Zelfstudie: C#-console-app uitbreiden en fouten opsporen in Visual Studio (deel 2 van 2)

In deel 2 van deze reeks zelfstudies gaat u wat dieper in op de Visual Studio-build- en foutopsporingsfuncties die u nodig hebt voor dagelijkse ontwikkeling. Deze functies omvatten het beheren van meerdere projecten, foutopsporing en het verwijzen naar pakketten van derden. U voert de C#-console-app uit die u hebt gemaakt in deel 1 van deze zelfstudieen verken enkele functies van de IDE (Integrated Development Environment) van Visual Studio. Deze zelfstudie is deel 2 van een tweedelige reeks zelfstudies.

In deze zelfstudie voert u de volgende taken uit:

• Voeg een tweede project toe.
• Referentiebibliotheken en pakketten toevoegen.
• Fouten opsporen in uw code.
• Inspecteer de voltooide code.

Voorwaarden

Als u dit artikel wilt doorlopen, kunt u een van deze rekenmachine-apps gebruiken:

• De console-app van de rekenmachine uit deel 1 van deze zelfstudie.
• De C# calculatorapp in de vs-tutorial-samples-opslagplaats . Om te beginnen, open de app vanuit de repository.

Nog een project toevoegen

Echte code omvat projecten die samenwerken in een oplossing. U kunt een klassebibliotheekproject toevoegen aan uw rekenmachine-app die enkele rekenmachinefuncties biedt.

In Visual Studio gebruikt u de menuopdracht File>Add>New Project om een nieuw project toe te voegen. U kunt ook met de rechtermuisknop op de oplossing klikken in Solution Explorer om een project toe te voegen vanuit het contextmenu.

1. Klik in Solution Explorermet de rechtermuisknop op het oplossingsknooppunt en kies Add>New Project.

2. Typ in het venster Een nieuw project toevoegen in het zoekvak de klassebibliotheek. Kies de C# Class Library projectsjabloon en klik vervolgens op Volgende.

   

3. Voer op het scherm Uw nieuwe project configureren de projectnaam CalculatorLibraryin en selecteer vervolgens Volgende.

4. In het scherm Aanvullende informatie is .NET 8.0 geselecteerd. Selecteer maken.

   Visual Studio maakt het nieuwe project en voegt het toe aan de oplossing.

   

5. Wijzig de naam van het Class1.cs-bestand in CalculatorLibrary.cs. Als u de naam van het bestand wilt wijzigen, klikt u met de rechtermuisknop op de naam in Solution Explorer en kiest u Naam wijzigen, selecteert u de naam en drukt u op F2of selecteert u de naam en selecteert u opnieuw om te typen.

   Een bericht kan vragen of u de naam van alle verwijzingen naar Class1 in het bestand wilt wijzigen. Het maakt niet uit hoe u antwoordt, omdat u de code in een toekomstige stap vervangt.

6. Voeg nu een projectreferentie toe, zodat het eerste project API's kan gebruiken die door de nieuwe klassebibliotheek worden weergegeven. Rechtsklik op het knooppunt Afhankelijkheden in het Calculatorproject en kies Verwijzing naar project toevoegen.

   

   Het dialoogvenster Reference Manager wordt weergegeven. In dit dialoogvenster kunt u verwijzingen toevoegen naar andere projecten, assembly's en COM-DLL's die uw projecten nodig hebben.

7. Schakel in het dialoogvenster Reference Manager het selectievakje in voor het project CalculatorLibrary en selecteer vervolgens OK.

   

   De projectverwijzing wordt weergegeven onder een knooppunt Projects in Solution Explorer.

   

