Oktatóanyag: C#-konzolalkalmazás kiterjesztése és hibakeresés a Visual Studióban (2. rész, 2. rész)

Az oktatóanyag-sorozat 2. részében egy kicsit részletesebben megismerkedhet a Visual Studio napi fejlesztéshez szükséges buildelési és hibakeresési funkcióival. Ezek a funkciók közé tartozik a több projekt kezelése, a hibakeresés és a külső csomagokra való hivatkozás. Az oktatóanyag 1. részében létrehozott C#-konzolalkalmazástfuttatja, és megismeri a Visual Studio integrált fejlesztői környezetének (IDE) néhány funkcióját. Ez az oktatóanyag egy kétrészes oktatóanyag-sorozat 2. része.

Ebben az oktatóanyagban a következő feladatokat hajtja végre:

• Adjon hozzá egy második projektet.
• Referenciatárak és csomagok hozzáadása.
• Hibakeresés a kódban.
• Vizsgálja meg a kész kódot.

Előfeltételek

A cikk használatához használhatja az alábbi számológép-alkalmazásokat:

• Az oktatóanyag 1. részében szereplő számológép konzolalkalmazás.
• A C# számológép alkalmazás a vs-tutorial-samples adattárban. Első lépésként nyissa meg az alkalmazást az adattárból.

Másik projekt hozzáadása

A valós kód magában foglalja a megoldásokban közösen dolgozó projekteket. Hozzáadhat egy osztálykönyvtár projektet a számológép alkalmazáshoz, amely bizonyos számológép funkciókat biztosít.

A Visual Studióban a Fájl>>Új projekt hozzáadása parancsot használhatja új projekt hozzáadásához. A Megoldáskezelő a megoldásra a jobb gombbal kattintva is hozzáadhat egy projektet a helyi menüből.

1. A Megoldáskezelőbenkattintson a jobb gombbal a megoldáscsomópontra, és válassza a Hozzáadás>Új projektlehetőséget.

2. Az Új projekt hozzáadása ablakban írja be osztálytár a Keresőmezőbe. Válassza a C# Osztálytár projektsablont, majd válassza a Továbblehetőséget.

   

3. Az Új projekt konfigurálása képernyőn írja be a projekt nevét CalculatorLibrary, majd válassza a Továbblehetőséget.

4. A További információk képernyőn .NET 8.0 van kiválasztva. Válassza a és hozza létre aelemet.

   A Visual Studio létrehozza az új projektet, és hozzáadja a megoldáshoz.

   

5. Nevezze át a Class1.cs fájlt CalculatorLibrary.cs. A fájl átnevezéséhez kattintson a jobb gombbal a névre Megoldáskezelő, és válassza az Átnevezéslehetőséget, jelölje ki a nevet, és nyomja le F2, vagy jelölje ki a nevet, majd válassza ki újra a beíráshoz.

   Egy üzenet megkérdezheti, hogy át szeretné-e nevezni a fájlban lévő Class1 összes hivatkozását. Nem számít, hogyan válaszol, mert egy későbbi lépésben lecseréli a kódot.

6. Most adjon hozzá egy projekthivatkozást, hogy az első projekt az új osztálytár által közzétett API-kat használhassa. Kattintson a jobb gombbal a Függőségek csomópontra a Számológép projektben, és válassza a Projekthivatkozás hozzáadásalehetőséget.

   

   Megjelenik a Reference Manager párbeszédpanel. Ebben a párbeszédpanelen más projektekre, szerelvényekre és COM-DLL-ekre mutató hivatkozásokat adhat hozzá, amelyekre a projekteknek szükségük van.

7. A Reference Manager párbeszédpanelen jelölje be a CalculatorLibrary projekt jelölőnégyzetét, majd válassza OKlehetőséget.

   

   A projekthivatkozás a MegoldáskezelőProjektek csomópontja alatt jelenik meg.

   

