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

Na parte 2 desta série de tutoriais, você se aprofunda um pouco mais nos recursos de build e depuração do Visual Studio necessários para o desenvolvimento diário. Esses recursos incluem o gerenciamento de vários projetos, a depuração e a referência a pacotes de terceiros. Você executa o aplicativo de console C# criado na parte 1 deste tutoriale explora alguns recursos do IDE (ambiente de desenvolvimento integrado) do Visual Studio. Este tutorial é a parte 2 de uma série de tutoriais de duas partes.

Neste tutorial, você concluirá as seguintes tarefas:

• Adicione um segundo projeto.
• Referencie bibliotecas e adicione pacotes.
• Depure seu código.
• Inspecione o código concluído.

Pré-requisitos

Para trabalhar neste artigo, você pode usar qualquer um desses aplicativos de calculadora:

• O aplicativo de console da calculadora da parte 1 deste tutorial.
• O aplicativo de calculadora C# no repositório vs-tutorial-samples. Para começar, abrir o aplicativo no repositório.

Adicionar outro projeto

O código do mundo real envolve projetos trabalhando juntos em uma solução. Você pode adicionar um projeto de biblioteca de classes ao aplicativo de calculadora que fornece algumas funções de calculadora.

No Visual Studio, você usa o comando de menu File>Add>New Project para adicionar um novo projeto. Você também pode clicar com o botão direito do mouse na solução no Gerenciador de Soluções para adicionar um projeto no menu de contexto.

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 de biblioteca de classes do C# e, em seguida, selecione Avançar.

   

3. Na tela Configurar seu novo projeto, digite o nome do projeto CalculatorLibrary e selecione Avançar.

4. Na tela Informações adicionais, o .NET 8.0 está selecionado. 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 arquivo, clique com o botão direito no nome no Gerenciador de Soluções e escolha Renomear, selecione o nome e pressione F2, ou selecione o nome e selecione novamente para digitar.

   Uma mensagem pode perguntar se você deseja renomear todas as referências para Class1 no arquivo. Não importa como você responde, pois você substituirá o código em uma etapa futura.

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

   

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

7. Na caixa de diálogo Gerenciador de Referências, marque a caixa de seleção do projeto CalculatorLibrary e selecione OK.

   

   A referência de projeto será exibida no nó Projetos no Gerenciador de Soluções.

   

8. Em Program.cs, selecione a classe Calculator e todo o código e pressione Ctrl+X para recortar. Em seguida, em CalculatorLibrary.cs, cole o código no namespace CalculatorLibrary.

   Adicione também public antes da classe Calculadora para torná-la acessível fora da biblioteca.

   CalculatorLibrary.cs agora deve ser semelhante 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. O Program.cs também tem uma referência, mas um erro diz que a chamada Calculator.DoOperation não está sendo resolvida. O erro ocorre porque CalculatorLibrary está em um namespace diferente. Para 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 que você remova 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.

Referenciar bibliotecas do .NET: gravar em um log

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 classe Trace está em System.Diagnosticse usa classes System.IO como StreamWriter.

1. Comece adicionando as diretivas using no topo do arquivo 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 um objeto, portanto, adicione um construtor no início da classe Calculator em CalculatorLibrary.cs.

   Remova também a palavra-chave static para alterar o método de 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 agora deve assemelhar-se ao 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. De volta ao Program.cs, um sublinhado ondulado vermelho agora sinaliza a chamada estática. Para corrigir o erro, crie uma variável calculator adicionando a seguinte linha de código pouco 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 letras minúsculas. O código agora é uma invocação 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 do mouse no nó de projeto Calculadora e escolha Abrir Pasta no Explorador de Arquivos.

6. No Explorador de Arquivos, navegue até a pasta de saída em bin/Debug/e abra o arquivo calculator.log. A saída deve ser semelhante a esta:

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

Neste ponto, CalculatorLibrary.cs deve ser semelhante 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;
        }
    }
}

