Testen von WinUI-Apps, die mit dem Windows App SDK erstellt wurden

In diesem Thema geben wir einige Empfehlungen zum Testen und Überprüfen der Funktionalität in Apps, die mit den Windows App SDK-Features mithilfe der WinUI 3-Benutzeroberfläche (UI) erstellt wurden. Das Testen ist ein wesentlicher Bestandteil des App-Entwicklungsprozesses– Es hilft Ihnen, Fehler frühzeitig abzufangen, die Codequalität aufrechtzuerhalten und eine zuverlässige Benutzererfahrung zu gewährleisten, während sich Ihre App weiterentwickelt. Durch die Integration von Unittests in Ihren Workflow können Sie Code problemlos refaktorisieren, neue Features hinzufügen und Updates veröffentlichen, in dem Wissen, dass vorhandene Funktionen weiterhin wie erwartet funktionieren.

Lernprogramm: Erstellen eines WinUI 3-Komponententestprojekts.

Die meisten Objekttypen unter den Microsoft.UI.Xaml-Namespaces müssen aus einem UI-Thread in einem XAML-Anwendungsprozess verwendet werden. (Ausführliche Informationen zum Testen von Apps, die mit Windows App SDK erstellt wurden, die WinUI 3 nicht verwenden, finden Sie im folgenden Abschnitt, Testing nicht-WinUI-Funktionalität.)

In diesem Tutorial erfahren Sie, wie:

Voraussetzungen

Sie müssen Visual Studio installiert und für die WinUI-Entwicklung eingerichtet haben. Siehe Schnellstart: Einrichten Ihrer Umgebung und Erstellen eines WinUI 3-Projekts.

Erstellen eines WinUI Unit Test App-Projekts

Erstellen Sie zunächst ein Komponententestprojekt. Der Projekttyp enthält alle Vorlagendateien, die Sie benötigen.

1. Öffnen Sie Visual Studio, und wählen Sie Ein neues Projekt erstellen im Startfenster aus.

   

2. Filtern Sie im Fenster Neues Projekt erstellen Projekte nach C#> Windows und WinUI wählen Sie die Vorlage WinUI Unit Test App aus, und wählen Sie dann Next

   

3. [Optional] Ändern Sie im Fenster Neues Projekt konfigurierenProjektname, Projektmappenname (entfernen Sie die Markierung bei Projektmappe und Projekt im selben Verzeichnis platzieren) und den Standort Ihres Projekts.

4. Wählen Sie "Erstellen" aus.

Ausführen von Tests mit Test-Explorer

Wenn Sie das Testprojekt erstellen, werden ihre Tests im Test-Explorer angezeigt, der zum Ausführen Ihrer Komponententests verwendet wird. Sie können Tests auch in Kategorien gruppieren, die Testliste filtern, Wiedergabelisten von Tests erstellen, speichern und ausführen, Komponententests debuggen und (in Visual Studio Enterprise) Codeabdeckung analysieren.

Die Datei UnitTests.cs enthält den Quellcode für die vom Test-Explorer verwendeten Komponententests. Standardmäßig werden die hier gezeigten grundlegenden Beispieltests automatisch erstellt:

namespace WinUITest1
{
   [TestClass]
   public class UnitTest1
   {
      [TestMethod]
      public void TestMethod1()
      {
         Assert.AreEqual(0, 0);
      }

      // Use the UITestMethod attribute for tests that need to run on the UI thread.
      [UITestMethod]
      public void TestMethod2()
      {
         var grid = new Grid();
         Assert.AreEqual(0, grid.MinWidth);
      }
   }
}

1. Wenn Sie es noch nicht getan haben, erstellen Sie Ihre Lösung. Dadurch kann Visual Studio alle verfügbaren Tests "entdecken".

2. Öffnen Sie den Test-Explorer. Öffnen Sie das Menü Test, wenn es noch nicht angezeigt wird, und wählen Sie dann Test-Explorer aus (oder drücken Sie die Tasten STRG+E, T).

   

3. Sehen Sie sich die Tests an. Erweitern Sie im Test-Explorer-Fenster alle Knoten (zu diesem Zeitpunkt sind nur die Beispieltests vorhanden).

   

4. Führen Sie Tests durch.

   • Klicken Sie mit der rechten Maustaste auf einzelne Testknoten, und wählen Sie Ausführen aus.
   • Wählen Sie einen Test aus, und drücken Sie entweder die Schaltfläche Wiedergeben, oder drücken Sie die Tasten STRG+R, T.
   • Drücken Sie die Schaltfläche Alle Tests in der Ansicht ausführen, oder drücken Sie die Tasten STRG+R, V.

   

