Verwenden Sie die Codeabdeckung, um zu bestimmen, wie viel Code getestet wird.

Um zu bestimmen, welcher Anteil des Codes Ihres Projekts durch codierte Tests wie Komponententests getestet wird, können Sie das Codeabdeckungsfeature von Visual Studio verwenden. Um effektiv vor Fehlern zu schützen, sollten Ihre Tests einen großen Teil Ihres Codes ausüben oder "abdecken".

Codeabdeckungsanalyse ist sowohl für verwalteten (CLR) als auch für nicht verwalteten (systemeigenen) Code möglich. Sowohl statische als auch dynamische Instrumentierung werden unterstützt. Um die Codeabdeckung in Befehlszeilenszenarien zu verwenden, nutzen Sie entweder vstest.console.exe oder das Microsoft.CodeCoverage.Console-Tool. Dieses ist eine Erweiterung für dotnet-coverage, die auch systemeigenen Code unterstützt.

Die Codeabdeckungsoption ist im Menü "Test" verfügbar, wenn Sie Testmethoden mit dem Test-Explorer ausführen. Die Ergebnistabelle zeigt den Prozentsatz des Codes, der in jeder Assembly, Klasse und Prozedur ausgeführt wird. Der Quell-Editor hebt den getesteten Code hervor. Sie können die Ergebnisse in beliebten Formaten wie Cobertura exportieren.

Anforderungen

Das Codeabdeckungsfeature ist nur in Visual Studio Enterprise Edition verfügbar.

Anmerkung

Für die .NET-Codeabdeckung können Sie alternativ das Befehlszeilentool dotnet-coverageverwenden.

Analysieren der Codeabdeckung

1. Wählen Sie im Menü Test die Option Code Coverage für alle Tests analysieren aus.

   

   Tipp

   Sie können die Code Coverage auch über das Toolfenster Test-Explorer ausführen.

2. Klicken Sie nach der Ausführung der Tests im Fenster Code Coverage-Ergebnisse auf Code Coverage-Färbung anzeigen. Standardmäßig wird Code, der von Tests abgedeckt wird, in Hellblau hervorgehoben.

   

   In der Dropdown-Liste für die Option Codeabdeckungsfarbe anzeigen können Sie auswählen, ob die Farbgebung auf Codezeilen, Glyphen im linken Rand oder auf beides angewendet wird.

3. Um die Farben zu ändern oder den Text in Fettdruck anzuzeigen, wählen Sie Extras>Optionen>Umgebung>Schriftarten und Farben>Einstellungen anzeigen für: Text-Editor aus. Passen Sie unter Elemente anzeigen die Einstellungen der Elemente für „Coverage“ an, z. B. Von Code Coverage nicht verwendeter Bereich.

   

4. Wenn die Ergebnisse eine geringe Abdeckung aufweisen, untersuchen Sie, welche Teile des Codes nicht ausgeübt werden, und schreiben Sie weitere Tests, um sie abzudecken. Entwicklungsteams streben normalerweise eine Codeabdeckung von ca. 80 % an. In einigen Fällen ist eine geringere Abdeckung akzeptabel. Beispielsweise ist eine geringere Abdeckung akzeptabel, wenn ein Teil des Codes aus einer Standardvorlage generiert wird.

Tipp

So optimieren Sie die Codeabdeckung:

• Deaktivieren Sie die Compileroptimierung.
• Wenn Sie mit nicht verwaltetem (systemeigenem) Code arbeiten, verwenden Sie einen Debugbuild.
• Generieren Sie .pdb- (Symbol)-Dateien für jede Assembly.

Sollten Sie nicht die erwarteten Ergebnisse erhalten, finden Sie weitere Informationen unter Problembehandlung bei der Code Coverage.

Vergessen Sie nicht, die Code Coverage nach Aktualisierung des Codes erneut auszuführen. Abdeckungsergebnisse und Codefarben werden nach dem Ändern des Codes oder beim Ausführen von Tests nicht automatisch aktualisiert.