Adicionar um pacote NuGet: gravar em um arquivo JSON

Para operações de saída no JSON, um formato popular e portátil para armazenar dados de objeto, você pode referenciar o pacote Newtonsoft.Json NuGet. Os pacotes NuGet são o método de distribuição principal para bibliotecas de classes do .NET.

1. No Gerenciador de Soluções, clique com o botão direito do mouse no nó Dependências do projeto CalculatorLibrary e escolha Gerenciar Pacotes NuGet.

   

   O Gerenciador de Pacotes NuGet é aberto.

2. Pesquise e selecione o pacote Newtonsoft.Json e selecione Instalar.

   

   Se você for solicitado a aceitar alterações, selecione OK.

   O Visual Studio baixa o pacote e o adiciona ao projeto. Uma nova entrada será exibida no nó Pacotes no Gerenciador de Soluções.

   Adicione uma diretiva using para Newtonsoft.Json no início do CalculatorLibrary.cs.

   // CalculatorLibrary.cs
   using Newtonsoft.Json;
   

3. Crie o objeto membro JsonWriter e substitua o construtor Calculator pelo seguinte código:

        // CalculatorLibrary.cs
        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();
        }
   

4. Modifique o método DoOperation para adicionar o código de writer JSON:

        // 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.
            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;
        }
   

5. Adicione um método para concluir a sintaxe JSON depois que o usuário terminar de inserir dados de operação.

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

6. No final do Program.cs, antes do return;, adicione uma chamada para Finish:

        // Program.cs
            // Add call to close the JSON writer before return
            calculator.Finish();
            return;
        }
   

7. Crie e execute o aplicativo e, depois de concluir a inserção de algumas operações, feche o aplicativo inserindo o comando n.

8. Abra o arquivo calculatorlog.json no Explorador de Arquivos. Você verá algo semelhante ao seguinte conteúdo:

   {
    "Operations": [
        {
        "Operand1": 2.0,
        "Operand2": 3.0,
        "Operation": "Add",
        "Result": 5.0
        },
        {
        "Operand1": 3.0,
        "Operand2": 4.0,
        "Operation": "Multiply",
        "Result": 12.0
        }
    ]
   }
   

Depurar: definição e ocorrência de um ponto de interrupção

O depurador do Visual Studio é uma ferramenta poderosa. O depurador pode percorrer seu código para encontrar o ponto exato em que há um erro de programação. Em seguida, você pode entender quais correções você precisa fazer e fazer alterações temporárias para poder continuar executando seu aplicativo.

1. Em Program.cs, clique na medianiz à esquerda da linha de código a seguir. Você também pode clicar na linha e selecionar F9, ou clicar com o botão direito do mouse na linha e selecionar Ponto de Interrupção>Inserir Ponto de Interrupção.

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

   O ponto vermelho exibido indica um ponto de interrupção. Você pode usar pontos de interrupção para pausar seu aplicativo e inspecionar o código. Você pode definir um ponto de interrupção em qualquer linha de código executável.

   

2. Crie e execute o aplicativo. Insira os seguintes valores para o cálculo:

   • Para o primeiro número, insira 8.
   • Para o segundo número, insira 0.
   • Para o operador, vamos nos divertir um pouco. Insira d.

   O aplicativo suspende onde você criou o ponto de interrupção, que é indicado pelo ponteiro amarelo à esquerda e pelo código realçado. O código realçado ainda não foi executado.

   captura de tela

   Agora, com o aplicativo suspenso, você pode inspecionar o estado do aplicativo.

Depurar: exibir variáveis

1. No código realçado, passe o mouse sobre variáveis como cleanNum1 e op. Os valores atuais dessas variáveis, 8 e d respectivamente, aparecem em Dicas de Dados.

   

   Ao depurar, verificar se as variáveis contêm os valores esperados geralmente é essencial para corrigir problemas.

