Tutorial: Estender o aplicativo de console C# e depurar no Visual Studio (parte 2 de 2)

1. No Gerenciador de Soluções , clique com o botão direito do mouse no nó da solução e escolha Adicionar>Novo Projeto.

2. Na janela Adicionar um novo projeto, digite biblioteca de classes na caixa de pesquisa. Escolha o modelo de projeto da Biblioteca de Classes C# e depois selecione Próximo.

   

3. No ecrã Configurar o seu novo projeto , introduza o nome do projeto CalculatorLibrary e depois selecione Próximo.

4. No ecrã de informação adicional , selecione .NET 10.0 e depois selecione Criar.

   O Visual Studio cria o novo projeto e o adiciona à solução.

   

5. Renomeie o arquivo Class1.cs para CalculatorLibrary.cs. Para renomear o ficheiro, pode clicar com o botão direito no nome no Explorador de Soluções e escolher Renomear, selecionar o nome e pressionar F2, ou selecionar o nome e selecionar novamente para escrever.

   Uma mensagem pode perguntar se você deseja renomear todas as referências para Class1 no arquivo. Não importa como respondes, porque substitues o código numa etapa futura.

6. Adicione uma referência de projeto, que permite ao primeiro projeto usar APIs que a nova biblioteca de classes expõe. Clique com o botão direito do rato no nó Dependências no projeto Calculadora e escolha Adicionar Referência de Projeto.

   

   A caixa de diálogo Reference Manager é exibida. Nesta caixa de diálogo, você pode adicionar referências a outros projetos, assemblies e DLLs COM que seus projetos precisam.

7. Na caixa de diálogo Gestor de Referências, selecione a caixa de seleção para CalculatorLibrary e depois selecione OK.

   

   A referência do projeto aparece sob um nó Projetos no Gerenciador de Soluções .

   

8. No Program.cs, selecione a classe Calculator e todo o seu código e pressione Ctrl+X para cortá-la. Em seguida, no CalculatorLibrary.cs, cole o código no namespace CalculatorLibrary.

   Adicione também public antes da classe Calculator para expô-la fora da biblioteca.

   CalculatorLibrary.cs agora deve se assemelhar ao seguinte código:

    // CalculatorLibrary.cs
    namespace CalculatorLibrary
    {
        public class Calculator
        {
            public static double DoOperation(double num1, double num2, string op)
            {
                double result = double.NaN; // Default value is "not-a-number" if an operation, such as division, could result in an error.
   
                // Use a switch statement to do the math.
                switch (op)
                {
                    case "a":
                        result = num1 + num2;
                        break;
                    case "s":
                        result = num1 - num2;
                        break;
                    case "m":
                        result = num1 * num2;
                        break;
                    case "d":
                        // Ask the user to enter a non-zero divisor.
                        if (num2 != 0)
                        {
                            result = num1 / num2;
                        }
                        break;
                    // Return text for an incorrect option entry.
                    default:
                        break;
                }
                return result;
            }
        }
    }
   

9. Program.cs também tem uma referência, mas um erro diz que a chamada Calculator.DoOperation não é resolvida. O erro é porque CalculatorLibrary está em um namespace diferente. Para obter uma referência totalmente qualificada, você pode adicionar o namespace CalculatorLibrary à chamada Calculator.DoOperation em Program.cs:

   // Program.cs
   result = CalculatorLibrary.Calculator.DoOperation(cleanNum1, cleanNum2, op);
   

   Ou, você pode tentar adicionar uma diretiva using ao início do arquivo Program.cs:

   // Program.cs
   using CalculatorLibrary;
   

   Adicionar a diretiva using deve permitir remover o namespace CalculatorLibrary do site de chamada.

   Se o código Program.cs estiver no namespace Calculator, renomeie o namespace de Calculator para CalculatorProgram para remover a ambiguidade entre o nome da classe e o nome do namespace.

Você pode usar a classe .NET Trace para adicionar um log de todas as operações e gravá-lo em um arquivo de texto. A classe Trace também é útil para técnicas básicas de depuração de impressão. A Trace classe está em System.Diagnostics. Utiliza System.IO classes como StreamWriter.