Tipp

Ab Visual Studio 2022, Version 17.2, können Sie die neuesten Codeabdeckungsfeatures aktivieren, indem Sie Tools > Optionen > Umgebung > Vorschaufeaturesauswählen und dann Verbesserungen der Codeabdeckungauswählen und dann Visual Studio neu starten.

Bericht in Blöcken oder Zeilen

Die Code Coverage wird in Blöcken gezählt. Ein Block ist ein Teil des Codes mit genau einem Ein- und Ausgangspunkt. Wenn der Kontrollfluss des Programms während eines Testlaufs einen Block durchläuft, wird dieser Block als abgedeckt gezählt. Die Häufigkeit, mit der der Block verwendet wird, wirkt sich nicht auf das Ergebnis aus.

Sie können auch die Ergebnisse für Zeilen anzeigen lassen, indem Sie in der Tabellenüberschrift Spalten hinzufügen/entfernen auswählen. Einige Benutzer bevorzugen eine Anzahl von Zeilen, da die Prozentsätze der Größe der Fragmente, die Sie im Quellcode sehen, genauer entsprechen. Ein langer Berechnungsblock würde auch dann als einzelner Block gezählt, wenn er viele Zeilen belegt.

Tipp

Eine Codezeile kann mehrere Codeblocks enthalten. Wenn dies der Fall ist und die Testausführung alle Codeblöcke in der Zeile ausführt, wird sie als eine Zeile gezählt. Wenn einige, aber nicht alle Codeblöcke in der Zeile ausgeübt werden, wird sie als Teilzeile gezählt.

Ansichten für die Code Coverage-Ergebnisse

Im Fenster Code Coverage-Ergebnisse ist der Bericht normalerweise gemäß der Projekt-/Klassen-/Methodenhierarchie strukturiert. Sie können dies ändern, um die Abdeckung auf Verzeichnis-/Datei-/Methodenebene anzuzeigen.

• Um den Quellberichtanzuzeigen, wählen Sie das Symbol "Code Coverage-Ansichten konfigurieren" im Fenster "Code Coverage-Ergebnisse". Wählen Sie dann in der Dropdownliste Berichtsformatvorlage die Option Quellansicht aus.

Im Fenster Code Coverage-Ergebnisse wird normalerweise das Ergebnis der gesamten Projektmappe angezeigt. Die Ergebnisse können gefiltert werden, um nur die Dateien anzuzeigen, die in der aktuellen Branch aktualisiert wurden.

• Um den Changeset-Bericht anzuzeigen, wählen Sie im Fenster Code Coverage-Ergebnisse das Symbol Code Coverage-Ansichten konfigurieren aus. Wählen Sie dann in der Dropdownliste Berichtsinhalt die Option Changeset-Bericht aus. Aktualisieren Sie das aktive Repository und den Basisbranch, um den Vergleichsbericht bereitzustellen.

Im Suchfeld im Fenster Code Coverage-Ergebnisse stehen Ihnen mehrere Möglichkeiten zum Filtern des Berichts zur Verfügung.

• Geben Sie die Suchzeichenfolge in das Suchfeld ein, um die Option Nach Namen suchen zu verwenden (es werden nur die Ergebnisse angezeigt, die der Suchzeichenfolge im Fenster entsprechen).
• Geben Sie zum Verwenden der Option Nach Typ filtern den Namen des Typs in das Suchfeld ein.
• Für die Option Alle anzeigen leeren Sie das Suchfeld.
• Für Vollständig abgedeckt (100 %) anzeigen geben Sie „abgedeckt (%Lines)“:„100“ in das Suchfeld ein.
• Für Teilweise abgedeckt (>0% && < 100%) anzeigen geben Sie „teilweise abgedeckt (%Lines)“:„<##“ ein und ersetzen dabei „##“ durch den abgedeckten Prozentsatz.
• Für 0 % abgedeckt anzeigen geben Sie „nicht abgedeckt (%Lines)“:„0“ in das Suchfeld ein.

