Kurs · Schulung · Workshop
Clean Code mit C#
Zwei Tage hands-on mit C# und .NET: Namen schärfen, SOLID auf eine bestehende Anwendung anwenden, Geschäftsregeln test-first entwickeln und APIs mit Validierung und Integrationstests bauen.
In vielen .NET-Projekten hängt die Fachlogik in Service-Klassen, die mit jedem Feature wachsen: Eine Methode validiert, rechnet, speichert und verschickt Mails, Tests gibt es wenige, und jede Änderung braucht Mut. Dieser Kurs zeigt C#-Teams, wie sie solchen Code in kleinen, abgesicherten Schritten verbessern und neuen Code von Beginn an sauber aufbauen. Die Teilnehmenden beginnen bei Namen, Kommentaren und den Grundprinzipien DRY, KISS, Single Level of Abstraction und dem Integration Operation Segregation Principle. Danach wenden sie die fünf SOLID-Prinzipien an Übungen und an den Services einer bestehenden Anwendung für Arztpraxen an. Im zweiten Teil bauen sie Module dieser Anwendung als Modular Monolith neu: Domain Model, Geschäftsregeln als eigene Klassen mit Unit Tests in xUnit, Endpoints mit FluentValidation und Integrationstests gegen PostgreSQL mit Testcontainers. Analyzer, Nullable Reference Types und eine .editorconfig halten die vereinbarten Regeln im Build fest. Der Kurs gehört zur Clean-Code-Familie von letsboot mit einem gemeinsamen Massstab: Code, den das Team lesen, gefahrlos ändern und testen kann. Für Teams mit mehreren Sprachen gibt es Clean Code Hands-On, für Java Clean Code mit Java, für das Frontend Clean Code mit TypeScript. Am Ende haben die Teilnehmenden eine refaktorierte Anwendung und zwei getestete Module, die sie als Vorlage für eigene Projekte nutzen.
Stimmen unserer Teilnehmer:innen






