Kurz: Rozšíření konzolové aplikace v jazyce C# a ladění v sadě Visual Studio (část 2 ze 2)

Článek
10/31/2023

Ve 2. části této série kurzů se podrobněji ponoříte do sestavení a ladění funkcí sady Visual Studio, které potřebujete pro každodenní vývoj. Mezi tyto funkce patří správa více projektů, ladění a odkazování na balíčky třetích stran. Spustíte konzolovou aplikaci jazyka C#, kterou jste vytvořili v části 1 tohoto kurzu, a prozkoumáte některé funkce integrovaného vývojového prostředí (IDE) sady Visual Studio. Tento kurz je druhou částí dvoudílné série kurzů.

V tomto kurzu provedete následující úlohy:

Přidejte druhý projekt.
Odkazovat na knihovny a přidávat balíčky
Ladění kódu
Zkontrolujte dokončený kód.

Požadavky

K práci s tímto článkem můžete použít některou z těchto aplikací kalkulačky:

Konzolová aplikace kalkulačky z 1. části tohoto kurzu.
Aplikace kalkulačky jazyka C# v úložišti vs-tutorial-samples. Začněte tím, že otevřete aplikaci z úložiště.

Přidání dalšího projektu

Skutečný kód zahrnuje projekty, které spolupracují v řešení. Do aplikace kalkulačky můžete přidat projekt knihovny tříd, který poskytuje některé funkce kalkulačky.

V sadě Visual Studio pomocí příkazu >nabídky Přidat>nový projekt přidáte nový projekt. Můžete také kliknout pravým tlačítkem na řešení v Průzkumník řešení a přidat projekt z místní nabídky.

V Průzkumník řešení klikněte pravým tlačítkem na uzel řešení a zvolte Přidat>nový projekt.
V okně Přidat nový projekt zadejte do vyhledávacího pole knihovnu tříd. Zvolte šablonu projektu knihovny tříd jazyka C# a pak vyberte Další.
Na obrazovce Konfigurovat nový projekt zadejte název projektu CalculatorLibrary a pak vyberte Další.
Po zobrazení výzvy zvolte .NET 3.1. Visual Studio vytvoří nový projekt a přidá ho do řešení.
Přejmenujte soubor Class1.cs na CalculatorLibrary.cs. Pokud chcete soubor přejmenovat, můžete kliknout pravým tlačítkem myši na název v Průzkumník řešení a zvolit Přejmenovat, vybrat název a stisknout klávesu F2 nebo vybrat název a znovu ho zadat.

Zpráva se může zeptat, jestli chcete přejmenovat odkazy v Class1 souboru. Nezáleží na tom, jak odpovíte, protože kód nahradíte v budoucím kroku.
Teď přidejte odkaz na projekt, takže první projekt může používat rozhraní API, která nová knihovna tříd zveřejňuje. Klikněte pravým tlačítkem myši na uzel Závislosti v projektu Kalkulačka a zvolte Přidat odkaz na projekt.

Zobrazí se dialogové okno Správce odkazů. V tomto dialogovém okně můžete přidat odkazy na jiné projekty, sestavení a knihovny DLL modelu COM, které vaše projekty potřebují.
V dialogovém okně Správce odkazů zaškrtněte políčko pro projekt CalculatorLibrary a pak vyberte OK.

Odkaz na projekt se zobrazí pod uzlem Projekty v Průzkumník řešení.

V souboru Program.cs vyberte Calculator třídu a veškerý její kód a stisknutím kláves Ctrl+X ji vyjměte. Potom v souboru CalculatorLibrary.cs vložte kód do CalculatorLibrary oboru názvů.

public Přidejte také před třídu Calculator, aby ji zpřístupnil mimo knihovnu.

CalculatorLibrary.cs by teď měl vypadat podobně jako následující kód:

using System;

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

Program.cs má také odkaz, ale chyba říká, že Calculator.DoOperation volání se nevyřeší. Příčinou chyby je to, že CalculatorLibrary se nachází v jiném oboru názvů. Pro plně kvalifikovaný odkaz můžete přidat CalculatorLibrary obor názvů do Calculator.DoOperation volání:
```
result = CalculatorLibrary.Calculator.DoOperation(cleanNum1, cleanNum2, op);
```
Nebo můžete zkusit přidat using direktivu na začátek souboru:
```
using CalculatorLibrary;
```
using Přidání direktivy by vám mělo umožnit odebrat CalculatorLibrary obor názvů z webu volání, ale teď existuje nejednoznačnost. Je Calculator třída v CalculatorLibrary, nebo je Calculator obor názvů?

Chcete-li vyřešit nejednoznačnost, přejmenujte obor názvů z Calculator na program.csCalculatorProgram.
```
namespace CalculatorProgram
```