Verwalten von Code Coverage-Ergebnissen

Im Fenster Code Coverage-Ergebnisse wird normalerweise das Ergebnis der letzten Ausführung angezeigt. Die Ergebnisse variieren, wenn Sie Ihre Testdaten ändern oder nur einige Ihrer Tests jedes Mal ausführen.

Das Fenster Code Coverage-Ergebnisse kann auch zur Anzeige von vorherigen Ergebnissen oder von Ergebnissen verwendet werden, die über andere Computer erzielt wurden.

Sie können die Ergebnisse mehrerer Läufe zusammenführen, z. B. aus Ausführungen, die unterschiedliche Testdaten verwenden.

• Zum Anzeigen einer vorherigen Gruppe von Ergebnissenwählen Sie sie im Dropdownmenü aus. Das Menü zeigt eine temporäre Liste an, die gelöscht wird, wenn Sie eine neue Lösung öffnen.

• Wenn Sie Ergebnisse aus einer vorherigen Sitzunganzeigen möchten, wählen Sie importieren, navigieren Sie zum Ordner TestResults in Ihrer Lösung, und importieren Sie eine .coverage Datei.

  Die Deckungsfarbe ist möglicherweise falsch, wenn sich der Quellcode seit der Erstellung der .coverage Datei geändert hat.

• Um die Ergebnisse als Text lesbar zu machen, wählen Sie Ergebnisse exportieren und als Dateityp .xml aus. Dadurch wird eine lesbare .xml Datei generiert, die Sie mit anderen Tools verarbeiten oder einfach per E-Mail senden können. Sie können auch Exportformate wie Cobertura auswählen.

• Um Ergebnisse an eine andere Personzu senden, senden Sie entweder eine .coverage--Datei oder eine exportierte .xml Datei. Sie können die Datei dann importieren. Wenn sie dieselbe Version des Quellcodes haben, können sie die Abdeckungsfarbe sehen.

Zusammenführen von Ergebnissen aus verschiedenen Ausführungen

In einigen Fällen werden je nach Testdaten unterschiedliche Blöcke in Ihrem Code verwendet. Daher sollten Sie die Ergebnisse aus verschiedenen Testläufen kombinieren.

Angenommen, wenn Sie einen Test mit Eingabe "2" ausführen, stellen Sie fest, dass 50% einer bestimmten Funktion abgedeckt ist. Wenn Sie den Test ein zweites Mal mit der Eingabe „-2“ ausführen, sehen Sie in der Ansicht der Code Coverage-Färbung, dass die anderen 50 % der Funktion abgedeckt werden. Führen Sie nun die Ergebnisse aus den zwei Testläufen zusammen. Der Bericht und die Code Coverage-Färbung geben nun an, dass 100 % der Funktion abgedeckt wird.

Verwenden Sie hierfür Ergebnisse zusammenführen. Sie können eine beliebige Kombination aus zuletzt ausgeführten Oder importierten Ergebnissen auswählen. Wenn Sie exportierte Ergebnisse kombinieren möchten, müssen Sie sie zuerst importieren.

Verwenden Sie Ergebnisse exportieren, um die Ergebnisse eines Zusammenführungsvorgangs zu speichern.

Einschränkungen beim Zusammenführen

• Wenn Sie Abdeckungsdaten aus verschiedenen Versionen des Codes zusammenführen, werden die Ergebnisse separat angezeigt, aber sie werden nicht kombiniert. Um vollständig kombinierte Ergebnisse zu erhalten, verwenden Sie denselben Build des Codes, und ändern Sie nur die Testdaten.

• Wenn Sie eine Ergebnisdatei zusammenführen, die exportiert und dann importiert wurde, können Sie die Ergebnisse nur nach Zeilen und nicht nach Blöcken anzeigen. Verwenden Sie den Befehl Spalten hinzufügen/entfernen, um die Zeilendaten anzuzeigen.