1. Comece por adicionar as using diretivas no topo de CalculatorLibrary.cs:

   // CalculatorLibrary.cs
   using System.Diagnostics;
   

2. Esse uso da classe Trace deve manter uma referência para a classe, que ela associa a um fluxo de arquivos. Esse requisito significa que a calculadora funciona melhor como objeto. Adicione um construtor no início da classe Calculator em CalculatorLibrary.cs.

   Remova também a palavra-chave static para alterar o método DoOperation estático em um método membro.

   // CalculatorLibrary.cs
   public Calculator()
      {
          StreamWriter logFile = File.CreateText("calculator.log");
          Trace.Listeners.Add(new TextWriterTraceListener(logFile));
          Trace.AutoFlush = true;
          Trace.WriteLine("Starting Calculator Log");
          Trace.WriteLine(String.Format("Started {0}", System.DateTime.Now.ToString()));
      }
   
   public double DoOperation(double num1, double num2, string op)
      {
   

3. Adicione a saída de log a cada cálculo. DoOperation deverá agora parecer-se com o seguinte código:

   // CalculatorLibrary.cs
   public double DoOperation(double num1, double num2, string op)
   {
        double result = double.NaN; // Default value is "not-a-number" if an operation, such as division, could result in an error.
   
        // Use a switch statement to do the math.
        switch (op)
        {
            case "a":
                result = num1 + num2;
                Trace.WriteLine(String.Format("{0} + {1} = {2}", num1, num2, result));
                break;
            case "s":
                result = num1 - num2;
                Trace.WriteLine(String.Format("{0} - {1} = {2}", num1, num2, result));
                break;
            case "m":
                result = num1 * num2;
                Trace.WriteLine(String.Format("{0} * {1} = {2}", num1, num2, result));
                break;
            case "d":
                // Ask the user to enter a non-zero divisor.
                if (num2 != 0)
                {
                    result = num1 / num2;
                    Trace.WriteLine(String.Format("{0} / {1} = {2}", num1, num2, result));
                }
                    break;
            // Return text for an incorrect option entry.
            default:
                break;
        }
        return result;
    }
   

4. Em Program.cs, uma linha vermelha ondulada agora marca a chamada estática. Para corrigir o erro, crie uma variável calculator adicionando a seguinte linha de código imediatamente antes do loop while (!endApp):

   // Program.cs
   Calculator calculator = new Calculator();
   

   Modifique também o site de chamada DoOperation para fazer referência ao objeto chamado calculator em minúsculas. O código agora é uma chamada de membro, em vez de uma chamada para um método estático.

   // Program.cs
   result = calculator.DoOperation(cleanNum1, cleanNum2, op);
   

5. Execute o aplicativo novamente. Quando terminar, clique com o botão direito no nó do projeto Calculadora de e escolha Abrir Pasta no Explorador do Windows.

6. No Explorador de Ficheiros, navegue até à pasta de saída em bin/Debug/e abra o ficheiro calculator.log. A saída deve ser algo como isto:

   Starting Calculator Log
   Started 7/9/2020 1:58:19 PM
   1 + 2 = 3
   3 * 3 = 9
   

Neste ponto, CalculatorLibrary.cs deve se assemelhar a este código:

// CalculatorLibrary.cs
using System.Diagnostics;

namespace CalculatorLibrary
{
    public class Calculator
    {

        public Calculator()
        {
            StreamWriter logFile = File.CreateText("calculator.log");
            Trace.Listeners.Add(new TextWriterTraceListener(logFile));
            Trace.AutoFlush = true;
            Trace.WriteLine("Starting Calculator Log");
            Trace.WriteLine(String.Format("Started {0}", System.DateTime.Now.ToString()));
        }

        public double DoOperation(double num1, double num2, string op)
        {
            double result = double.NaN; // Default value is "not-a-number" if an operation, such as division, could result in an error.

            // Use a switch statement to do the math.
            switch (op)
            {
                case "a":
                    result = num1 + num2;
                    Trace.WriteLine(String.Format("{0} + {1} = {2}", num1, num2, result));
                    break;
                case "s":
                    result = num1 - num2;
                    Trace.WriteLine(String.Format("{0} - {1} = {2}", num1, num2, result));
                    break;
                case "m":
                    result = num1 * num2;
                    Trace.WriteLine(String.Format("{0} * {1} = {2}", num1, num2, result));
                    break;
                case "d":
                    // Ask the user to enter a non-zero divisor.
                    if (num2 != 0)
                    {
                        result = num1 / num2;
                        Trace.WriteLine(String.Format("{0} / {1} = {2}", num1, num2, result));
                    }
                    break;
                // Return text for an incorrect option entry.
                default:
                    break;
            }
            return result;
        }
    }
}

Program.cs deve ser semelhante ao seguinte código:

// Program.cs
using CalculatorLibrary;

namespace CalculatorProgram
{

    class Program
    {
        static void Main(string[] args)
        {
            bool endApp = false;
            // Display title as the C# console calculator app.
            Console.WriteLine("Console Calculator in C#\r");
            Console.WriteLine("------------------------\n");

            Calculator calculator = new Calculator();
            while (!endApp)
            {
                // Declare variables and set to empty.
                // Use Nullable types (with ?) to match type of System.Console.ReadLine
                string? numInput1 = "";
                string? numInput2 = "";
                double result = 0;

                // Ask the user to type the first number.
                Console.Write("Type a number, and then press Enter: ");
                numInput1 = Console.ReadLine();

                double cleanNum1 = 0;
                while (!double.TryParse(numInput1, out cleanNum1))
                {
                    Console.Write("This is not valid input. Please enter an integer value: ");
                    numInput1 = Console.ReadLine();
                }

                // Ask the user to type the second number.
                Console.Write("Type another number, and then press Enter: ");
                numInput2 = Console.ReadLine();

                double cleanNum2 = 0;
                while (!double.TryParse(numInput2, out cleanNum2))
                {
                    Console.Write("This is not valid input. Please enter an integer value: ");
                    numInput2 = Console.ReadLine();
                }

                // Ask the user to choose an operator.
                Console.WriteLine("Choose an operator from the following list:");
                Console.WriteLine("\ta - Add");
                Console.WriteLine("\ts - Subtract");
                Console.WriteLine("\tm - Multiply");
                Console.WriteLine("\td - Divide");
                Console.Write("Your option? ");

                string? op = Console.ReadLine();

                // Validate input is not null, and matches the pattern
                if (op == null || ! Regex.IsMatch(op, "[a|s|m|d]"))
                {
                   Console.WriteLine("Error: Unrecognized input.");
                }
                else
                { 
                   try
                   {
                       result = calculator.DoOperation(cleanNum1, cleanNum2, op); 
                       if (double.IsNaN(result))
                       {
                           Console.WriteLine("This operation will result in a mathematical error.\n");
                       }
                       else Console.WriteLine("Your result: {0:0.##}\n", result);
                   }
                   catch (Exception e)
                   {
                       Console.WriteLine("Oh no! An exception occurred trying to do the math.\n - Details: " + e.Message);
                   }
                }
                Console.WriteLine("------------------------\n");

                // Wait for the user to respond before closing.
                Console.Write("Press 'n' and Enter to close the app, or press any other key and Enter to continue: ");
                if (Console.ReadLine() == "n") endApp = true;

                Console.WriteLine("\n"); // Friendly linespacing.
            }
            return;
        }
    }
}

Aqui está o código completo para o arquivo CalculatorLibrary.cs, depois de concluir todas as etapas:

// CalculatorLibrary.cs
using Newtonsoft.Json;

namespace CalculatorLibrary
{
    public class Calculator
    {

        JsonWriter writer;

        public Calculator()
        {
            StreamWriter logFile = File.CreateText("calculatorlog.json");
            logFile.AutoFlush = true;
            writer = new JsonTextWriter(logFile);
            writer.Formatting = Formatting.Indented;
            writer.WriteStartObject();
            writer.WritePropertyName("Operations");
            writer.WriteStartArray();
        }

        public double DoOperation(double num1, double num2, string op)
        {
            double result = double.NaN; // Default value is "not-a-number" if an operation, such as division, could result in an error.
            writer.WriteStartObject();
            writer.WritePropertyName("Operand1");
            writer.WriteValue(num1);
            writer.WritePropertyName("Operand2");
            writer.WriteValue(num2);
            writer.WritePropertyName("Operation");
            // Use a switch statement to do the math.
            switch (op)
            {
                case "a":
                    result = num1 + num2;
                    writer.WriteValue("Add");
                    break;
                case "s":
                    result = num1 - num2;
                    writer.WriteValue("Subtract");
                    break;
                case "m":
                    result = num1 * num2;
                    writer.WriteValue("Multiply");
                    break;
                case "d":
                    // Ask the user to enter a non-zero divisor.
                    if (num2 != 0)
                    {
                        result = num1 / num2;
                    }
                    writer.WriteValue("Divide");
                    break;
                // Return text for an incorrect option entry.
                default:
                    break;
            }
            writer.WritePropertyName("Result");
            writer.WriteValue(result);
            writer.WriteEndObject();

            return result;
        }

        public void Finish()
        {
            writer.WriteEndArray();
            writer.WriteEndObject();
            writer.Close();
        }
    }
}

E aqui está o código para Program.cs:

// Program.cs
using CalculatorLibrary;

namespace CalculatorProgram
{

    class Program
    {
        static void Main(string[] args)
        {
            bool endApp = false;
            // Display title as the C# console calculator app.
            Console.WriteLine("Console Calculator in C#\r");
            Console.WriteLine("------------------------\n");

            Calculator calculator = new Calculator();
            while (!endApp)
            {
                // Declare variables and set to empty.
                // Use Nullable types (with ?) to match type of System.Console.ReadLine
                string? numInput1 = "";
                string? numInput2 = "";
                double result = 0;

                // Ask the user to type the first number.
                Console.Write("Type a number, and then press Enter: ");
                numInput1 = Console.ReadLine();

                double cleanNum1 = 0;
                while (!double.TryParse(numInput1, out cleanNum1))
                {
                    Console.Write("This is not valid input. Please enter an integer value: ");
                    numInput1 = Console.ReadLine();
                }

                // Ask the user to type the second number.
                Console.Write("Type another number, and then press Enter: ");
                numInput2 = Console.ReadLine();

                double cleanNum2 = 0;
                while (!double.TryParse(numInput2, out cleanNum2))
                {
                    Console.Write("This is not valid input. Please enter an integer value: ");
                    numInput2 = Console.ReadLine();
                }

                // Ask the user to choose an operator.
                Console.WriteLine("Choose an operator from the following list:");
                Console.WriteLine("\ta - Add");
                Console.WriteLine("\ts - Subtract");
                Console.WriteLine("\tm - Multiply");
                Console.WriteLine("\td - Divide");
                Console.Write("Your option? ");

                string? op = Console.ReadLine();

                // Validate input is not null, and matches the pattern
                if (op == null || ! Regex.IsMatch(op, "[a|s|m|d]"))
                {
                   Console.WriteLine("Error: Unrecognized input.");
                }
                else
                { 
                   try
                   {
                       result = calculator.DoOperation(cleanNum1, cleanNum2, op); 
                       if (double.IsNaN(result))
                       {
                           Console.WriteLine("This operation will result in a mathematical error.\n");
                       }
                       else Console.WriteLine("Your result: {0:0.##}\n", result);
                   }
                   catch (Exception e)
                   {
                       Console.WriteLine("Oh no! An exception occurred trying to do the math.\n - Details: " + e.Message);
                   }
                }
                Console.WriteLine("------------------------\n");

                // Wait for the user to respond before closing.
                Console.Write("Press 'n' and Enter to close the app, or press any other key and Enter to continue: ");
                if (Console.ReadLine() == "n") endApp = true;

                Console.WriteLine("\n"); // Friendly linespacing.
            }
            calculator.Finish();
            return;
        }
    }
}