Gute Tests ohne Umwege: Unittests mit Copilot für Dotnet bringen Tempo und Klarheit direkt in Visual Studio 2026 v18.3. Copilot erzeugt Tests, baut und führt sie aus, erkennt Fehler und versucht sie zu beheben. Du startest per @Test im Chat, per Rechtsklick im Editor oder über Icebreaker – alles ohne Kontextwechsel. Die neue Funktion ist jetzt allgemein verfügbar in Visual Studio 2026 v18.3. Sie macht Unit-Testing schneller, einfacher und konsistenter. Der Workflow integriert sich in die IDE, reagiert auf natürliche Anweisungen und bietet neue Einstiegspunkte. Grundlage sind Erfahrungen aus echten Projekten und viel Feedback aus der Insider-Phase. So sparst du Zeit zwischen Code schreiben und Code absichern. Mit Unittests mit Copilot für Dotnet bekommst du verlässliche Ergebnisse in wenigen Schritten und bleibst im Fluss.

Unittests mit Copilot für Dotnet: Was ist jetzt möglich?

GitHub Copilot testing for .NET ist auf Unit-Tests spezialisiert. Der Agent kennt deine Lösungsstruktur, deine Test-Frameworks und den Build. Er arbeitet als End-to-End-Prozess und nicht als einmalige Antwort. Du wählst den Scope, Copilot erledigt den Rest. Du kannst den Umfang flexibel setzen: – einzelnes Member – eine Klasse – eine Datei – ein Projekt – die komplette Solution – deinen aktuellen Git-Diff Copilot nutzt diesen Rahmen, um zu entscheiden, welche Tests entstehen, wo sie landen und wie sie sich ausführen lassen. Der Agent beachtet deine Projektkonfiguration und das gewählte Test-Framework, damit Visual Studio die Tests sauber findet und ausführt. Außerdem funktioniert der Agent mit jedem Modell, das du in Copilot Chat ausgewählt hast. So kombinierst du dein bevorzugtes Modell mit einem Workflow, der speziell für Tests gebaut wurde. Mit Unittests mit Copilot für Dotnet wählst du also nur Ziel und Stil, der Rest läuft koordiniert im Hintergrund.

Ein Workflow statt Einmal-Antwort

Wenn du einen Testauftrag startest, führt Copilot einen iterativen Prozess aus: – Erzeugt Unit-Tests für den gewählten Code – Baut und führt die Tests automatisch aus – Erkennt Fehlschläge und versucht, sie zu reparieren – Wiederholt die Ausführung, bis ein stabiler Startpunkt entsteht Das spart dir manuelles Nachjustieren. Du musst nicht separat bauen, Tests starten und Fehler sortieren. Stattdessen bekommst du zügig eine lauffähige Basis, auf der du aufbauen kannst.

Transparente Zusammenfassung nach der Generierung

Nach dem Lauf zeigt Copilot eine strukturierte Übersicht: – Welche Testdateien und Testprojekte neu sind oder geändert wurden – Vorher-Nachher-Informationen zur Abdeckung – Pass/Fail-Signale und instabile Fälle – Hinweise auf Lücken in der Testbarkeit – Direkte Links zu den erzeugten Tests, damit du sofort prüfen und nachziehen kannst Diese Übersicht verkürzt die Schleife zwischen Implementierung und Absicherung. Du siehst auf einen Blick, was passiert ist, und kommst schneller zur nächsten Verbesserung.

Natürliches Prompten mit @Test

Du startest den Agenten im Copilot Chat mit @Test. Ab jetzt musst du keine starre Befehlsform mehr merken. Du beschreibst in deinen eigenen Worten, was du testen möchtest. Der Agent interpretiert deine Absicht und kümmert sich um Erzeugung, Ausführung und Stabilisierung.

Beispiele für freie Prompts

– „@Test schreibe Unit-Tests für meine zentrale Geschäftslogik“ – „@Test Klasse Foo“ – „@Test die Logik zum Parsen der Anfragen“ – „@Test schreibe Tests für meine aktuellen Änderungen“ – „@Test #git_changes“ – „@Test repariere meine fehlschlagenden Tests“ – „@Test Klasse Bar, ziele auf 80 % Codeabdeckung“ – „@Test nutze xUnit und FluentAssertions für die Tests“ Wenn du präzise eingrenzen willst, bleibt die strukturierte Syntax erhalten: – „@Test #“ – kann Member, Klasse, Datei, Projekt, Solution oder Git-Diff sein Freies Prompten macht Unittests mit Copilot für Dotnet alltagstauglich. Du beschreibst dein Ziel kurz und klar, der Agent setzt es um und dokumentiert, was er getan hat. So passt sich das Werkzeug deinen Gewohnheiten an, nicht umgekehrt.