8. Selecteer in Program.csde Calculator-klasse en alle bijbehorende code en druk op Ctrl+X- om deze te knippen. Plak vervolgens in CalculatorLibrary.csde code in de CalculatorLibrary naamruimte.

   Voeg ook public toe vóór de klasse Calculator om deze buiten de bibliotheek beschikbaar te maken.

   CalculatorLibrary.cs moet nu lijken op de volgende code:

    // 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 bevat ook een verwijzing, maar er is een fout die aangeeft dat de Calculator.DoOperation oproep niet kan worden opgelost. De fout komt doordat CalculatorLibrary zich in een andere naamruimte bevindt. Voor een volledig gekwalificeerde verwijzing kunt u de CalculatorLibrary naamruimte toevoegen aan de Calculator.DoOperation aanroep in Program.cs:

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

   U kunt ook proberen een using instructie toe te voegen aan het begin van het Program.cs-bestand:

   // Program.cs
   using CalculatorLibrary;
   

   Als u de using-instructie toevoegt, kunt u de CalculatorLibrary naamruimte van de aanroepsite verwijderen.

   Als uw Program.cs code zich in de Calculator naamruimte bevindt, wijzigt u de naamruimte van Calculator in CalculatorProgram om dubbelzinnigheid tussen klassenaam en naamruimtenaam te verwijderen.

Naslaginformatie over .NET-bibliotheken: schrijven naar een logboek

U kunt de klasse .NET Trace gebruiken om een logboek van alle bewerkingen toe te voegen en naar een tekstbestand te schrijven. De Trace-klasse is ook handig voor eenvoudige technieken voor foutopsporing voor afdrukken. De Trace klasse bevindt zich in System.Diagnosticsen gebruikt System.IO klassen zoals StreamWriter.

1. Begin met het toevoegen van de using instructies bovenaan CalculatorLibrary.cs:

   // CalculatorLibrary.cs
   using System.Diagnostics;
   

2. Dit gebruik van de Trace-klasse moet een verwijzing bevatten voor de klasse die wordt gekoppeld aan een filestream. Deze vereiste betekent dat de rekenmachine beter werkt als een object, dus voeg een constructor toe aan het begin van de Calculator-klasse in CalculatorLibrary.cs.

   Verwijder ook het trefwoord static om de statische DoOperation methode te wijzigen in een lidmethode.

   // 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. Logboekuitvoer toevoegen aan elke berekening. DoOperation moet er nu uitzien als de volgende code:

   // 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. Terug in Program.csmarkeert een rode golvende onderstreping nu de statische aanroep. Als u de fout wilt oplossen, maakt u een calculator variabele door de volgende coderegel toe te voegen vlak vóór de while (!endApp) lus:

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

   Wijzig ook de DoOperation aanroepsite om te verwijzen naar het object met de naam calculator in kleine letters. De code is nu een ledenaanroep, in plaats van een aanroep naar een statische methode.

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

5. Voer de app opnieuw uit. Wanneer u klaar bent, klikt u met de rechtermuisknop op het Rekenmachine projectknooppunt en kiest u Map openen in Windows Verkenner.

6. Navigeer in Verkenner naar de uitvoermap onder bin/Debug/en open het calculator.log bestand. De uitvoer ziet er ongeveer als volgt uit:

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

Op dit moment moet CalculatorLibrary.cs lijken op deze code:

// 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 moet eruitzien als de volgende code:

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

Een NuGet-pakket toevoegen: schrijven naar een JSON-bestand

Als u bewerkingen wilt uitvoeren in JSON, een populaire en draagbare indeling voor het opslaan van objectgegevens, kunt u verwijzen naar het Newtonsoft.Json NuGet-pakket. NuGet-pakketten zijn de primaire distributiemethode voor .NET-klassebibliotheken.

1. Klik in Solution Explorermet de rechtermuisknop op het knooppunt Afhankelijkheden voor het CalculatorLibrary-project en kies NuGet-pakketten beheren.

   

   NuGet Package Manager wordt geopend.