5. Überprüfen Sie die Ergebnisse. Nach Abschluss der Tests werden die Ergebnisse im Test-Explorer-Fenster angezeigt.

   

Hinzufügen eines Klassenbibliotheksprojekts zum Testen

6. Fügen Sie der Komponententest-Projektmappe ein neues Projekt hinzu. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf die Projektmappe, und wählen Sie Hinzufügen -> Neues Projekt....

   

7. Fügen Sie in diesem Beispiel ein WinUI 3-Klassenbibliotheksprojekt hinzu. Filtern Sie im Fenster "Neues Projekt" nach C#/Windows/WinUI, und wählen Sie WinUI-Klassenbibliothek aus.

   

8. Wählen Sie "Weiter" aus, und geben Sie einen Namen für das Projekt ein (in diesem Beispiel verwenden WinUIClassLibrary1wir), und drücken Sie "Erstellen".

   

9. Fügen Sie dem Projekt ein neues UserControl hinzu. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf das WinUI 3-Klassenbibliotheksprojekt, das Sie soeben hinzugefügt haben, und wählen Sie im Kontextmenü Add -> Neues Element aus.

   

10. Wählen Sie im Fenster " Neues Element hinzufügen " den WinUI-Knoten in der Liste " Installierte Elemente" und dann " Benutzersteuerelement " aus den Ergebnissen aus. Benennen Sie das Steuerelement UserControl1.

    

11. Öffnen Sie die Code-Behind-Datei UserControl1.xaml.cs. In diesem Beispiel fügen wir eine neue öffentliche Methode GetSeven hinzu, die einfach eine ganze Zahl zurückgibt.

    namespace WinUIClassLibrary1
    {
      public sealed partial class UserControl1 : UserControl
      {
         public UserControl1()
         {
             this.InitializeComponent();
         }
    
         public int GetSeven()
         {
             return 7;
         }
      }
    }
    

12. Legen Sie das WinUI 3-Klassenbibliotheksprojekt als Abhängigkeit des Komponententestprojekts fest, um die Verwendung von Typen aus dem WinUI 3-Klassenbibliotheksprojekt zu ermöglichen. Klicken Sie in Projektmappen-Explorer unter dem Klassenbibliotheksprojekt mit der rechten Maustaste auf Dependencies und wählen Sie Add Project Reference aus.

    

    Wählen Sie das WinUIClassLibrary1 Element aus der Projektliste aus.

    

13. Erstellen Sie in UnitTests.cs eine neue Testmethode. Da in diesem Testfall ein XAML-UI-Thread ausgeführt werden muss, markieren Sie ihn mit dem [UITestMethod] Attribut anstelle des Standardattributes [TestMethod] .

    [UITestMethod]
    public void TestUserControl1()
    {
       WinUIClassLibrary1.UserControl1 userControl1 = new WinUIClassLibrary1.UserControl1();
       Assert.AreEqual(7, userControl1.GetSeven());
    }
    

    Diese neue Testmethode wird nun im Test-Explorer als einer Ihrer Komponententests angezeigt.

    

14. Führen Sie Tests durch.

• Klicken Sie mit der rechten Maustaste auf den neuen Testknoten, und wählen Sie Ausführen aus.
• Wählen Sie den neuen Test aus, und drücken Sie entweder die Schaltfläche Wiedergeben, oder drücken Sie die Tasten STRG+R, T.
• Drücken Sie die Schaltfläche Alle Tests in der Ansicht ausführen, oder drücken Sie die Tasten STRG+R, V.

Testen der Nicht-WinUI-Funktionalität

In vielen Fällen umfasst eine App Funktionalität, die nicht von Microsoft.UI.Xaml-Typen abhängt, aber dennoch getestet werden muss. Es stehen verschiedene Tools zum Testen .NET Codes zur Verfügung, einschließlich MSTest, NUnit und xUnit. Weitere Informationen zum Testen .NET Apps finden Sie unter Testing in .NET.

In Visual Studio können Sie ein neues Projekt für jedes dieser Testtools erstellen, indem Sie mit der rechten Maustaste auf Ihre Lösung in Projektmappen-Explorer klicken, wählen Sie > aus dem Kontextmenü aus, wählen Sie C# aus dem Alle Sprachen Selektor/Windows aus dem Alle Sprachen Selektor/Test aus dem Alle Projekttypen Auswahlsystem, und wählen Sie dann das entsprechende Testtool aus der Liste aus (MSTest Test Project, NUnit Test Project oder xUnit Test Project).

Beim Erstellen eines neuen MSTest-, NUnit- oder xUnit-Projekts, das auf ein WinUI 3-Projekt verweist, müssen Sie:

1. Aktualisieren Sie die TargetFramework in der .csproj-Datei Ihres Testprojekts. Dieser Wert muss mit dem Wert im TargetFramework WinUI 3-Projekt übereinstimmen. Standardmäßig sind MSTest-, NUnit- und xUnit-Projekte auf die gesamte Palette von Plattformen ausgerichtet, die von .NET unterstützt werden, aber ein WinUI 3-Projekt unterstützt nur Windows und verfügt über ein spezifisches TargetFramework.

   Wenn Sie beispielsweise auf .NET 8 abzielen, aktualisieren Sie das TargetFramework des Unit-Test-Projekts von <TargetFramework>net8.0</TargetFramework> auf <TargetFramework>net8.0-windows10.0.19041.0</TargetFramework>.

2. Die RuntimeIdentifiers in Ihrem Testprojekt aktualisieren.

   <RuntimeIdentifiers Condition="$([MSBuild]::GetTargetFrameworkVersion('$(TargetFramework)')) &gt;= 8">win-x86;win-x64;win-arm64</RuntimeIdentifiers>

   <RuntimeIdentifiers Condition="$([MSBuild]::GetTargetFrameworkVersion('$(TargetFramework)')) &lt; 8">win10-x86;win10-x64;win10-arm64</RuntimeIdentifiers>

3. Fügen Sie die folgende Eigenschaft zur PropertyGroup in der CSPROJ-Datei Ihres Testprojekts hinzu, um sicherzustellen, dass der Test die Windows App SDK Laufzeit lädt: <WindowsAppSdkBootstrapInitialize>true</WindowsAppSdkBootstrapInitialize>

4. Stellen Sie sicher, dass die Windows App SDK Laufzeit auf dem Computer installiert ist, auf dem der Test ausgeführt wird. Weitere Informationen zur Windows App SDK Bereitstellung finden Sie im Windows App SDK Bereitstellungshandbuch für frameworkabhängige Apps, die mit externem Speicherort (oder entpackt) verpackt sind.

Benutzeroberflächentestautomatisierung

Für End-to-End-Tests der Benutzeroberfläche Ihrer App können Sie automatisierte Ui-Testtools verwenden, die mit Ihrer App interagieren, wie ein Benutzer auf Schaltflächen klickt, Text eingibt und den visuellen Zustand überprüft.

Appium mit WinAppDriver

WinAppDriver war das ursprüngliche Microsoft Tool für Windows Benutzeroberflächenautomatisierungstests, aber es ist nicht mehr aktiv. Der empfohlene Nachfolger ist Appium mit dem Windows Anwendungstreiber-Plug-In (appium-windows-driver). Appium verwendet dasselbe WebDriver-Protokoll und unterstützt Windows Desktop-Apps über das Windows Benutzeroberflächenautomatisierung Framework.

So richten Sie Appium für eine WinUI 3-Desktop-App ein:

1. Appium installieren: npm install -g appium
2. Installieren Sie den Windows Treiber:appium driver install windows
3. Überprüfen Sie, ob der Treiber installiert ist: appium driver list (sollte als installiert angezeigt werden windows )
4. Starten Sie den Appium-Server: appium
5. Schreiben von Tests mithilfe einer WebDriver-Clientbibliothek (verfügbar für C#, Python, Java und JavaScript).

Barrierefreiheitserkenntnisse und Benutzeroberflächenautomatisierung

Accessibility Insights for Windows hilft Ihnen, die UI-Automatisierungsstruktur Ihrer App zu prüfen und zu validieren. Die durch Benutzeroberflächenautomatisierung verfügbar gemachten Elemente sind dieselben Elemente, mit denen automatisierte Testtools interagieren. Sicherstellen, dass Ihre App über eine gut strukturierte Automatisierungsstruktur verfügt, verbessert sowohl die Barrierefreiheit als auch die Testbarkeit.

Microsoft Playwright (Web-UI in WebView2)

Wenn Ihre App WebView2 für Webinhalte verwendet, können Sie Microsoft Playwright verwenden, um die Webparts zu testen. Playwright unterstützt automatisierte Browsertests und kann für die End-to-End-Szenarioüberprüfung eine Verbindung mit WebView2-Instanzen herstellen.

Codequalität und statische Analyse

Statische Analysetools erfassen Fehler, Sicherheitsprobleme und Codequalitätsprobleme vor der Laufzeit. Integrieren Sie diese in Ihren Entwicklungsworkflow und CI-Pipelines, um eine konsistente Qualität zu erzielen.

.NET Analyzer (Roslyn)

.NET Projekte umfassen integrierte Roslyn-Analysegeräte, die auf Richtigkeit, Leistung, Zuverlässigkeit und Sicherheitsprobleme überprüfen. So aktivieren Sie alle empfohlenen Regeln in Ihrem Projekt:

<PropertyGroup>
  <AnalysisLevel>latest-recommended</AnalysisLevel>
  <EnforceCodeStyleInBuild>true</EnforceCodeStyleInBuild>
</PropertyGroup>

Sie können Regelschweregrade in einer .editorconfig-Datei oder durch Verwendung von <NoWarn> in Ihrer Projektdatei konfigurieren. Weitere Informationen finden Sie in der Übersicht über die .NET-Quellcodeanalyse.

Statische C++-Analyse (/analyse)

Aktivieren Sie für C++-Windows App SDK- und Win32-Projekte die statische Codeanalyse von Microsoft, indem Sie /analyze in Ihren Projekteigenschaften oder in MSBuild festlegen:

<PropertyGroup>
  <EnableMicrosoftCodeAnalysis>true</EnableMicrosoftCodeAnalysis>
  <CodeAnalysisRuleSet>CppCoreCheckRules.ruleset</CodeAnalysisRuleSet>
</PropertyGroup>

C++ Core Guidelines Checker erzwingt moderne bewährte Methoden für C++. Bei Win32-API-Verwendungsmustern erfassen SAL-Anmerkungen und das /analyze Flag allgemeine Lebenszyklus-, Puffer- und Parallelitätsprobleme.

CI-Integration

Fügen Sie Ihrem CI-Workflow statische Analysen hinzu, sodass Codequalitätsprüfungen für jede Pullanforderung ausgeführt werden. In einem GitHub Actions Workflow:

    - name: Build with analysis
      run: dotnet build --configuration Release /p:AnalysisLevel=latest-recommended /p:TreatWarningsAsErrors=true

Für C++-Projekte mit MSBuild:

    - name: Build with /analyze
      run: msbuild MySolution.sln /p:Configuration=Release /p:EnableMicrosoftCodeAnalysis=true /p:RunCodeAnalysis=true

Telemetrie- und Absturzberichte

Durch das Sammeln von Telemetrie- und Absturzdaten aus der Produktion können Sie verstehen, wie Ihre App in der realen Welt ausgeführt wird, Regressionen identifizieren und Korrekturen priorisieren.

Application Insights

Azure-Anwendung Insights bietet Absturzberichte, Leistungsüberwachung und Nutzungsanalysen für Desktop-Apps. So fügen Sie es einem Windows App SDK Projekt hinzu:

1. Installieren Sie das NuGet-Paket: Microsoft.ApplicationInsights
2. Initialisieren Sie den TelemetryClient beim Start Ihrer App mit Ihrer Verbindungszeichenfolge
3. Nachverfolgen von Ausnahmen, Ereignissen und Seitenansichten

Ausführliche Einrichtungsanweisungen finden Sie unter Application Insights für .NET Konsolen- und Desktop-Apps.

OpenTelemetry

OpenTelemetry ist ein anbieterneutraler Standard zum Sammeln von Protokollen, Metriken und verteilten Ablaufverfolgungen. Das .NET OpenTelemetry SDK ist in Azure Monitor und andere Back-Ends integriert.

Installieren Sie die erforderlichen Pakete:

dotnet add package OpenTelemetry
dotnet add package Azure.Monitor.OpenTelemetry.Exporter

Konfigurieren Sie dann den Tracer-Provider:

var activitySource = new System.Diagnostics.ActivitySource("MyApp");
// OpenTelemetry SDKs can listen to ActivitySource instances like this one.
using var activity = activitySource.StartActivity("Startup");
activity?.SetTag("app.version", "1.0.0");

OpenTelemetry ist der empfohlene Ansatz für neue Projekte, die Multi-Backend-Unterstützung oder verteilte Ablaufverfolgung benötigen. Application Insights bleibt eine gute Wahl, wenn Sie Azure Monitor ausschließlich verwenden und turnkey Dashboards verwenden möchten.

Windows-Fehlerberichterstattung (WER)

Für die systemeigene Sammlung von Absturzdaten erfasst die Windows-Fehlerberichterstattung automatisch Absturzabbilder, wenn Ihre App unerwartet beendet wird. Verpackte Apps (MSIX) erhalten Absturzdaten, die über Partner Center-Qualitätsberichte angezeigt werden. Für Organisations-Apps (LOB) können Sie die lokale WER-Dumpsammlung konfigurieren, um Minidumps für die lokale Analyse zu speichern.

Weitere Ressourcen

• Unittest-Grundlagen
• Testing-Tools in Visual Studio
• Kontinuierliche Integration für WinUI-Apps
• Übersicht über die .NET-Quellcodeanalyse
• C++-Codeanalyse
• Azure Monitor Application Insights
• OpenTelemetry .NET SDK