Blog

.NET 10 Tests ausführen mit Dotnet Test

Ashley Goolam

Ashley Goolam

27 August 2025

.NET 10 Tests ausführen mit Dotnet Test

Hallo, .NET-Entwickler! Bereit, Ihr Testspiel mit der Microsoft Testing Platform (MTP) und .NET 10 auf das nächste Level zu heben? Wenn Sie bisher dotnet test mit dem traditionellen VSTest-Runner verwendet haben, schnallen Sie sich an – MTP ist hier, um Ihr Testen reibungsloser, schneller und flexibler zu gestalten. In diesem konversationsorientierten Leitfaden werden wir untersuchen, was MTP, auch bekannt als MicrosoftTestingPlatform, ist, warum es eine Verbesserung gegenüber VSTest darstellt und wie Sie es mit dotnet test in .NET 10 nutzen können, um robuste Tests für Ihre Projekte zu erstellen. Ich führe Sie durch die Schritte, die ich unternommen habe, um dieses Setup zu experimentieren, von einem grundlegenden MSTest-Projekt bis hin zu einer Multi-Projekt-Lösung mit einer eigenständigen ausführbaren Datei. Tauchen wir ein in die Welt von MTP, MicrosoftTestingPlatform, .NET 10, dotnet test und machen wir das Testen einfacher und unterhaltsamer!

💡
Möchten Sie ein großartiges API-Test-Tool, das wunderschöne API-Dokumentation generiert?

Möchten Sie eine integrierte All-in-One-Plattform, damit Ihr Entwicklerteam mit maximaler Produktivität zusammenarbeiten kann?

Apidog erfüllt all Ihre Anforderungen und ersetzt Postman zu einem viel günstigeren Preis!
button

Warum ist Testen in der .NET-Entwicklung wichtig?

Bevor wir uns die Hände schmutzig machen, sprechen wir darüber, warum Testen eine große Sache ist. Egal, ob Sie eine kleine App oder ein riesiges Unternehmenssystem erstellen, Tests stellen sicher, dass Ihr Code wie erwartet funktioniert, Fehler frühzeitig erkannt werden und Sie vor nächtlichen Debugging-Sitzungen bewahrt werden. Automatisierte Unit-Tests, wie die, die wir mit MSTest und MTP erstellen werden, ermöglichen es Ihnen, die Funktionalität zu überprüfen, die Codequalität zu verbessern und Refactoring zum Kinderspiel zu machen. Mit den Leistungssteigerungen von .NET 10 und dem modernen Test-Framework von MTP sind Sie bereit, Tests zu schreiben, die schnell, zuverlässig und einfach in CI/CD-Pipelines zu integrieren sind. Bereit zu sehen, wie? Folgen wir meiner Reise!

Was ist die Microsoft Testing Platform (MTP)?

Die Microsoft Testing Platform (MTP), oder MicrosoftTestingPlatform, ist Microsofts Test-Framework der nächsten Generation, das eingeführt wurde, um den alternden VSTest-Runner zu ersetzen. Im Gegensatz zu VSTest, das auf komplexen Adaptern und DLL-basierter Ausführung basiert, bietet MTP ein optimiertes, natives Erlebnis für die Ausführung von Tests in .NET. Es ist in .NET 10 integriert, wodurch es schneller und flexibler ist, mit Funktionen wie eigenständigen ausführbaren Test-Runnern und einer besseren Integration mit dotnet test. MTP unterstützt MSTest, NUnit und xUnit und ist für moderne Workflows konzipiert, einschließlich CI/CD und plattformübergreifender Entwicklung. Sie können es sich als den cooleren, effizienteren Bruder von VSTest vorstellen, optimiert für die Leistungsverbesserungen von .NET 10.

Schritt 1: Einrichten eines grundlegenden MSTest-Projekts mit MTP

Beginnen wir einfach mit der Erstellung eines grundlegenden MSTest-Projekts, um MTP in Aktion zu sehen. So habe ich angefangen:

Projekt erstellen:

