Śledzenie i debugowanie w języku Visual C sharp

Artykuł
07/17/2023

W tym artykule opisano sposób śledzenia i debugowania w języku Visual C# oraz przedstawiono kilka przykładowych kroków wyjaśniających powiązane informacje.

Oryginalna wersja produktu: Visual C#
Oryginalny numer KB: 815788

Podsumowanie

Aby zapoznać się z wersją programu Microsoft Visual Basic dla platformy .NET w tym artykule, zobacz Używanie klas śledzenia i debugowania w programie Visual Basic .NET.

Ten artykuł odnosi się do systemu przestrzeni nazw biblioteki klas .NET Framework. Diagnostyka i opis sposobu używania Debug klas i Trace . Te klasy są dostępne w .NET Framework. Te klasy umożliwiają dostarczanie informacji o wydajności aplikacji podczas opracowywania aplikacji lub po wdrożeniu w środowisku produkcyjnym. Te klasy są tylko jedną częścią funkcji instrumentacji, które są dostępne w .NET Framework.

Wymagania

Na poniższej liście przedstawiono zalecany sprzęt, oprogramowanie, infrastrukturę sieciową i dodatki Service Pack, których potrzebujesz:

Microsoft Windows
Microsoft Visual C#

W tym artykule przyjęto również założenie, że znasz debugowanie programu.

Opis techniki

Kroki opisane w sekcji Create a Sample with the Debug Class (Tworzenie przykładu za pomocą klasy debugowania ) pokazują, jak utworzyć aplikację konsolową, która udostępnia informacje o wykonywaniu programu za pomocą Debug klasy .

Po uruchomieniu programu można użyć metod klasy do tworzenia komunikatów Debug , które ułatwiają monitorowanie sekwencji wykonywania programu, wykrywanie błędów lub podawanie informacji dotyczących pomiaru wydajności. Domyślnie komunikaty generowane przez klasę Debug są wyświetlane w oknie Dane wyjściowe zintegrowanego środowiska deweloperskiego programu Visual Studio (IDE).

Przykładowy kod używa WriteLine metody do utworzenia komunikatu, po którym następuje terminator wiersza. W przypadku użycia tej metody do utworzenia komunikatu każdy komunikat jest wyświetlany w osobnym wierszu w oknie Dane wyjściowe.

W przypadku korzystania z AssertDebug metody klasy w oknie Dane wyjściowe jest wyświetlany komunikat tylko wtedy, gdy określony warunek ma wartość false. Komunikat zostanie również wyświetlony w modalnym oknie dialogowym dla użytkownika. Okno dialogowe zawiera komunikat, nazwę projektu i Debug. Numer instrukcji assert. Okno dialogowe zawiera również następujące trzy przyciski poleceń:

Przerwać: Aplikacja przestaje działać.
Ponów próbę: Aplikacja przechodzi w tryb debugowania.
Ignoruj: Aplikacja jest kontynuowana. Użytkownik musi kliknąć jeden z tych przycisków, aby aplikacja mogła kontynuować.

Można również kierować dane wyjściowe z Debug klasy do miejsc docelowych innych niż okno Dane wyjściowe. Klasa Debug ma kolekcję Odbiorniki, która zawiera Listener obiekty.

Każdy obiekt odbiornika monitoruje dane wyjściowe Debug i kieruje dane wyjściowe do określonego obiektu docelowego.

Każdy odbiornik w kolekcji odbiornika otrzymuje wszystkie dane wyjściowe wygenerowane przez klasę Debug . Użyj klasy , TextWriterTraceListener aby zdefiniować Listener obiekty. Można określić obiekt docelowy dla klasy za pośrednictwem TextWriterTraceListener jej konstruktora.

Niektóre możliwe cele wyjściowe obejmują następujące elementy:

Okno Konsoli przy użyciu System.Console.Out właściwości .
Plik tekstowy (.txt) przy użyciu System.IO.File.CreateText("FileName.txt") instrukcji . Po utworzeniu obiektu TextWriterTraceListener należy dodać obiekt do obiektu Debug. Kolekcja odbiorników do odbierania Debug danych wyjściowych.

Tworzenie przykładu za pomocą klasy debugowania