2. Zoek naar en selecteer het pakket Newtonsoft.Json en selecteer Installeren.

   

   Als u wordt gevraagd of u wijzigingen wilt accepteren, selecteert u OK-.

   Visual Studio downloadt het pakket en voegt het toe aan het project. Er wordt een nieuwe vermelding in een Pakketten-knooppunt weergegeven in Solution Explorer.

   Voeg aan het begin van usingeen Newtonsoft.Json toe voor .

   // CalculatorLibrary.cs
   using Newtonsoft.Json;
   

3. Maak het JsonWriter lidobject en vervang de Calculator constructor door de volgende code:

        // 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. Wijzig de methode DoOperation om de JSON-writer-code toe te voegen:

        // 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. Voeg een methode toe om de JSON-syntaxis te voltooien zodra de gebruiker klaar is met het invoeren van bewerkingsgegevens.

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

6. Voeg aan het einde van Program.csvóór het return;een aanroep toe aan Finish:

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

7. Bouw en voer de app uit. Nadat u een paar bewerkingen hebt ingevoerd, sluit u de app door de opdracht n in te voeren.

8. Open het bestand calculatorlog.json in Verkenner. Als het goed is, ziet u ongeveer de volgende inhoud:

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

Fouten opsporen: een onderbrekingspunt instellen en bereiken

Het Visual Studio-foutopsporingsprogramma is een krachtig hulpprogramma. Het foutopsporingsprogramma kan uw code doorlopen om het exacte punt te vinden waar zich een programmeerfout voordeed. U kunt vervolgens begrijpen welke correcties u moet aanbrengen en tijdelijke wijzigingen aanbrengen, zodat u uw app kunt blijven uitvoeren.

1. Klik in Program.csin de marge links van de volgende coderegel. U kunt ook op de regel klikken en F9-selecteren of met de rechtermuisknop op de lijn klikken en onderbrekingspunt selecteren>Onderbrekingspunt invoegen.

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

   De rode stip die wordt weergegeven, geeft een onderbrekingspunt aan. U kunt onderbrekingspunten gebruiken om uw app te onderbreken en code te inspecteren. U kunt een onderbrekingspunt instellen op elke uitvoerbare coderegel.

   

2. Bouw en voer de app uit. Voer de volgende waarden in voor de berekening:

   • Voer voor het eerste getal 8in.
   • Voer voor het tweede getal 0in.
   • Laten we wat plezier hebben voor de operator. Voer din.

   De app onderbreekt waar u het onderbrekingspunt hebt gemaakt, wat wordt aangegeven door de gele aanwijzer aan de linkerkant en de gemarkeerde code. De gemarkeerde code is nog niet uitgevoerd.

   

   Nu de app is onderbroken, kunt u de status van uw toepassing inspecteren.

Fouten opsporen: Variabelen weergeven

1. Beweeg in de gemarkeerde code de muisaanwijzer over variabelen zoals cleanNum1 en op. De huidige waarden voor deze variabelen, respectievelijk 8 en d, worden weergegeven in DataTips.

   

   Bij het debuggen is het vaak cruciaal om te controleren of variabelen de waarden bevatten die u verwacht, om problemen op te lossen.

2. Bekijk in het onderste deelvenster het Locals venster. Als het gesloten is, selecteert u Debuggen>Windows>Locals om het te openen.

   In het venster Locals wordt elke variabele weergegeven die momenteel binnen het bereik valt, samen met de waarde en het type.

   

3. Bekijk het venster Autos.

   Het venster Autos is vergelijkbaar met het venster Locals, maar toont de variabelen die direct voorafgaan en de huidige coderegel volgen waarop uw app is onderbroken.

   Notitie

   Als u het venster Automatisch niet ziet, selecteert u Foutopsporing>Windows>Autos om het te openen.

Voer vervolgens de code in de debugger stap voor stap uit, wat stappenwordt genoemd.

Fouten opsporen: stapsgewijze code doorlopen