dotnet new mstest -n MyMtpTests

Projektdatei überprüfen:

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>net8.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
    <IsPackable>false</IsPackable>
    <IsTestProject>true</IsTestProject>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="coverlet.collector" Version="6.0.0" />
    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
    <PackageReference Include="MSTest.TestAdapter" Version="3.1.1" />
    <PackageReference Include="MSTest.TestFramework" Version="3.1.1" />
  </ItemGroup>
</Project>

Tests ausführen:

cd MyMtpTests

dotnet test
vstest runner

Was passiert? Dies ist ein traditionelles Setup mit VSTest, aber es ist eine solide Grundlage, bevor wir auf MTP aktualisieren. Das Projekt führt Tests als DLL aus, was in Ordnung ist, aber nicht so flexibel wie MTPs ausführbarer Ansatz.

Schritt 2: Entwicklung zu einem ausführbaren MTP-basierten Test-Runner

Machen wir es jetzt spannender, indem wir zum eigenständigen ausführbaren Runner von MTP wechseln, mit dem Sie Tests ohne dotnet test ausführen können. So habe ich es gemacht:

Projektdatei aktualisieren:

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>net8.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
    <IsPackable>false</IsPackable>
    <IsTestProject>true</IsTestProject>
    <!-- Enable MTP runner and executable output -->
    <EnableMSTestRunner>true</EnableMSTestRunner>
    <TestingPlatformDotnetTestSupport>true</TestingPlatformDotnetTestSupport>
    <OutputType>Exe</OutputType>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="coverlet.collector" Version="6.0.0" />
    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
    <PackageReference Include="MSTest.TestFramework" Version="3.10.2" />
    <PackageReference Include="MSTest.TestAdapter" Version="3.10.2" />
  </ItemGroup>
  <ItemGroup>
    <Using Include="Microsoft.VisualStudio.TestTools.UnitTesting" />
  </ItemGroup>
</Project>

Wesentliche Änderungen:

Projekt erstellen:

dotnet build
exe file generated

Ausführbare Datei ausführen:

cd bin/Debug/net8.0
run test on .exe file

Warum das rockt: Der ausführbare Ansatz ist perfekt für benutzerdefinierte CI/CD-Setups oder Umgebungen ohne installiertes .NET SDK. Es ist ein Wendepunkt für Flexibilität, und MTP macht es schneller als VSTest, indem es den Overhead reduziert.

Schritt 3: Professionell werden mit .NET 10 und Multi-Projekt-Tests

Um MTP und .NET 10 in einem realen Szenario glänzen zu sehen, erstellen wir eine Multi-Projekt-Lösung mit einer Klassenbibliothek und Tests. So habe ich es eingerichtet:

Endgültige Projektstruktur:

MyMtpSolution/
│
├── MyLibrary/
│   ├── Calculator.cs
│   └── MyLibrary.csproj
│
├── MyLibrary.Tests/
│   ├── CalculatorTests.cs
│   └── MyLibrary.Tests.csproj
│
├── MyMtpSolution.sln
└── dotnet.config

1. Eine Lösung erstellen:

dotnet new sln -n MyMtpSolution

2. Eine Klassenbibliothek erstellen:

dotnet new classlib -n MyLibrary

namespace MyLibrary
{
    public class Calculator
    {
        public int Add(int a, int b) => a + b;
        public int Subtract(int a, int b) => a - b;
        public int Multiply(int a, int b) => a * b;
        public int Divide(int a, int b) => 
            b == 0 ? throw new ArgumentException("Cannot divide by zero.") : a / b;
    }
}

3. Ein Testprojekt erstellen:

dotnet new mstest -n MyLibrary.Tests

using Microsoft.VisualStudio.TestTools.UnitTesting;
using MyLibrary;

namespace MyLibrary.Tests
{
    [TestClass]
    public class CalculatorTests
    {
        private Calculator _calculator;

        [TestInitialize]
        public void Setup()
        {
            _calculator = new Calculator();
        }