V Průzkumník řešení klikněte pravým tlačítkem na uzel řešení a zvolte Přidat>nový projekt.
V okně Přidat nový projekt zadejte do vyhledávacího pole knihovnu tříd. Zvolte šablonu projektu knihovny tříd jazyka C# a pak vyberte Další.
Na obrazovce Konfigurovat nový projekt zadejte název projektu CalculatorLibrary a pak vyberte Další.
Na obrazovce Další informace je vybraná možnost .NET 8.0. Vyberte Vytvořit.

Visual Studio vytvoří nový projekt a přidá ho do řešení.
Přejmenujte soubor Class1.cs na CalculatorLibrary.cs. Pokud chcete soubor přejmenovat, můžete kliknout pravým tlačítkem myši na název v Průzkumník řešení a zvolit Přejmenovat, vybrat název a stisknout klávesu F2 nebo vybrat název a znovu ho zadat.

Zpráva se může zeptat, jestli chcete přejmenovat všechny odkazy v Class1 souboru. Nezáleží na tom, jak odpovíte, protože kód nahradíte v budoucím kroku.
Teď přidejte odkaz na projekt, takže první projekt může používat rozhraní API, která nová knihovna tříd zveřejňuje. Klikněte pravým tlačítkem myši na uzel Závislosti v projektu Kalkulačka a zvolte Přidat odkaz na projekt.

Zobrazí se dialogové okno Správce odkazů. V tomto dialogovém okně můžete přidat odkazy na jiné projekty, sestavení a knihovny DLL modelu COM, které vaše projekty potřebují.
V dialogovém okně Správce odkazů zaškrtněte políčko pro projekt CalculatorLibrary a pak vyberte OK.

Odkaz na projekt se zobrazí pod uzlem Projekty v Průzkumník řešení.

public Přidejte také před třídu Calculator, aby ji zpřístupnil mimo knihovnu.

CalculatorLibrary.cs by teď měl vypadat podobně jako následující kód:

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

Program.cs má také odkaz, ale chyba říká, že Calculator.DoOperation volání se nevyřeší. Příčinou chyby je to, že CalculatorLibrary se nachází v jiném oboru názvů. Pro plně kvalifikovaný odkaz můžete přidat CalculatorLibrary obor názvů do Calculator.DoOperation volání:
```
result = CalculatorLibrary.Calculator.DoOperation(cleanNum1, cleanNum2, op);
```
Nebo můžete zkusit přidat using direktivu na začátek souboru:
```
using CalculatorLibrary;
```
using Přidání direktivy by vám mělo umožnit odebrat CalculatorLibrary obor názvů z webu volání, ale teď existuje nejednoznačnost. Je Calculator třída v CalculatorLibrary, nebo je Calculator obor názvů?

Chcete-li vyřešit nejednoznačnost, přejmenujte obor názvů z Calculator na program.csCalculatorProgram.
```
namespace CalculatorProgram
```

Referenční knihovny .NET: Zápis do protokolu

Třídu trasování .NET můžete použít k přidání protokolu všech operací a jeho zápisu do textového souboru. Třída Trace je také užitečná pro základní techniky ladění tisku. Třída Trace je v System.Diagnosticsa používá System.IO třídy jako StreamWriter.

Začněte přidáním using direktiv v horní části souboru CalculatorLibrary.cs:
```
using System.IO;
using System.Diagnostics;
```

Toto použití Trace třídy musí obsahovat odkaz pro třídu, kterou přidruží k souborustream. Tento požadavek znamená, že kalkulačka funguje lépe jako objekt, takže přidejte konstruktor na začátek Calculator třídy v CalculatorLibrary.cs.