• Wenn Sie Ergebnisse aus Tests eines ASP.NET Projekts zusammenführen, werden die Ergebnisse für die separaten Tests angezeigt, aber nicht kombiniert. Dieses Verhalten gilt nur für die ASP.NET Artefakte selbst: Ergebnisse für alle anderen Assemblys werden kombiniert.

Ausschließen von Elementen aus den Codeabdeckungsergebnissen

Sie können bestimmte Elemente in Ihrem Code aus den Abdeckungsergebnissen ausschließen, z. B. wenn der Code aus einer Textvorlage generiert wird. Fügen Sie das attribut System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute zu einem der folgenden Codeelemente hinzu: Klasse, Struktur, Methode, Eigenschaft, Eigenschaftensatzer oder Getter, Ereignis.

Tipp

Durch Ausschließen einer Klasse werden die abgeleiteten Klassen nicht ausgeschlossen.

Zum Beispiel:

C#

using System.Diagnostics.CodeAnalysis;
...
public class ExampleClass1
{
    [ExcludeFromCodeCoverage]
    void ExampleMethod() {...}

    [ExcludeFromCodeCoverage] // exclude property
    int ExampleProperty1
    { get {...} set{...}}

    int ExampleProperty2
    {
        get
        {
            ...
        }
        [ExcludeFromCodeCoverage] // exclude setter
        set
        {
            ...
        }
    }

}
[ExcludeFromCodeCoverage]
class ExampleClass2 { ... }

VB

Imports System.Diagnostics.CodeAnalysis

Class ExampleClass1
    <ExcludeFromCodeCoverage()>
    Public Sub ExampleSub1()
        ...
    End Sub

    ' Exclude property
    < ExcludeFromCodeCoverage()>
    Property ExampleProperty1 As Integer
        ...
    End Property

    ' Exclude setter
    Property ExampleProperty2 As Integer
        Get
            ...
        End Get
        <ExcludeFromCodeCoverage()>
        Set(ByVal value As Integer)
            ...
        End Set
    End Property
End Class

<ExcludeFromCodeCoverage()>
Class ExampleClass2
...
End Class

C++

// A .cpp file compiled as managed (CLI) code.
using namespace System::Diagnostics::CodeAnalysis;
...
public ref class ExampleClass1
{
  public:
    [ExcludeFromCodeCoverage]
    void ExampleFunction1() { ... }

    [ExcludeFromCodeCoverage]
    property int ExampleProperty2 {...}

    property int ExampleProperty2 {
      int get() { ... }
     [ExcludeFromCodeCoverage]
      void set(int value) { ...  }
   }
}

[ExcludeFromCodeCoverage]
public ref class ExampleClass2
{ ... }

Ausschließen von Elementen im nativen C++-Code

So schließen Sie nicht verwaltete (systemeigene) Elemente in C++-Code aus:

#include <CodeCoverage\CodeCoverage.h>
...

// Exclusions must be compiled as unmanaged (native):
#pragma managed(push, off)

// Exclude a particular function:
ExcludeFromCodeCoverage(Exclusion1, L"MyNamespace::MyClass::MyFunction");

// Exclude all the functions in a particular class:
ExcludeFromCodeCoverage(Exclusion2, L"MyNamespace::MyClass2::*");

// Exclude all the functions generated from a particular template:
ExcludeFromCodeCoverage(Exclusion3, L"*::MyFunction<*>");

// Exclude all the code from a particular .cpp file:
ExcludeSourceFromCodeCoverage(Exclusion4, L"*\\unittest1.cpp");

// After setting exclusions, restore the previous managed/unmanaged state:
#pragma managed(pop)

Verwenden Sie die folgenden Makros:

ExcludeFromCodeCoverage(ExclusionName, L"FunctionName");

ExcludeSourceFromCodeCoverage(ExclusionName, L"SourceFilePath");

• ExclusionName ist ein eindeutiger Name.

• FunctionName ist ein vollqualifizierter Funktionsname. Es kann Wildcards enthalten. Wenn Sie beispielsweise alle Funktionen einer Klasse ausschließen möchten, schreiben Sie MyNamespace::MyClass::*