1. Druk op F11of selecteer Debuggen>Stap in.

   Met behulp van de opdracht Stap in voert de applicatie de huidige instructie uit en gaat naar de volgende uitvoerbare instructie, meestal de volgende regel van code. De gele aanwijzer aan de linkerkant geeft altijd de huidige instructie aan.

   

   U hebt net de DoOperation methode betreden in de Calculator klasse.

2. Als u een hiërarchische weergave van uw programmastroom wilt zien, bekijkt u het venster Aanroepstack. Als dit is gesloten, selecteert u Foutopsporing>Windows>Aanroepstack om het te openen.

   

   In deze weergave ziet u de huidige methode Calculator.DoOperation, aangegeven door de gele aanwijzer. In de tweede rij ziet u de functie die de methode heeft aangeroepen, afkomstig uit de Main-methode in Program.cs.

   In het venster Aanroepstack ziet u de volgorde waarin methoden en functies worden aangeroepen. Dit venster biedt ook toegang tot veel functies voor foutopsporingsprogramma's, zoals Ga naar broncode, vanuit het snelmenu.

3. Druk op F10of selecteer Debuggen>Overstappen, meerdere keren totdat de app pauzeert bij de switch-instructie.

   // CalculatorLibrary.cs
   switch (op)
   {
   

   De opdracht Stap over is vergelijkbaar met de opdracht Stap in, behalve dat als de huidige instructie een functie aanroept, het foutopsporingsprogramma de code in de functie uitvoert en de uitvoering niet onderbreekt totdat de functie wordt geretourneerd. Step Over is sneller dan Stap in als u niet geïnteresseerd bent in een bepaalde functie.

4. Druk nog een keer op F10, zodat de app pauzeert op de volgende regel code.

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

   Met deze code wordt gecontroleerd op een geval van delen door nul. Als de app doorgaat, wordt er een algemene uitzondering (een fout) gegenereerd, maar wilt u misschien iets anders proberen, zoals het weergeven van de werkelijke geretourneerde waarde in de console. Een optie is om een foutopsporingsprogrammafunctie te gebruiken met de naam bewerken en doorgaan om wijzigingen aan te brengen in de code en vervolgens door te gaan met foutopsporing. Er is echter een andere truc om de uitvoeringsstroom tijdelijk te wijzigen.

Fouten opsporen: een tijdelijke wijziging testen

1. Selecteer de gele aanwijzer, die momenteel is onderbroken op de instructie if (num2 != 0) en sleep deze naar de volgende instructie:

   // CalculatorLibrary.cs
   result = num1 / num2;
   

   Als u de aanwijzer hier sleept, wordt de if-instructie volledig overgeslagen, zodat u kunt zien wat er gebeurt wanneer u door nul deelt.

2. Druk op F10- om de coderegel uit te voeren.

3. Als u de muisaanwijzer over de variabele result beweegt, wordt er een waarde van Infinityweergegeven. In C# is Infinity het resultaat wanneer u door nul deelt.

4. Druk op F5of selecteer Debuggen>Doorgaan met Debuggen.

   Het oneindigheidssymbool wordt weergegeven in de console als resultaat van de wiskundige bewerking.

5. Sluit de app correct door de opdracht n in te voeren.

Code voltooid

Hier volgt de volledige code voor het CalculatorLibrary.cs-bestand, nadat u alle stappen hebt voltooid:

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

En hier is de code voor 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;
        }
    }
}

Volgende stappen

Gefeliciteerd met het voltooien van deze zelfstudie. Ga verder met de volgende inhoud voor meer informatie:

• Ga verder met meer C#-zelfstudies
• Quickstart: Een ASP.NET Core-web-app maken
• Meer informatie over het opsporen van fouten in C#-code in Visual Studio
• Stapsgewijze instructies voor het maken en uitvoeren van eenheidstests
• een C#-programma uitvoeren
• Meer informatie over C# IntelliSense-
• Ga verder met het overzicht van Visual Studio IDE
• logboekregistratie en tracering