8. A Program.cs-ben válassza ki a Calculator osztályt és annak teljes kódját, majd nyomja meg a Ctrl+X gombokat a kivágáshoz. Ezután illessze be a kódot CalculatorLibrary.csa CalculatorLibrary névtérbe.

   Adja hozzá a public a Számológép osztály elé, hogy közzétehesse azt a könyvtáron kívül.

   CalculatorLibrary.cs most a következő kódhoz kell hasonlítania:

    // 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 is rendelkezik hivatkozással, de egy hiba azt jelzi, hogy a Calculator.DoOperation hívás nem oldható fel. A hiba az, hogy CalculatorLibrary egy másik névtérben van. Teljes körű hivatkozáshoz hozzáadhatja a CalculatorLibrary névteret a Calculator.DoOperation híváshoz a Program.cs:

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

   Vagy megpróbálhat hozzáadni egy using direktívát a Program.cs fájl elejéhez:

   // Program.cs
   using CalculatorLibrary;
   

   A using irányelv hozzáadásával eltávolíthatja a CalculatorLibrary névteret a hívási helyről.

   Ha a Program.cs kód a Calculator névtérben van, nevezze át a névteret Calculator-ről CalculatorProgram az osztálynév és a névtér neve közötti kétértelműség eltávolításához.

.NET könyvtárak referenciája: Írás a naplóba

A .NET Trace osztály használatával minden művelet naplóját hozzáadhatja, és egy szövegfájlba írhatja. A Trace osztály az alapvető nyomtatási hibakeresési technikákhoz is hasznos. A Trace osztály System.Diagnosticsvan, és System.IO osztályokat használ, például StreamWriter.

1. Először vegye fel a using irányelveket a CalculatorLibrary.cstetejére:

   // CalculatorLibrary.cs
   using System.Diagnostics;
   

2. A Trace osztálynak meg kell őriznie az osztályra vonatkozó hivatkozást, amelyet fájlstreamhez társít. Ez a követelmény azt jelenti, hogy a számológép objektumként jobban működik, ezért adjon hozzá egy konstruktort a Calculator osztály elején CalculatorLibrary.cs.

   A statikus static metódus tagmetódussá alakításához távolítsa el a DoOperation kulcsszót is.

   // 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. Adjon hozzá naplókimenetet minden számításhoz. DoOperation most a következő kódhoz hasonlóan kell kinéznie:

   // 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. Az Program.csfájlban most egy piros hullámos aláhúzás jelzi a statikus hívást. A hiba kijavításához hozzon létre egy calculator változót úgy, hogy hozzáadja a következő kódsort a while (!endApp) ciklus előtt:

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

   Módosítsa a DoOperation híváswebhelyet is, hogy kisbetűvel hivatkozzon a calculator nevű objektumra. A kód mostantól taghívásként működik, nem pedig statikus függvény hívásaként.

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

5. Futtassa újra az alkalmazást. Ha végzett, kattintson a jobb gombbal a Számológép projektcsomópontra, és válassza Mappa megnyitása a Fájlkezelőbenlehetőséget.

6. A Fájlkezelőben keresse meg a kimeneti mappát a bin/Debug/területen, és nyissa meg a calculator.log fájlt. A kimenetnek így kell kinéznie:

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

Ezen a ponton CalculatorLibrary.cs a következő kódhoz kell hasonlítania:

// 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 a következő kódhoz hasonlóan kell kinéznie:

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

NuGet-csomag hozzáadása: Írás JSON-fájlba

Az objektumadatok tárolására népszerű és hordozható JSON-műveletek kimenetéhez hivatkozhat a Newtonsoft.Json NuGet-csomagra. A NuGet-csomagok a .NET-osztálykódtárak elsődleges terjesztési módszerei.

1. A Megoldáskezelőterületen kattintson a jobb gombbal a CalculatorLibrary projekt Függőségek csomópontjára, és válassza a NuGet-csomagok kezeléselehetőséget.

   

   Megnyílik a NuGet Package Manager.