Diese Kunden haben Kurse im gleichen Themen-Cluster bei uns gebucht.Mehr Kunden →
Inhalt
Der Kurs richtet sich an C#-Teams, die .NET-Anwendungen warten und weiterentwickeln. Durch beide Tage zieht sich eine Beispielanwendung für Arztpraxen, die zuerst refaktoriert und dann in Modulen neu aufgebaut wird.
Der Kurs besteht aus den folgenden Themen und kann je nach Publikum angepasst werden.
Clean Code im .NET-Alltag
- Warum Code öfter gelesen als geschrieben wird und was das kostet
- Clean Code im Zeitalter von AI: was mit generiertem Code wichtiger wird
- Pragmatismus: wie viel Qualität an welcher Stelle sinnvoll ist
- Stilfragen wie var per .editorconfig entscheiden
- Hands-On: gute und problematische Stellen im eigenen Code sammeln und einordnen
Effective Naming und Kommentare
- Namen für Variablen, Methoden und Klassen, die die Absicht tragen
- Kommentare für Absicht, Warnungen und öffentliche Verträge (XML Docs)
- Veraltete und überflüssige Kommentare erkennen
- Hands-On: schlecht benannten C#-Code mit den Rename-Refactorings der IDE verbessern
Grundprinzipien
- DRY und der Preis der falschen Abstraktion
- KISS, YAGNI und Composition over Inheritance
- Integration Operation Segregation Principle (IOSP)
- Single Level of Abstraction und Separation of Concerns
- Hands-On: duplizierte Rabattlogik zusammenführen und einen OrderService nach IOSP zerlegen
SOLID in C#
- Single Responsibility am Beispiel eines UserService
- Open-Closed mit Strategy am Beispiel eines DiscountCalculator
- Liskov Substitution an Vererbungshierarchien
- Interface Segregation und Dependency Inversion mit dem DI-Container
- Hands-On: je eine Verletzung der fünf Prinzipien beheben
Bestehenden Code refaktorieren
- Code Smells in gewachsenen Service-Klassen erkennen
- Unit Tests als Sicherheitsnetz vor dem Umbau
- Kleine Schritte mit den automatisierten Refactorings von Rider und Visual Studio
- Pfadfinderregel und Root Cause Analysis
- Hands-On: Billing-, Invoice- und Benachrichtigungs-Services der Praxis-Anwendung refaktorieren
Unit Testing und Test-Driven Development
- Aufbau eines Tests: Arrange, Act, Assert und sprechende Testnamen
- TDD in Mikroiterationen: Test, minimale Implementierung, Refactoring
- xUnit mit Shouldly, Testdaten mit Bogus, Zeit steuern mit TimeProvider
- Stubs und Mocks unterscheiden
- Hands-On: Geschäftsregeln wie «nur Erwachsene» und «keine Registrierung am Wochenende» test-first entwickeln
Domain Model und Geschäftsregeln
- Rich und Anemic Domain Model
- Geschäftsregeln als eigene Klassen
- Tell, Don’t Ask und Law of Demeter
- Hands-On: Domain Model für Registrierung und Terminplanung mit den Methoden Register, Discharge, Schedule und Cancel bauen
Saubere APIs
- Ein Endpoint pro Use Case mit Minimal APIs
- Request-Validierung mit FluentValidation
- Einheitliche Fehlerantworten mit einem globalen Exception Handler
- Integrationstests gegen PostgreSQL mit Testcontainers
- Hands-On: Endpoints mit Validierung, Unit Tests und Integrationstests umsetzen
Modularisierung
- Modular Monolith: Module Patient Registration und Appointment Scheduling
- Öffentliche Schnittstellen eines Moduls über ein Contracts-Projekt
- Von Ordnern zu eigenen Projekten pro Modul
- Clean Architecture und Vertical Slices einordnen
- Hands-On: zwei Module trennen und über eine öffentliche Schnittstelle verbinden
Qualität im Build absichern
- .NET-Analyzer, Warnings as Errors und Nullable Reference Types
- .editorconfig und Directory.Build.props für die ganze Solution
- Zentrale Paketverwaltung mit Directory.Packages.props
- Statische Analyse und Continuous Integration einordnen
- Hands-On: Build-Regeln für eine Solution scharf schalten und Verstösse beheben
Am Ende haben die Teilnehmenden eine refaktorierte Anwendung und zwei getestete Module mit Domain Model, Validierung und Integrationstests, die als Vorlage für eigene Projekte dienen. Arbeitet euer Team in mehreren Sprachen? Dann passt Clean Code Hands-On. Für TypeScript im Frontend gibt es Clean Code mit TypeScript, für Java Clean Code mit Java.
Der effektive Kursinhalt kann, abhängig von Trainer, Durchführung, Dauer und Konstellation der Teilnehmer:innen, von obigen Angaben abweichen.
In-House Kurs anfragen
Öffentlichen Termin anfragen
Kein passender öffentlicher Termin dabei? Trag dich unverbindlich ein – sobald genug Interesse besteht, planen wir einen neuen öffentlichen Termin und informieren dich zuerst.
Mehr über Clean Code mit C#
Clean Code in C# verbindet die Prinzipien aus dem Buch von Robert C. Martin (2008, zweite Auflage 2025) mit den Mitteln von Sprache und Plattform. Records, Pattern Matching und Nullable Reference Types unterstützen unveränderliche Daten und ausdrucksstarken Code, die .NET-Analyzer prüfen Konventionen im Build. Im deutschsprachigen Raum ist zudem die Initiative Clean Code Developer mit ihren Graden, Prinzipien und Praktiken verbreitet.
Weitere Ressourcen:
Verwandte Kurse
- Clean Code Hands-On: sprachneutral, für Teams mit mehreren Sprachen
- Clean Code mit TypeScript: das Typsystem als Werkzeug für sauberen Code
- Clean Code mit Java: dieselben Prinzipien für Java-Teams
- Clean Architecture mit Spring Boot: Use Cases, Ports und Module für Java-Anwendungen