Odeberte static také klíčové slovo, aby se statická DoOperation metoda změnila na členovou metodu.

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)
   {

Přidejte výstup protokolu do každého výpočtu. DoOperation teď by měl vypadat jako následující kód:

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

Zpátky v souboru Program.cs označuje červené vlnovkou podtržené nyní označení statického volání. Pokud chcete chybu opravit, vytvořte proměnnou calculator přidáním následujícího řádku kódu těsně před smyčku while (!endApp) :
```
Calculator calculator = new Calculator();
```
Upravte DoOperation také web volání tak, aby odkazoval na objekt pojmenovaný calculator malými písmeny. Kód je nyní vyvoláním člena, nikoli voláním statické metody.
```
result = calculator.DoOperation(cleanNum1, cleanNum2, op);
```
Spusťte aplikaci znovu. Až budete hotovi, klikněte pravým tlačítkem myši na uzel projektu Kalkulačka a zvolte Otevřít složku v Průzkumník souborů.
V Průzkumník souborů přejděte do výstupní složky v bin/Debug/a otevřete soubor calculator.log. Výstup by měl vypadat přibližně takto:
```
Starting Calculator Log
Started 7/9/2020 1:58:19 PM
1 + 2 = 3
3 * 3 = 9
```

V tomto okamžiku by kalkulačkaLibrary.cs měla vypadat podobně jako tento kód:

using System;
using System.IO;
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 by měl vypadat jako následující kód:

using System;
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.
                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();

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

Začněte přidáním using direktiv v horní části souboru CalculatorLibrary.cs:
```
using System.Diagnostics;
```

Odeberte static také klíčové slovo, aby se statická DoOperation metoda změnila na členovou metodu.

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)
   {

Přidejte výstup protokolu do každého výpočtu. DoOperation teď by měl vypadat jako následující kód:

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

Zpátky v souboru Program.cs označuje červené vlnovkou podtržené nyní označení statického volání. Pokud chcete chybu opravit, vytvořte proměnnou calculator přidáním následujícího řádku kódu těsně před smyčku while (!endApp) :
```
Calculator calculator = new Calculator();
```
Upravte DoOperation také web volání tak, aby odkazoval na objekt pojmenovaný calculator malými písmeny. Kód je nyní vyvoláním člena, nikoli voláním statické metody.
```
result = calculator.DoOperation(cleanNum1, cleanNum2, op);
```
Spusťte aplikaci znovu. Až budete hotovi, klikněte pravým tlačítkem myši na uzel projektu Kalkulačka a zvolte Otevřít složku v Průzkumník souborů.
V Průzkumník souborů přejděte do výstupní složky v bin/Debug/a otevřete soubor calculator.log. Výstup by měl vypadat přibližně takto:
```
Starting Calculator Log
Started 7/9/2020 1:58:19 PM
1 + 2 = 3
3 * 3 = 9
```

V tomto okamžiku by kalkulačkaLibrary.cs měla vypadat podobně jako tento kód:

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 by měl vypadat jako následující kód:

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.
                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();

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

Přidání balíčku NuGet: Zápis do souboru JSON

Pokud chcete výstupní operace ve formátu JSON, oblíbeném a přenosném formátu pro ukládání dat objektů, můžete odkazovat na balíček NuGet Newtonsoft.Json . Balíčky NuGet jsou primární distribuční metodou pro knihovny tříd .NET.

V Průzkumník řešení klikněte pravým tlačítkem myši na uzel Závislosti pro projekt CalculatorLibrary a zvolte Spravovat balíčky NuGet.

Otevře se Správce balíčků NuGet.
Vyhledejte a vyberte balíček Newtonsoft.Json a vyberte Nainstalovat.

Visual Studio stáhne balíček a přidá ho do projektu. V uzlu Reference se v Průzkumník řešení zobrazí nová položka.

Pokud se zobrazí výzva, jestli chcete přijmout změny, vyberte OK.

Visual Studio stáhne balíček a přidá ho do projektu. V uzlu Balíčky se v Průzkumník řešení zobrazí nová položka.

Přidejte direktivu using pro Newtonsoft.Json začátek CalculatorLibrary.cs.
```
using Newtonsoft.Json;
```

Vytvořte objekt člena JsonWriter a nahraďte Calculator konstruktor následujícím kódem:

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

Upravte metodu DoOperation pro přidání kódu JSON writer :

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

Po zadání dat operace přidejte metodu pro dokončení syntaxe JSON.

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

Na konci souboru Program.cs před , return;přidejte volání:Finish

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

Sestavte a spusťte aplikaci a po zadání několika operací aplikaci zavřete zadáním příkazu n .

Otevřete soubor calculatorlog.json v Průzkumník souborů. Měli byste vidět něco jako následující obsah:

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

Ladění: Nastavení a dosažení zarážky

Ladicí program sady Visual Studio je výkonný nástroj. Ladicí program může procházet kód a najít přesný bod, kde je chyba programování. Pak můžete pochopit, jaké opravy potřebujete udělat, a provést dočasné změny, abyste mohli pokračovat ve spuštění aplikace.

V souboru Program.cs klikněte na hřbet vlevo od následujícího řádku kódu. Můžete také kliknout na řádek a vybrat klávesu F9 nebo kliknout pravým tlačítkem myši na čáru a vybrat Zarážku Vložit zarážku>.
```
result = calculator.DoOperation(cleanNum1, cleanNum2, op);
```
Červená tečka, která se zobrazí, značí zarážku. Zarážky můžete použít k pozastavení aplikace a kontrole kódu. Zarážku můžete nastavit na libovolný spustitelný řádek kódu.
Sestavte a spusťte aplikaci. Zadejte následující hodnoty pro výpočet:
- Jako první číslo zadejte 8.
- Jako druhé číslo zadejte 0.
- Pro operátora se trochu pobavíme. Zadejte d.
Aplikace pozastaví místo, kde jste vytvořili zarážku, která je označená žlutým ukazatelem vlevo a zvýrazněným kódem. Zvýrazněný kód se ještě nespustí.

Teď můžete s pozastavenou aplikací zkontrolovat stav aplikace.

Ladění: Zobrazení proměnných

Ve zvýrazněném kódu najeďte myší na proměnné, například cleanNum1 a op. Aktuální hodnoty těchto proměnných 8 a d v uvedeném pořadí se zobrazí v části Data Tipy.

Při ladění zkontrolujte, jestli proměnné obsahují očekávané hodnoty, často důležité pro řešení problémů.
V dolním podokně se podívejte do okna Místní hodnoty. Pokud je zavřený, otevřete ho výběrem možnosti Ladit>místní prostředí Windows.>

V okně Místní hodnoty se zobrazí každá proměnná, která je aktuálně v oboru, spolu s její hodnotou a typem.
Podívejte se do okna Automatické položky .

Okno Automatické hodnoty se podobá okně Místní hodnoty, ale zobrazuje proměnné bezprostředně před aktuálním řádkem kódu, kde je aplikace pozastavená.

Poznámka:

Pokud se okno Automatické položky nezobrazuje, otevřete ho výběrem možnosti Ladit>>automatické windows.

Dále spusťte kód v ladicím programu po jednom příkazu, který se nazývá krokování.

Ladění: Krokování kódu

Stiskněte klávesu F11 nebo vyberte Krok pro ladění>.

Pomocí příkazu Step Into spustí aplikace aktuální příkaz a přejde na další spustitelný příkaz, obvykle další řádek kódu. Žlutý ukazatel vlevo vždy označuje aktuální příkaz.

Právě jste vstoupili do DoOperation metody ve Calculator třídě.
Pokud chcete získat hierarchický pohled na tok programu, podívejte se do okna Zásobník volání. Pokud je zavřený, otevřete ho výběrem možnosti Ladění>zásobníku volání systému Windows.>

Toto zobrazení zobrazuje aktuální Calculator.DoOperation metodu označenou žlutým ukazatelem. Druhý řádek zobrazuje funkci, která volala metodu Main , z metody v Program.cs.

Okno Zásobník volání zobrazuje pořadí, ve kterém se volají metody a funkce. Toto okno také poskytuje přístup k mnoha funkcím ladicího programu, například Přejít ke zdrojovému kódu, z místní nabídky.
Stiskněte klávesu F10 nebo několikrát vyberte Krok pro ladění>, dokud se aplikace na switch příkazu nepřestaví.
```
switch (op)
{
```
Příkaz Krok přes je podobný příkazu Step Into s tím rozdílem, že pokud aktuální příkaz volá funkci, ladicí program spustí kód ve funkci a nepřestavuje provádění, dokud funkce nevrátí. Krok za krokem je rychlejší než krok do, pokud vás konkrétní funkce nezajímá.
Stiskněte ještě jednou klávesu F10 , aby se aplikace pozastavila na následujícím řádku kódu.
```
if (num2 != 0)
{
```
Tento kód kontroluje případ dělení nulou. Pokud aplikace pokračuje, vyvolá obecnou výjimku (chybu), ale můžete zkusit něco jiného, třeba zobrazit skutečnou vrácenou hodnotu v konzole. Jednou z možností je použít funkci ladicího programu s názvem edit-and-continue provádět změny kódu a pak pokračovat v ladění. Existuje ale jiný trik k dočasné úpravě toku provádění.

Ladění: Testování dočasné změny

Vyberte žlutý ukazatel, který je aktuálně pozastavený na if (num2 != 0) příkazu, a přetáhněte ho na následující příkaz:
```
result = num1 / num2;
```
Přetažením ukazatele sem aplikace úplně přeskočí if příkaz, abyste viděli, co se stane, když ho vydělíte nulou.
Stisknutím klávesy F10 spusťte řádek kódu.
Pokud na proměnnou result najedete myší, zobrazí se hodnota nekonečna. V jazyce C# je výsledkem nekonečna při dělení nulou.
Stiskněte klávesu F5 nebo vyberte Ladit>pokračovat v ladění.

Symbol nekonečna se v konzole zobrazí jako výsledek matematické operace.
Aplikaci zavřete správně zadáním příkazu n .

Kód je dokončený.

Tady je úplný kód souboru CalculatorLibrary.cs po dokončení všech kroků:

using System;
using System.IO;
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();
        }
    }
}

A tady je kód pro Program.cs:

using System;
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.
                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();

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