• SourceFilePath- ist der lokale oder UNC-Pfad einer .cpp Datei. Es kann Wildcards enthalten. Im folgenden Beispiel werden alle Dateien in einem bestimmten Verzeichnis ausgeschlossen: \\MyComputer\Source\UnitTests\*.cpp

• #include <CodeCoverage\CodeCoverage.h>

• Platzieren Sie Aufrufe der Ausschlussmakros im globalen Namespace, nicht innerhalb eines Namespaces oder einer Klasse.

• Sie können die Ausschlüsse entweder in der Komponententestcodedatei oder in der Anwendungscodedatei platzieren.

• Die Ausschlüsse müssen als nicht verwalteter (systemeigener) Code kompiliert werden, entweder durch Festlegen der Compileroption oder mithilfe von #pragma managed(off).

Anmerkung

Um Funktionen im C++/CLI-Code auszuschließen, wenden Sie das Attribut [System::Diagnostics::CodeAnalysis::ExcludeFromCodeCoverage] auf die Funktion an. Dies ist identisch mit C#.

Einschließen oder Ausschließen zusätzlicher Elemente

Codeabdeckungsanalyse wird nur für Assemblys ausgeführt, die geladen werden und für die eine PDB--Datei im selben Verzeichnis wie die .dll- oder .exe-Datei verfügbar ist. Daher können Sie in einigen Fällen den Satz von Assemblys erweitern, die enthalten sind, indem Sie Kopien der entsprechenden PDB--Dateien abrufen.

Sie können mehr Kontrolle darüber ausüben, welche Assemblys und Elemente für die Codeabdeckungsanalyse ausgewählt werden, indem Sie eine .runsettings Datei schreiben. Sie können beispielsweise Assemblys bestimmter Arten ausschließen, ohne attribute zu ihren Klassen hinzufügen zu müssen. Weitere Informationen finden Sie unter Anpassen der Code Coverage-Analyse.

Analysieren der Codeabdeckung in Azure-Pipelines

Wenn Sie Ihren Code einchecken, werden Ihre Tests zusammen mit Tests von anderen Teammitgliedern auf dem Buildserver ausgeführt. Es ist hilfreich, die Code Coverage in Azure Pipelines zu analysieren, um das aktuellste und umfassendste Bild der Code Coverage für das gesamte Projekt zu erhalten. Codeabdeckung in Azure Pipelines umfasst auch automatisierte Systemtests und andere codierte Tests, die Sie normalerweise nicht auf den Entwicklungscomputern ausführen.

Analysieren Sie die Codeabdeckung über die Befehlszeile

Verwenden Sie das Hilfsprogramm vstest.console.exe, um Tests über die Befehlszeile auszuführen. Code Coverage ist eine Option des Hilfsprogramms vstest.console.exe, die über die Option /EnableCodeCoverage aufgerufen wird.

1. Starten Sie die Entwickler-Eingabeaufforderung für Visual Studio:

   Suchen Sie im Windows Startmenü nach Developer Command Prompt for VS, und wählen Sie das App-Ergebnis aus, das Ihrem Suchtext zugeordnet ist.

2. Führen Sie an der Eingabeaufforderung den folgenden Befehl aus:

   vstest.console.exe MyTestAssembly.dll /EnableCodeCoverage
   

   Tipp

   Für Developer PowerShell ist das Startverzeichnis der Shell das Visual Studio-Projektverzeichnis. Ersetzen Sie MyTestAssembly.dll durch Pfad und Testdateiname. Weitere Informationen finden Sie unter VSTest.Console.exe Befehlszeilenoptionen.

Fehlersuche

Wenn keine Code Coverage-Ergebnisse angezeigt werden, lesen Sie den Artikel Problembehandlung bei der Code Coverage.

Verwandte Inhalte

• Anpassen der Codeabdeckungsanalyse
• Problembehandlung bei der Code Coverage
• Ausführen von Komponententests für Code