Uruchom program Visual Studio lub Visual C# Express Edition.
Utwórz nowy projekt aplikacji konsolowej visual C# o nazwie conInfo. Klasa Class1 jest tworzona w programie Visual Studio .NET. Program.cs jest tworzony w programie Visual Studio 2005.
Dodaj następującą przestrzeń nazw u góry w klasie Class1 lub Program.cs.
```
using System.Diagnostics;
```
Aby zainicjować zmienne zawierające informacje o produkcie, dodaj następujące instrukcje deklaracji do metody Main:
```
string sProdName = "Widget";
int iUnitQty = 100;
double dUnitCost = 1.03;
```
Określ komunikat, który klasa generuje jako pierwszy parametr wejściowy WriteLine metody . Naciśnij kombinację klawiszy CTRL+ALT+O , aby upewnić się, że okno Dane wyjściowe jest widoczne.
```
Debug.WriteLine("Debug Information-Product Starting ");
```
Aby uzyskać czytelność, użyj Indent metody , aby wcięć kolejne komunikaty w oknie Dane wyjściowe:
```
Debug.Indent();
```

Aby wyświetlić zawartość wybranych zmiennych, użyj metody w WriteLine następujący sposób:

Debug.WriteLine("The product name is " + sProdName);
Debug.WriteLine("The available units on hand are" + iUnitQty.ToString());
Debug.WriteLine("The per unit cost is " + dUnitCost.ToString());

Możesz również użyć metody , WriteLine aby wyświetlić przestrzeń nazw i nazwę klasy istniejącego obiektu. Na przykład poniższy kod wyświetla System.Xml.XmlDocument przestrzeń nazw w oknie Dane wyjściowe:
```
System.Xml.XmlDocument oxml = new System.Xml.XmlDocument();
Debug.WriteLine(oxml);
```
Aby zorganizować dane wyjściowe, można dołączyć kategorię jako opcjonalny, drugi parametr wejściowy WriteLine metody. Jeśli określisz kategorię, format komunikatu okna Dane wyjściowe to "category: message". Na przykład w pierwszym wierszu następującego kodu w oknie Dane wyjściowe jest wyświetlany komunikat "Pole: nazwa produktu to Widget":
```
Debug.WriteLine("The product name is " + sProdName,"Field");
Debug.WriteLine("The units on hand are" + iUnitQty,"Field");
Debug.WriteLine("The per unit cost is" + dUnitCost.ToString(),"Field");
Debug.WriteLine("Total Cost is " + (iUnitQty * dUnitCost),"Calc");
```
Okno Dane wyjściowe może wyświetlać komunikaty tylko wtedy, gdy wyznaczony warunek ma wartość true przy użyciu WriteLineIf metody Debug klasy . Warunek, który ma zostać oceniony, jest pierwszym parametrem wejściowym WriteLineIf metody . Drugim parametrem parametru WriteLineIf jest komunikat, który jest wyświetlany tylko wtedy, gdy warunek w pierwszym parametrze ma wartość true.
```
Debug.WriteLineIf(iUnitQty > 50, "This message WILL appear");
Debug.WriteLineIf(iUnitQty < 50, "This message will NOT appear");
```
Użyj metody Debug Assert klasy, aby w oknie Dane wyjściowe był wyświetlany komunikat tylko wtedy, gdy określony warunek ma wartość false:
```
Debug.Assert(dUnitCost > 1, "Message will NOT appear");
Debug.Assert(dUnitCost < 1, "Message will appear since dUnitcost < 1 is false");
```

TextWriterTraceListener Utwórz obiekty dla okna konsoli (tr1) i pliku tekstowego o nazwie Output.txt (tr2), a następnie dodaj każdy obiekt do kolekcji Odbiorniki debugowania:

TextWriterTraceListener tr1 = new TextWriterTraceListener(System.Console.Out);
Debug.Listeners.Add(tr1);

TextWriterTraceListener tr2 = new TextWriterTraceListener(System.IO.File.CreateText("Output.txt"));
Debug.Listeners.Add(tr2);

