Blog

Comment exécuter des tests avec Dotnet Test dans .NET 10

Ashley Goolam

Ashley Goolam

27 August 2025

Comment exécuter des tests avec Dotnet Test dans .NET 10

Salut les développeurs .NET ! Prêts à faire passer vos tests au niveau supérieur avec la **Microsoft Testing Platform (MTP)** et **.NET 10** ? Si vous utilisiez dotnet test avec l'exécuteur VSTest traditionnel, accrochez-vous — la **MTP** est là pour rendre vos tests plus fluides, plus rapides et plus flexibles. Dans ce guide conversationnel, nous explorerons ce qu'est la **MTP**, également connue sous le nom de **MicrosoftTestingPlatform**, pourquoi elle représente une avancée par rapport à VSTest, et comment l'exploiter avec **dotnet test** dans **.NET 10** pour créer des tests robustes pour vos projets. Je vous guiderai à travers les étapes que j'ai suivies pour expérimenter cette configuration, d'un projet MSTest basique à une solution multi-projets avec un exécutable autonome. Plongeons dans le monde de la **MTP, MicrosoftTestingPlatform, .NET 10, dotnet test** et rendons les tests plus faciles et plus amusants !

💡
Vous voulez un excellent outil de test d'API qui génère une belle documentation API ?

Vous voulez une plateforme intégrée, tout-en-un, pour que votre équipe de développeurs travaille ensemble avec une productivité maximale ?

Apidog répond à toutes vos exigences et remplace Postman à un prix beaucoup plus abordable !
bouton

Pourquoi les tests sont-ils importants dans le développement .NET ?

Avant de nous lancer, parlons de l'importance des tests. Que vous développiez une petite application ou un système d'entreprise massif, les tests garantissent que votre code fonctionne comme prévu, détectent les bogues tôt et vous évitent ces sessions de débogage nocturnes. Les tests unitaires automatisés, comme ceux que nous créerons avec **MSTest** et **MTP**, vous permettent de vérifier les fonctionnalités, d'améliorer la qualité du code et de faciliter le refactoring. Avec les améliorations de performance de **.NET 10** et le framework de test moderne de la **MTP**, vous êtes prêt à écrire des tests rapides, fiables et faciles à intégrer dans les pipelines CI/CD. Prêt à voir comment ? Suivons mon parcours !

Qu'est-ce que la Microsoft Testing Platform (MTP) ?

La **Microsoft Testing Platform (MTP)**, ou **MicrosoftTestingPlatform**, est le framework de test de nouvelle génération de Microsoft, introduit pour remplacer l'exécuteur VSTest vieillissant. Contrairement à VSTest, qui repose sur des adaptateurs complexes et une exécution basée sur des DLL, la **MTP** offre une expérience simplifiée et native pour l'exécution des tests dans .NET. Elle est intégrée à **.NET 10**, ce qui la rend plus rapide et plus flexible, avec des fonctionnalités telles que des exécuteurs de tests exécutables autonomes et une meilleure intégration avec dotnet test. La **MTP** prend en charge MSTest, NUnit et xUnit, et est conçue pour les flux de travail modernes, y compris le CI/CD et le développement multiplateforme. Vous pouvez la considérer comme la version plus cool et plus efficace de VSTest, optimisée pour les améliorations de performance de **.NET 10**.

Étape 1 : Configuration d'un projet MSTest basique avec MTP

Commençons simplement en créant un projet MSTest basique pour voir la **MTP** en action. Voici comment j'ai démarré :

Créer le projet :

dotnet new mstest -n MyMtpTests

Vérifier le fichier projet :

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

Exécuter les tests :

cd MyMtpTests

dotnet test
exécuteur vstest

Que se passe-t-il ? Il s'agit d'une configuration traditionnelle utilisant VSTest, mais c'est une base solide avant de passer à la **MTP**. Le projet exécute les tests sous forme de DLL, ce qui est bien mais pas aussi flexible que l'approche exécutable de la **MTP**.

Étape 2 : Évolution vers un exécuteur de tests basé sur un exécutable MTP

Maintenant, rendons les choses plus intéressantes en passant à l'exécuteur exécutable autonome de la **MTP**, qui vous permet d'exécuter des tests sans dotnet test. Voici comment j'ai fait :

Mettre à jour le fichier projet :

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

Modifications clés :

Compiler le projet :

dotnet build
fichier exe généré

Exécuter l'exécutable :

cd bin/Debug/net8.0
exécuter le test sur le fichier .exe

Pourquoi c'est génial : L'approche exécutable est parfaite pour les configurations CI/CD personnalisées ou les environnements sans le SDK .NET installé. C'est un atout majeur pour la flexibilité, et la **MTP** la rend plus rapide que VSTest en réduisant les frais généraux.

Étape 3 : Passer au niveau supérieur avec .NET 10 et les tests multi-projets

Pour voir la **MTP** et **.NET 10** briller dans un scénario réel, construisons une solution multi-projets avec une bibliothèque de classes et des tests. Voici comment je l'ai configurée :

Structure finale du projet :

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

1. Créer une solution :

dotnet new sln -n MyMtpSolution

2. Créer une bibliothèque de classes :

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. Créer un projet de test :

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. Ajouter des références de projet :

dotnet add MyLibrary.Tests reference MyLibrary

5. Ajouter des projets à la solution :

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

6. Configurer pour MTP :

<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. Mettre à niveau vers .NET 10 :

télécharger .net10
<TargetFramework>net10.0</TargetFramework>

8. Créer un fichier dotnet.config :

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

9. Compiler et exécuter les tests :

dotnet test
exécution des tests

Pourquoi c'est génial : **.NET 10** apporte des améliorations de performance (JIT plus rapide, meilleure gestion de la mémoire), et l'intégration native de la **MTP** élimine les ponts hérités de VSTest, rendant les tests plus rapides et plus fiables. La configuration multi-projets imite les applications réelles, avec une bibliothèque et un projet de test séparé.

Comment .NET 10 et MTP améliorent les tests

La **MTP** et **.NET 10** portent les tests au niveau supérieur :

Les utilisateurs sont enthousiastes à propos de la **MTP** : « C'est comme VSTest mais sans le fardeau — plus rapide et plus propre ! » Avec **.NET 10**, vous bénéficiez de performances de pointe, et la **MTP** rend dotnet test un plaisir.

Conseils de dépannage

Conclusion

Vous êtes maintenant un expert dans l'utilisation de la **MTP (MicrosoftTestingPlatform), .NET 10, dotnet test** pour construire une configuration de test moderne ! D'un projet MSTest basique à une solution multi-projets avec un exécutable autonome, vous avez vu comment la **MTP** surpasse VSTest et comment **.NET 10** améliore les performances. Essayez d'ajouter plus de tests, de les intégrer dans votre pipeline CI/CD, ou d'explorer les fonctionnalités avancées de la **MTP** comme l'exécution parallèle. Vous avez des configurations de test sympas ? Partagez-les — continuons sur cette lancée des tests !

bouton

Pratiquez le Design-first d'API dans Apidog

Découvrez une manière plus simple de créer et utiliser des API

S'inscrire gratuitementTélécharger