Neue Einstiegspunkte in Visual Studio

GitHub Copilot testing for .NET ist schnell zu finden und direkt nutzbar. Neben dem Start im Copilot Chat mit @Test gibt es nun Einstiegspunkte an vertrauten Stellen in der IDE. So fühlst du dich sofort zu Hause.

Rechtsklick im Editor

– Rechtsklick → Copilot Actions → Generate Tests – Der Scope wird aus deiner Cursor-Position abgeleitet, ähnlich wie bei anderen Copilot Actions (zum Beispiel Member, Klasse oder Datei) – Der Befehl startet die dedizierte Testing-Erfahrung für C#-Projekte und setzt den @Test-Kontext automatisch

Copilot-Chat-Icebreaker

– Wählst du die vorgeschlagene Eingabe zum Schreiben von Unit-Tests, startet der Test-Agent, wenn dein Editorfokus auf C# steht – Der Prompt ist mit @Test vorbelegt und standardmäßig auf das aktive Dokument begrenzt Damit bringst du Unittests mit Copilot für Dotnet direkt aus dem Editor oder dem Chat ins Rollen. Du musst nicht nach Funktionen suchen oder dich durch Menüs klicken. Ein paar gewohnte Wege reichen aus.

Schritt für Schritt starten

Für den Einstieg brauchst du: – Visual Studio 18.3 – C#-Code – eine bezahlte GitHub-Copilot-Lizenz So legst du los:

1. Öffne dein C#-Projekt oder deine Solution in Visual Studio 18.3 und sorge dafür, dass der Build ohne Fehler läuft. Das vereinfacht den Prozess.
2. Starte einen neuen Copilot-Chat und beginne deinen Prompt mit @Test. Nutze natürliche Sprache oder die strukturierte Syntax, um deinen Auftrag zu definieren.
3. Sende die Anfrage. GitHub Copilot testing for .NET startet nun den iterativen Ablauf. Falls noch kein Testprojekt existiert, legt Copilot eines an. Danach erzeugt Copilot Tests, baut sie und führt sie automatisch aus.
4. Öffne den Test Explorer, falls er nicht erscheint: Test → Test Explorer. Du siehst dort die Ergebnisse, während Tests entstehen und laufen.
5. Nach Abschluss zeigt Copilot im Chat eine Zusammenfassung mit allen Änderungen, Abdeckungswerten, Pass/Fail-Signalen und Links zu den Dateien.

Mit diesem Ablauf kommst du schnell zu aussagekräftigen Tests. Du kannst die erzeugten Dateien sofort prüfen, Namen, Asserts oder Testdaten anpassen und erneut ausführen. So entsteht in kurzer Zeit ein tragfähiges Testfundament.

Warum dieser Ansatz Tempo bringt

Die Stärke des Agents liegt in der Kombination aus Kontextwissen und Automatisierung. Er kennt deine Lösung, dein Framework und deinen Build-Prozess. Damit spart er die Reibung, die sonst beim Wechsel zwischen Editor, Test-Runner und Build-Tool entsteht. Außerdem schließt der Agent typische Lücken: – fehlende Testprojekte werden bei Bedarf angelegt – Tests werden nicht nur generiert, sondern direkt kompiliert und ausgeführt – Fehlschläge lösen einen Reparaturversuch aus – die Zusammenfassung macht die Wirkung des Laufs nachvollziehbar So fällt es leichter, nach dem ersten Wurf gezielt nachzuarbeiten. Statt „alles selbst verkabeln“ bekommst du direkt Feedback, wo etwas klemmt. Unittests mit Copilot für Dotnet führen dich damit schrittweise zu stabilen Tests, ohne dass du den IDE-Kontext verlässt.

Kontrolle behalten durch klare Eingaben

Die freie Eingabe eröffnet viele Möglichkeiten, ohne an Flexibilität zu verlieren. Du kannst: – Code allgemein oder gezielt referenzieren – den aktuellen Git-Stand zur Grundlage machen – fehlschlagende Tests reparieren lassen – eine Zielabdeckung vorgeben – Test-Frameworks und Stilmittel nennen, zum Beispiel xUnit und FluentAssertions Wer mehr Steuerung mag, nutzt die strukturierte Syntax mit @Test #. Sie passt gut, wenn der Umfang präzise sein soll, etwa „nur diese Klasse“ oder „nur der aktuelle Diff“. So hältst du die Generierung schlank und fokussiert.