Aby uzyskać czytelność, użyj Unindent metody , aby usunąć wcięcie dla kolejnych komunikatów generowanych przez klasę Debug . Gdy używasz Indent metod i Unindent razem, czytelnik może odróżnić dane wyjściowe jako grupę.
```
Debug.Unindent();
Debug.WriteLine("Debug Information-Product Ending");
```
Aby upewnić się, że każdy Listener obiekt odbiera wszystkie swoje dane wyjściowe, wywołaj metodę Flush dla Debug buforów klasy:
```
Debug.Flush();
```

Korzystanie z klasy Trace

Można również użyć klasy do Trace tworzenia komunikatów, które monitorują wykonywanie aplikacji. Klasy Trace i Debug współużytkują większość tych samych metod, aby wygenerować dane wyjściowe, w tym następujące:

Writeline
WriteLineIf
Wcięcie
Nie wcięcie
Assert
Flush

Klasy i Debug można używać Trace osobno lub razem w tej samej aplikacji. W projekcie debugowania konfiguracji rozwiązań zarówno dane wyjściowe, jak Trace i Debug wyjściowe są aktywne. Projekt generuje dane wyjściowe z obu tych klas do wszystkich Listener obiektów. Jednak projekt Release Solution Configuration generuje tylko dane wyjściowe z Trace klasy. Projekt Release Solution Configuration ignoruje wszelkie Debug wywołania metody klasy.

Trace.WriteLine("Trace Information-Product Starting ");
Trace.Indent();

Trace.WriteLine("The product name is "+sProdName);
Trace.WriteLine("The product name is"+sProdName,"Field" );
Trace.WriteLineIf(iUnitQty > 50, "This message WILL appear");
Trace.Assert(dUnitCost > 1, "Message will NOT appear");

Trace.Unindent();
Trace.WriteLine("Trace Information-Product Ending");

Trace.Flush();

Console.ReadLine();

Sprawdź, czy działa

Upewnij się, że debugowanie jest bieżącą konfiguracją rozwiązania.
Jeśli okno Eksplorator rozwiązań nie jest widoczne, naciśnij kombinację klawiszy CTRL+ALT+L, aby wyświetlić to okno.
Kliknij prawym przyciskiem myszy pozycję conInfo, a następnie kliknij pozycję Właściwości.
W lewym okienku strony właściwości conInfo w folderze Konfiguracja upewnij się, że strzałka wskazuje na debugowanie.

Uwaga

W programie Visual C# 2005 i Visual C# 2005 Express Edition kliknij pozycję Debuguj na stronie conInfo .
Nad folderem Konfiguracja na liście rozwijanej Konfiguracja kliknij pozycję Aktywne (debugowanie) lub Debuguj, a następnie kliknij przycisk OK. W programie Visual C# 2005 i Visual C# 2005 Express Edition kliknij pozycję Aktywne (debugowanie) lubDebuguj w polu listy rozwijanej Konfiguracja na stronie Debugowanie, a następnie kliknij przycisk Zapisz w menu Plik.
Naciśnij klawisze CTRL+ALT+O , aby wyświetlić okno Dane wyjściowe .
Naciśnij klawisz F5 , aby uruchomić kod. Po wyświetleniu okna dialogowego Assertion Failed (Niepowodzenie asercji) kliknij pozycję Ignoruj.

W oknie Konsola naciśnij klawisz ENTER. Program powinien zakończyć pracę, a w oknie Dane wyjściowe powinny zostać wyświetlone dane wyjściowe podobne do następujących:

Debug Information-Product Starting
The product name is Widget
The available units on hand are100
The per unit cost is 1.03
System.Xml.XmlDocument
Field: The product name is Widget
Field: The units on hand are100
Field: The per unit cost is1.03
Calc: Total Cost is 103
This message WILL appear
---- DEBUG ASSERTION FAILED ----
---- Assert Short Message ----
Message will appear since dUnitcost < 1 is false
---- Assert Long Message ----

at Class1.Main(String[] args) <%Path%>\class1.cs(34)

The product name is Widget
The available units on hand are100
The per unit cost is 1.03
Debug Information-Product Ending
Trace Information-Product Starting
The product name is Widget
Field: The product name isWidget
This message WILL appear
Trace Information-Product Ending

W oknie Konsola i pliku Output.txt powinny zostać wyświetlone następujące dane wyjściowe:

The product name is Widget
The available units on hand are 100
The per unit cost is 1.03
Debug Information-Product Ending
Trace Information-Product Starting
The product name is Widget
Field: The product name is Widget
This message WILL appear
Trace Information-Product Ending

Uwaga

Plik Output.txt znajduje się w tym samym katalogu co plik wykonywalny conInfo (conInfo.exe). Zazwyczaj jest to folder \bin, w którym jest przechowywane źródło projektu. Domyślnie jest C:\Documents and Settings\User login\My Documents\Visual Studio Projects\conInfo\binto . W programie Visual C# 2005 i Visual C# 2005 Express Edition plik Output.txt znajduje się w folderze: C:\Documents and Settings\User login\My Documents\Visual Studio 2005\Projects\conInfo\conInfo\bin\Debug.

Ukończ listę kodu

using System;
using System.Diagnostics;

class Class1
{
    [STAThread]
    static void Main(string[] args)
    {
        string sProdName = "Widget";
        int iUnitQty = 100;
        double dUnitCost = 1.03;
        Debug.WriteLine("Debug Information-Product Starting ");
        Debug.Indent();
        Debug.WriteLine("The product name is "+sProdName);
        Debug.WriteLine("The available units on hand are"+iUnitQty.ToString());
        Debug.WriteLine("The per unit cost is "+ dUnitCost.ToString());

        System.Xml.XmlDocument oxml = new System.Xml.XmlDocument();
        Debug.WriteLine(oxml);

        Debug.WriteLine("The product name is "+sProdName,"Field");
        Debug.WriteLine("The units on hand are"+iUnitQty,"Field");
        Debug.WriteLine("The per unit cost is"+dUnitCost.ToString(),"Field");
        Debug.WriteLine("Total Cost is "+(iUnitQty * dUnitCost),"Calc");

        Debug.WriteLineIf(iUnitQty > 50, "This message WILL appear");
        Debug.WriteLineIf(iUnitQty < 50, "This message will NOT appear");

        Debug.Assert(dUnitCost > 1, "Message will NOT appear");
        Debug.Assert(dUnitCost < 1, "Message will appear since dUnitcost < 1 is false");

        TextWriterTraceListener tr1 = new TextWriterTraceListener(System.Console.Out);
        Debug.Listeners.Add(tr1);

        TextWriterTraceListener tr2 = new TextWriterTraceListener(System.IO.File.CreateText("Output.txt"));
        Debug.Listeners.Add(tr2);

        Debug.WriteLine("The product name is "+sProdName);
        Debug.WriteLine("The available units on hand are"+iUnitQty);
        Debug.WriteLine("The per unit cost is "+dUnitCost);
        Debug.Unindent();
        Debug.WriteLine("Debug Information-Product Ending");
        Debug.Flush();

        Trace.WriteLine("Trace Information-Product Starting ");
        Trace.Indent();

        Trace.WriteLine("The product name is "+sProdName);
        Trace.WriteLine("The product name is"+sProdName,"Field" );
        Trace.WriteLineIf(iUnitQty > 50, "This message WILL appear");
        Trace.Assert(dUnitCost > 1, "Message will NOT appear");

        Trace.Unindent();
        Trace.WriteLine("Trace Information-Product Ending");

        Trace.Flush();

        Console.ReadLine();
    }
}

Rozwiązywanie problemów

Jeśli typ konfiguracji rozwiązania to Release, Debug dane wyjściowe klasy są ignorowane.
Po utworzeniu TextWriterTraceListener klasy dla określonego obiektu docelowego otrzymuje TextWriterTraceListener dane wyjściowe z Trace klas i Debug . Dzieje się tak niezależnie od tego, czy używasz Add metody Trace klasy lub Debug do dodawania TextWriterTraceListenerListeners do klasy.

Jeśli dodasz Listeners obiekt dla tego samego obiektu docelowego w Trace klasach iDebug, każdy wiersz danych wyjściowych zostanie zduplikowany, niezależnie od tego, czy Debug dane wyjściowe są generowane.Trace

TextWriterTraceListener myWriter = new TextWriterTraceListener(System.Console.Out);
Debug.Listeners.Add(myWriter);

TextWriterTraceListener myCreator = new TextWriterTraceListener(System.Console.Out);
Trace.Listeners.Add(myCreator);