2. Keresse meg és válassza ki a Newtonsoft.Json csomagot, majd válassza a Telepítéslehetőséget.

   

   Ha a rendszer kéri, hogy fogadja el a módosításokat, válassza az OKlehetőséget.

   A Visual Studio letölti a csomagot, és hozzáadja a projekthez. Új bejegyzés jelenik meg a Packages csomópontban a Solution Explorer-ban.

   Adjon hozzá using irányelveket Newtonsoft.JsonCalculatorLibrary.cselején.

   // CalculatorLibrary.cs
   using Newtonsoft.Json;
   

3. Hozza létre a JsonWriter tagobjektumot, és cserélje le a Calculator konstruktort a következő kódra:

        // 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. Módosítsa a DoOperation metódust a JSON writer kód hozzáadásához:

        // 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. Adjon hozzá egy metódust a JSON-szintaxis befejezéséhez, ha a felhasználó befejezte a műveleti adatok megadását.

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

6. A Program.csvégén, mielőtt a return;-hez érne, adjon hozzá egy hívást a Finish-ra:

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

7. Hozza létre és futtassa az alkalmazást, és miután végzett néhány művelet beírásával, zárja be az alkalmazást az n parancs megadásával.

8. Nyissa meg a calculatorlog.json fájlt a Fájlkezelőben. A következő tartalomhoz hasonlót kell látnia:

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

Hibakeresés: Töréspont beállítása és elérése

A Visual Studio hibakeresője hatékony eszköz. A hibakereső végiglépkedhet a kódon, és megkeresheti azt a pontot, ahol programozási hiba történt. Ezután megismerheti, hogy milyen javításokat kell végrehajtania, és ideiglenes módosításokat végezhet az alkalmazás futtatásának folytatásához.

1. Kattintson a Program.csfájlban az alábbi kódsor bal oldalán található margóra. Rá is kattinthat a sorra, és kiválaszthatja F9, vagy kattintson a jobb gombbal a vonalra, majd válassza a Töréspont>Töréspont beszúrásalehetőséget.

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

   A megjelenő piros pont töréspontot jelez. Töréspontok használatával szüneteltetheti az alkalmazást, és megvizsgálhatja a kódot. Bármely végrehajtható kódsoron beállíthat töréspontot.

   

2. Hozza létre és futtassa az alkalmazást. Adja meg a számításhoz a következő értékeket:

   • Az első számnál adja meg 8.
   • A második számnál adja meg 0.
   • Az operátor számára, szórakozzunk egy kicsit. Adja meg d.

   Az alkalmazás ott áll meg, ahol a töréspontot létrehoztad, amit a bal oldali sárga mutató és a kiemelt kódrész jelöl. A kiemelt kódot még nem hajtották végre.

   

   Most, hogy az alkalmazás fel van függesztve, megvizsgálhatja az alkalmazás állapotát.

Hibakeresés: Változók megtekintése

1. A kiemelt kódban vigye az egérmutatót olyan változók fölé, mint a cleanNum1 és a op. A változók aktuális értékei( 8 és d) az adatleírásokban jelennek meg.

   

   Hibakereséskor ellenőrizze, hogy a változók megtartják-e a várt értékeket, gyakran kritikus fontosságú a problémák megoldása szempontjából.

2. Az alsó panelen tekintse meg a Helyiek ablakot. Ha be van zárva, a megnyitáshoz válassza Hibakeresés>Windows>Helyiek lehetőséget.

   A Helyiek ablak az összes jelenleg hatókörben lévő változót megjeleníti az értékével és típusával együtt.

   

3. Tekintse meg az Automatikus ablakot.

   Az Automatikusak ablak hasonló a Helyiek ablakhoz, de azokat a változókat jeleníti meg, amely közvetlenül az alkalmazás szüneteltetését megelőző és követő kódsort követi.

   Jegyzet

   Ha nem látja az Automatikus beállítások ablakot, a megnyitáshoz válassza Hibakeresés>Windows>Automatikus lehetőséget.

Ezután hajtsa végre a kódot a hibakeresőben egyszerre egy utasításban, amelyet léptetőnevezünk.