        [TestMethod]
        public void Add_ReturnsCorrectSum()
        {
            Assert.AreEqual(5, _calculator.Add(2, 3));
        }

        [TestMethod]
        public void Subtract_ReturnsCorrectDifference()
        {
            Assert.AreEqual(1, _calculator.Subtract(3, 2));
        }

        [TestMethod]
        public void Multiply_ReturnsCorrectProduct()
        {
            Assert.AreEqual(6, _calculator.Multiply(2, 3));
        }

        [TestMethod]
        public void Divide_ReturnsCorrectQuotient()
        {
            Assert.AreEqual(2, _calculator.Divide(6, 3));
        }

        [TestMethod]
        [ExpectedException(typeof(ArgumentException))]
        public void Divide_ByZero_ThrowsException()
        {
            _calculator.Divide(6, 0);
        }
    }
}

4. Projektverweise hinzufügen:

dotnet add MyLibrary.Tests reference MyLibrary

5. Projekte zur Lösung hinzufügen:

dotnet sln MyMtpSolution.sln add MyLibrary/MyLibrary.csproj
dotnet sln MyMtpSolution.sln add MyLibrary.Tests/MyLibrary.Tests.csproj

6. Für MTP konfigurieren:

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>net8.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
    <IsPackable>false</IsPackable>
    <IsTestProject>true</IsTestProject>
    <EnableMSTestRunner>true</EnableMSTestRunner>
    <TestingPlatformDotnetTestSupport>true</TestingPlatformDotnetTestSupport>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="coverlet.collector" Version="6.0.0" />
    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
    <PackageReference Include="MSTest.TestFramework" Version="3.10.2" />
    <PackageReference Include="MSTest.TestAdapter" Version="3.10.2" />
  </ItemGroup>
  <ItemGroup>
    <Using Include="Microsoft.VisualStudio.TestTools.UnitTesting" />
  </ItemGroup>
</Project>

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>net8.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
  </PropertyGroup>
</Project>

7. Auf .NET 10 aktualisieren:

download .net10
<TargetFramework>net10.0</TargetFramework>

8. Eine dotnet.config-Datei erstellen:

[dotnet.test.runner]
name = "Microsoft.Testing.Platform"

9. Tests erstellen und ausführen:

dotnet test
running the tests

Warum das großartig ist: .NET 10 bringt Leistungsverbesserungen (schnelleres JIT, besseres Speichermanagement), und MTPs native Integration eliminiert die Legacy-Brücken von VSTest, wodurch Tests schneller und zuverlässiger werden. Das Multi-Projekt-Setup ahmt reale Anwendungen nach, mit einer Bibliothek und einem separaten Testprojekt.

Wie .NET 10 und MTP das Testen verbessern

MTP und .NET 10 heben das Testen auf die nächste Stufe:

Benutzer schwärmen von MTP: „Es ist wie VSTest, aber ohne den Ballast – schneller und sauberer!“ Mit .NET 10 erhalten Sie modernste Leistung, und MTP macht dotnet test zu einer Freude.

Tipps zur Fehlerbehebung

Fazit

Sie sind jetzt ein Profi in der Verwendung von MTP (MicrosoftTestingPlatform), .NET 10, dotnet test, um ein modernes Test-Setup zu erstellen! Von einem grundlegenden MSTest-Projekt bis hin zu einer Multi-Projekt-Lösung mit einer eigenständigen ausführbaren Datei haben Sie gesehen, wie MTP VSTest übertrifft und wie .NET 10 die Leistung steigert. Versuchen Sie, weitere Tests hinzuzufügen, in Ihre CI/CD-Pipeline zu integrieren oder die erweiterten Funktionen von MTP wie die parallele Ausführung zu erkunden. Haben Sie coole Test-Setups? Teilen Sie sie – lassen Sie uns die Test-Vibes am Laufen halten!

button

Praktizieren Sie API Design-First in Apidog

Entdecken Sie eine einfachere Möglichkeit, APIs zu erstellen und zu nutzen

Kostenlos registrierenDownload