Transparenz über Abdeckung und Stabilität

Die Zusammenfassung nach der Generierung ist mehr als ein Protokoll. Sie zeigt, was der Lauf gebracht hat: – Welche Dateien und Projekte sind neu oder geändert? – Wie hat sich die Abdeckung bewegt? – Welche Tests sind instabil oder fehlgeschlagen? – Wo gibt es Hinweise, dass Teile schwer testbar sind? Diese Signale helfen, technische Schulden sichtbar zu machen. Du erkennst schnell, wo Entkopplung, bessere Schnittstellen oder mehr Beobachtbarkeit lohnen. Gleichzeitig kommst du durch die direkten Links sofort zu den relevanten Stellen im Code.

Praktische Tipps für den Alltag

Diese Hinweise fassen erprobte Schritte aus der GA-Version zusammen: – Wähle einen sinnvollen Scope. Starte bei kritischen Klassen oder dem aktuellen Diff, bevor du die ganze Solution nimmst. – Nenne dein bevorzugtes Test-Framework und wichtige Bibliotheken gleich im Prompt. – Lege bei Bedarf eine Zielabdeckung fest. So bekommst du eine klare Zielmarke. – Nutze die Reparaturrunde, wenn Tests scheitern. Der Agent versucht, typische Fehler selbst zu beheben. – Prüfe die erzeugten Tests. Passe Namen, Randfälle und Assertions an deinen Stil an. – Halte den Build fehlerfrei, bevor du startest. Das beschleunigt die Runde spürbar. – Öffne den Test Explorer und beobachte die Ergebnisse live. Das macht Fortschritt sichtbar. Diese Tipps sind direkt aus der Funktionsweise ableitbar. Sie helfen dir, die Geschwindigkeit des Agents mit deiner Expertise zu verbinden.

Blick nach vorn: Größere Umfänge planen

Die allgemeine Verfügbarkeit ist ein wichtiger Schritt, aber nicht das Ende. Das Team untersucht weitere Verbesserungen, vor allem für große und komplexe Aufträge. Ein Schwerpunkt ist eine Planungsphase vor der Generierung. Dabei könnten Absicht, Annahmen und ein Vorschlag zuerst abgestimmt werden, bevor die Tests entstehen. Ziel ist mehr Kontrolle bei großem Umfang und speziellen Anforderungen. Parallel sammelt das Team laufend Feedback aus Nutzerstudien, um die Arbeit mit wachsenden Codebasen noch besser zu stützen. Wenn du die Funktion nutzt, kannst du Rückmeldungen geben. In Visual Studio gibt es den Button „Give Feedback“. Es gibt außerdem eine Umfrage, über die du deine Erfahrungen teilen kannst. Je mehr Praxiswissen zurückfließt, desto besser passt die Funktion zu typischen Entwicklungsalltagen.

Was du konkret gewinnst

Zusammengefasst liefert die GA-Version klare Vorteile: – kürzere Wege von der Implementierung zum Test – weniger Kontextwechsel dank tiefer IDE-Integration – flexible Steuerung durch natürliches Prompten und strukturierte Scopes – automatische Ausführung samt Reparaturrunden – klare Zusammenfassungen mit Abdeckung, Stabilität und Links Das Ergebnis ist mehr Sicherheit im Code, ohne die Entwicklung auszubremsen. Du arbeitest weiter in Visual Studio, gibst deinen Auftrag an den Agenten, prüfst die Resultate und iterierst dort, wo es nötig ist. Wer heute in Visual Studio 18.3 arbeitet und eine GitHub-Copilot-Lizenz hat, kann direkt loslegen. Öffne dein Projekt, beginne mit @Test und wähle deinen Scope. Lass Copilot die erste Runde fahren, prüfe die generierten Dateien und passe die wichtigen Stellen an. So entsteht in kurzer Zeit eine solide Testbasis. Die Erfahrung zeigt: Wenn die ersten Hürden aus dem Weg sind, steigt die Testabdeckung schnell. Gleichzeitig bleiben Stil und Konventionen deiner Teams erhalten, denn du kannst sie im Prompt vorgeben und die erzeugten Tests sofort nachschärfen. Der Agent unterstützt dich, aber du führst. Genau das macht den Ansatz praxistauglich. Mit Blick nach vorn ist spannend, wie eine mögliche Planungsphase große Scopes noch steuerbarer macht. Bis dahin lohnt es sich, mit gezielten Ausschnitten zu beginnen: kritische Klassen, riskante Änderungen, komplexe Parser oder zentrale Businesslogik. So wächst das Netz aus Tests planvoll und messbar. Wer im Alltag Geschwindigkeit und Verlässlichkeit verbinden will, findet hier eine starke Ergänzung. Unittests mit Copilot für Dotnet bieten einen klaren Weg, die Qualität deiner C#-Projekte zu heben und dabei im gewohnten Rhythmus zu bleiben.