Hibakeresés: Kód lépésenkénti végrehajtása

1. Nyomja le a F11billentyűt, vagy válassza a Hibakeresés>Belépéslehetőséget.

   A Step Into paranccsal az alkalmazás végrehajtja az aktuális utasítást, és továbblép a következő végrehajtható utasításra, általában a következő kódsorra. A bal oldali sárga mutató mindig az aktuális utasítást jelzi.

   képernyőképe

   Most lépett be a DoOperation osztály Calculator metódusába.

2. Ha hierarchikusan szeretné áttekinteni a programfolyamatot, tekintse meg a Hívásverem ablakot. Ha be van zárva, a megnyitáshoz válassza Hibakeresés>Windows>Hívásverem lehetőséget.

   

   Ez a nézet az aktuális Calculator.DoOperation metódust jeleníti meg, amelyet a sárga mutató jelez. A második sor a metódusnak nevezett függvényt jeleníti meg a Main metódusából.

   A Hívási lánc ablakban látható a metódusok és függvények meghívásának sorrendje. Ez az ablak számos hibakereső funkcióhoz is hozzáférést biztosít, például Ugrás a Forráskódparancsra a helyi menüből.

3. Nyomja le F10, vagy válassza Hibakeresés>Lépésről lépésrelehetőséget többször, amíg az alkalmazás fel nem függeszti a switch utasítást.

   // CalculatorLibrary.cs
   switch (op)
   {
   

   A Step Over parancs hasonló a Step Into parancshoz, azzal a kivételrel, hogy ha az aktuális utasítás függvényt hív meg, a hibakereső a függvényben futtatja a kódot, és a függvény visszatéréséig nem függeszti fel a végrehajtást. A Step Over gyorsabb, mint a Step Into, ha nem érdekli egy adott függvény.

4. Nyomja le F10- még egyszer, hogy az alkalmazás a következő kódsoron szünetel.

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

   Ez a kód nullával való osztás esetét ellenőrzi. Ha az alkalmazás folytatja, az általános kivételt (hibát) okoz, de érdemes lehet valami mást kipróbálni, például a tényleges visszaadott érték megtekintését a konzolon. Az egyik lehetőség a hibakereső funkció, az úgynevezett szerkesztés és folytatás, használata a kód módosításához, majd a hibakeresés folytatásához. Van azonban egy másik trükk a végrehajtási folyamat ideiglenes módosítására.

Hibakeresés: Ideiglenes módosítás tesztelése

1. Jelölje ki a sárga mutatót, amely jelenleg a if (num2 != 0) utasításban van szüneteltetve, és húzza a következő utasításba:

   // CalculatorLibrary.cs
   result = num1 / num2;
   

   Ha ide húzza az egérmutatót, az alkalmazás teljesen kihagyja a if utasítást, így láthatja, mi történik, ha nullával oszt.

2. Nyomja le F10 a kódsor végrehajtásához.

3. Ha a result változó fölé viszi az egérmutatót, az Végtelenértékét jeleníti meg. C#-ban a nullával való osztás eredménye a végtelen.

4. Nyomja le F5, vagy válassza Hibakeresés>Hibakeresés folytatásalehetőséget.

   A matematikai művelet eredményeként megjelenik a végtelen szimbólum a konzolon.

5. Zárja be megfelelően az alkalmazást az n parancs megadásával.

Kód kész

A CalculatorLibrary.cs fájl teljes kódja az összes lépés elvégzése után:

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

Itt található a kód a Program.csszámára:

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

Következő lépések

Gratulálunk az oktatóanyag elvégzéséhez! További információért folytassa a következő tartalommal:

• További C#-oktatóanyagok
• rövid útmutató: ASP.NET Core-webalkalmazás létrehozása
• C#-kód hibakeresésének elsajátítása a Visual Studio
• Egységtesztek létrehozása és futtatása
• C#-program futtatása
• Tudnivalók a C# IntelliSense
• Folytassa a Visual Studio IDE áttekintési
• naplózási és nyomkövetési