2. No painel inferior, examine a janela Locais. Se estiver fechada, selecione Depurar>Janelas>Locais para abri-la.

   A janela Locais mostra cada variável que está atualmente no escopo, juntamente com o valor e tipo.

   

3. Dê uma olhada na janela Autos.

   A janela Autos é semelhante à janela Locais, mas mostra as variáveis imediatamente antes e depois da linha de código atual em que seu aplicativo está pausado.

   Nota

   Se você não vir a janela Autos, selecione Depurar>Janelas>Autos para abri-la.

Em seguida, execute o código no depurador, uma instrução por vez, o que é chamado de passo a passo.

Depurar: passar pelo código

1. Pressione F11 ou selecione Depurar>Entrar em.

   Usando o comando Step Into, o aplicativo executa a instrução atual e avança para a próxima instrução executável, geralmente a próxima linha de código. O ponteiro amarelo à esquerda sempre indica a instrução atual.

   

   Você acabou de intervir no método DoOperation na classe Calculator.

2. Para obter uma análise hierárquica no fluxo do programa, examine a janela Pilha de Chamadas. Se estiver fechada, selecione Depurar>Janelas>Pilha de Chamadas para abri-la.

   

   Essa exibição mostra o método Calculator.DoOperation atual, indicado pelo ponteiro amarelo. A segunda linha mostra a função que chamou o método, do método Main em Program.cs.

   A janela Pilha de Chamadas mostra a ordem em que os métodos e as funções são chamados. Essa janela também fornece acesso a muitos recursos do depurador, como Ir para o Código-Fonte, no menu de atalho.

3. Pressione F10 ou selecione Depurar>Step Over várias vezes até que o aplicativo pause na instrução switch.

   // CalculatorLibrary.cs
   switch (op)
   {
   

   O comando Step Over é semelhante ao comando Step Into, exceto que, se a instrução atual chamar uma função, o depurador executará o código na função e não suspenderá a execução até que a função retorne. O Step Over é mais rápido do que o Intervir, se você não estiver interessado em uma função específica.

4. Pressione F10 mais uma vez, para que o aplicativo pause na seguinte linha de código.

   // CalculatorLibrary.cs
   if (num2 != 0)
   {
   

   Esse código verifica se há um caso de divisão por zero. Se o aplicativo continuar, ele gerará uma exceção geral (um erro), mas talvez você queira tentar outra coisa, como exibir o valor real retornado no console. Uma opção é usar um recurso de depurador chamado edit-and-continue para fazer alterações no código e continuar a depuração. No entanto, há um truque diferente para modificar temporariamente o fluxo de execução.

Depurar: testar uma alteração temporária

1. Selecione o ponteiro amarelo, que está atualmente pausado na instrução if (num2 != 0), e arraste-o para a próxima instrução.

   // CalculatorLibrary.cs
   result = num1 / num2;
   

   Arrastar o ponteiro aqui faz com que o aplicativo ignore completamente a instrução if, para que você possa ver o que acontece quando você divide por zero.

2. Pressione F10 para executar a linha de código.

3. Se você passar o mouse sobre a variável result, ela mostrará um valor de Infinito. Em C#, o Infinito é o resultado quando você divide por zero.

4. Pressione F5 ou selecione Depurar>Continuar Depurando.

   O símbolo infinito aparece no console como resultado da operação matemática.

5. Feche o aplicativo corretamente inserindo o comando n.

Código concluído

Este é 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 este é 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;
        }
    }
}

Próximas etapas

Parabéns por concluir este tutorial! Para saber mais, continue com o seguinte conteúdo:

• Continuar com mais tutoriais em C#
• Início rápido: criar um aplicativo Web ASP.NET Core
• Aprenda a depurar código C# no Visual Studio
• passo a passo sobre como criar e executar testes de unidade
• executar um programa em C#
• Saiba mais sobre o IntelliSense do C#
• Continuar com a visão geral do IDE do Visual Studio
• Registro em log e rastreamento