(Source: https://devblogs.microsoft.com/dotnet/github-copilot-testing-for-dotnet-available-in-visual-studio/)

For more news: Click Here

FAQ

Q: Was ist Unittests mit Copilot für Dotnet und wozu dient es? A: Unittests mit Copilot für Dotnet ist eine auf Unit-Tests spezialisierte Funktion in Visual Studio 18.3, die Tests automatisch erzeugt, baut und ausführt. Der Agent erkennt Fehlschläge, versucht sie zu reparieren und liefert eine strukturierte Zusammenfassung mit Abdeckungs- und Pass/Fail-Informationen. Q: Wie kann ich Unittests mit Copilot für Dotnet in Visual Studio starten? A: Für den Einstieg benötigst du Visual Studio 18.3, C#-Code und eine bezahlte GitHub Copilot-Lizenz. Öffne dein Projekt, starte einen Copilot-Chat und beginne den Prompt mit @Test oder nutze die neuen Einstiegspunkte; Copilot legt bei Bedarf ein Testprojekt an und generiert, baut und führt die Tests automatisch aus. Q: Welche Scopes unterstützt Unittests mit Copilot für Dotnet bei der Testgenerierung? A: Unittests mit Copilot für Dotnet kann Tests für einzelne Member, Klassen, Dateien, Projekte, komplette Solutions oder den aktuellen Git-Diff erzeugen. Der Agent nutzt den gewählten Scope, um zu entscheiden, wie Tests organisiert und innerhalb von Visual Studio ausgeführt werden, und berücksichtigt dabei Projektkonfiguration und Test-Framework. Q: Welche Prompt-Optionen gibt es für Unittests mit Copilot für Dotnet? A: Bei Unittests mit Copilot für Dotnet startest du den Agenten im Copilot Chat mit @Test und kannst freie, natürliche Sprache verwenden oder die strukturierte Syntax @Test # für präzise Scopes. Damit lassen sich Anweisungen wie das Reparieren fehlschlagender Tests, das Anvisieren bestimmter Klassen oder das Setzen einer Zielabdeckung formulieren. Q: Welche Einstiegspunkte in Visual Studio bietet Unittests mit Copilot für Dotnet? A: Unittests mit Copilot für Dotnet ist über Copilot Chat, Rechtsklick → Copilot Actions → Generate Tests und die Copilot-Chat-Icebreaker schnell erreichbar. Der Scope wird automatisch aus der Cursor-Position oder dem aktiven Dokument abgeleitet und der @Test-Kontext entsprechend vorbefüllt. Q: Welche Informationen liefert die Zusammenfassung nach der Testgenerierung mit Unittests mit Copilot für Dotnet? A: Nach der Generierung zeigt Unittests mit Copilot für Dotnet eine strukturierte Übersicht mit neuen oder geänderten Testdateien und Testprojekten sowie Vorher‑/Nachher-Abdeckungswerten und Pass/Fail-Signalen. Zusätzlich werden instabile Fälle, Hinweise auf Testbarkeitlücken und direkte Links zu den erzeugten Tests angezeigt, damit du sofort prüfen und iterieren kannst. Q: Wie beschleunigt Unittests mit Copilot für Dotnet den Testworkflow praktisch? A: Unittests mit Copilot für Dotnet reduziert Kontextwechsel, weil Tests direkt in der IDE erzeugt, kompiliert und ausgeführt werden, statt manuell zwischen Editor, Build-Tool und Test-Runner zu wechseln. Automatische Reparaturrunden und das Anlegen fehlender Testprojekte sorgen für schnellere Feedback-Zyklen und eine lauffähige Grundlage für weiteres Testing. Q: Welche praktischen Tipps gibt es für den täglichen Einsatz von Unittests mit Copilot für Dotnet? A: Wähle einen sinnvollen Scope, nenne dein bevorzugtes Test-Framework und halte den Build fehlerfrei, bevor du startest, um die Runden zu beschleunigen. Prüfe die erzeugten Tests im Test Explorer, passe Namen und Assertions an und nutze die Reparaturrunden, um schnell ein stabiles Testfundament zu schaffen.