Claude Code .NET: C#-Projekte mit KI-Unterstützung entwickeln

Das .NET-Ökosystem ist eines der ausgereiftesten in der Softwareentwicklung — und gleichzeitig eines, das von KI-Unterstützung besonders profitiert. Nicht weil C# schwer zu lernen wäre, sondern weil die Menge an Boilerplate-Code enorm ist: Controller, DTOs, Repository-Klassen, Migrations, Unit-Tests — vieles davon ist strukturiert, vorhersehbar, und genau das, was Claude Code am besten kann.

Dieser Artikel zeigt, wie du Claude Code .NET konkret einsetzt: vom Verständnis der Grundkonzepte bis zu den Prompts, die in der Praxis funktionieren.

1. .NET und C# — ein schneller Überblick

.NET ist Microsofts plattformübergreifende Runtime für C#, F# und Visual Basic. Seit .NET Core (heute einfach ".NET") läuft der Code auf Windows, Linux und macOS — ein entscheidender Schritt weg vom Windows-only-Ökosystem der früheren .NET-Framework-Ära.

Die wichtigsten Komponenten im Überblick:

• CLR (Common Language Runtime): Die Laufzeitumgebung, die C#-Code kompiliert und ausführt. Verantwortlich für Garbage Collection, JIT-Kompilierung und Typsicherheit.
• dotnet CLI: Das Kommandozeilen-Werkzeug für alles — Projekte anlegen, bauen, testen, veröffentlichen: dotnet new webapi, dotnet run, dotnet test.
• NuGet: Der Paketmanager des .NET-Ökosystems, vergleichbar mit npm oder pip.

2. ASP.NET Core: Minimal APIs und Controller

ASP.NET Core ist das Web-Framework von .NET. Es unterstützt zwei Haupt-Patterns für HTTP-Endpunkte: Minimal APIs (kompakt, direkt) und Controller (strukturiert, für größere Projekte).

Minimal APIs

Minimal APIs wurden mit .NET 6 eingeführt und ermöglichen es, HTTP-Endpunkte ohne Controller-Klassen direkt in Program.cs zu definieren:

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddDbContext<AppDbContext>(opt =>
    opt.UseSqlite("Data Source=app.db"));

var app = builder.Build();

app.MapGet("/products", async (AppDbContext db) =>
    await db.Products.ToListAsync());

app.MapPost("/products", async (Product product, AppDbContext db) => {
    db.Products.Add(product);
    await db.SaveChangesAsync();
    return Results.Created($"/products/{product.Id}", product);
});

app.Run();

Claude Code generiert diese Endpunkte zuverlässig, inklusive korrekter Dependency Injection, HTTP-Statuscodes und async/await. Ein einfacher Prompt reicht:

claude "Erstelle Minimal API Endpunkte für CRUD-Operationen auf einem Product-Model
mit Id, Name, Price und CategoryId. Dependency Injection via AppDbContext."

Controller und Dependency Injection

Für größere Projekte bieten Controller eine klarere Struktur. Das Dependency Injection (DI)-System von ASP.NET Core ist tief integriert — Dienste werden im DI-Container registriert und per Konstruktor injiziert:

[ApiController]
[Route("api/[controller]")]
public class ProductsController : ControllerBase
{
    private readonly IProductService _productService;

    public ProductsController(IProductService productService)
    {
        _productService = productService;
    }

    [HttpGet]
    public async Task<ActionResult<IEnumerable<ProductDto>>> GetAll()
        => Ok(await _productService.GetAllAsync());

    [HttpPost]
    public async Task<ActionResult<ProductDto>> Create(CreateProductRequest request)
    {
        var product = await _productService.CreateAsync(request);
        return CreatedAtAction(nameof(GetById), new { id = product.Id }, product);
    }
}

Claude Code versteht dieses Pattern vollständig: Es generiert nicht nur den Controller, sondern auf Wunsch auch das zugehörige Interface, die Service-Implementierung und die DI-Registrierung in Program.cs.

3. Entity Framework Core: DbContext, Migrations, LINQ

Entity Framework Core ist das ORM (Object-Relational Mapper) von .NET. Es übersetzt zwischen C#-Objekten und Datenbankzeilen — und ist ein Bereich, in dem Claude Code besonders nützlich ist, weil EF-Code oft repetitiv ist.

DbContext und Modelle

public class AppDbContext : DbContext
{
    public AppDbContext(DbContextOptions<AppDbContext> options) : base(options) { }

    public DbSet<Product> Products => Set<Product>();
    public DbSet<Category> Categories => Set<Category>();

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Product>()
            .HasOne(p => p.Category)
            .WithMany(c => c.Products)
            .HasForeignKey(p => p.CategoryId);
    }
}

Migrations

Migrations halten das Datenbankschema synchron mit dem C#-Modell. Der typische Workflow:

dotnet ef migrations add AddProductTable
dotnet ef database update

Claude Code kann bestehende Migrations erklären, auf Probleme hinweisen und bei komplexeren Schemaänderungen die richtige Migrations-Strategie empfehlen — zum Beispiel ob eine AddColumn-Migration mit einem Default-Wert sicher für Produktionsdaten ist.

LINQ-Abfragen

LINQ (Language Integrated Query) ist eines der mächtigsten Features von C#. Es ermöglicht typsichere Datenbankabfragen direkt in C#:

var topProducts = await db.Products
    .Where(p => p.IsActive && p.Price > 10)
    .OrderByDescending(p => p.SalesCount)
    .Take(10)
    .Select(p => new ProductDto(p.Id, p.Name, p.Price))
    .ToListAsync();

Claude Code erklärt LINQ-Abfragen auf Anfrage auf Deutsch, optimiert bestehende Queries und kann das generierte SQL ausgeben lassen — nützlich, um N+1-Probleme oder fehlende Indizes zu identifizieren.

4. Modernes C#: async/await, Records, Pattern Matching

C# hat sich in den letzten Jahren stark weiterentwickelt. Die wichtigsten modernen Features:

async/await

Asynchrone Programmierung ist in .NET allgegenwärtig. Das async/await-Pattern macht asynchronen Code lesbar wie synchronen — birgt aber Fallen:

// Richtig: vollständig async
public async Task<Product?> GetByIdAsync(int id)
    => await _db.Products.FindAsync(id);

// Gefahr: .Result oder .Wait() blockieren den Thread-Pool
// und können zu Deadlocks führen
var product = _db.Products.FindAsync(id).Result; // NICHT so!

Records und Nullable Reference Types

Records sind immutable Datenklassen mit automatischem Equals, GetHashCode und ToString — ideal für DTOs:

public record ProductDto(int Id, string Name, decimal Price);

public record CreateProductRequest(
    string Name,
    decimal Price,
    int CategoryId);

Nullable Reference Types (aktiviert in modernen .NET-Projekten) machen den Compiler zum Verbündeten: Er warnt, wenn ein potenziell-null-Wert ohne Prüfung verwendet wird. Claude Code generiert Code der diese Annotationen korrekt berücksichtigt.

Pattern Matching

var message = result switch
{
    { IsSuccess: true } => $"Produkt {result.Value.Name} erstellt",
    { Error: var e } when e.Code == "DUPLICATE" => "Produkt existiert bereits",
    _ => "Unbekannter Fehler"
};

5. Testing: xUnit und Moq

Das Standard-Test-Setup für .NET-Projekte: xUnit als Test-Framework, Moq für Mocking.

public class ProductServiceTests
{
    private readonly Mock<IProductRepository> _repoMock = new();
    private readonly ProductService _sut;

    public ProductServiceTests()
    {
        _sut = new ProductService(_repoMock.Object);
    }

    [Fact]
    public async Task CreateAsync_WithValidRequest_ReturnsProduct()
    {
        // Arrange
        var request = new CreateProductRequest("Widget", 9.99m, 1);
        _repoMock.Setup(r => r.AddAsync(It.IsAny<Product>()))
                 .ReturnsAsync(new Product { Id = 1, Name = "Widget" });

        // Act
        var result = await _sut.CreateAsync(request);

        // Assert
        Assert.Equal("Widget", result.Name);
        _repoMock.Verify(r => r.AddAsync(It.IsAny<Product>()), Times.Once);
    }
}

Claude Code generiert Tests dieser Art auf Anfrage vollständig — inklusive Arrange/Act/Assert-Struktur, korrekten Mocks und sinnvollen Assertions. Wichtig: Den zu testenden Code zuerst mitgeben, damit Claude Code den echten Kontrakt versteht, nicht einen angenommenen.

6. Claude Code .NET: Tipps für den Alltag

Die folgenden Anwendungsfälle funktionieren in der Praxis besonders gut:

Controller und Endpunkte generieren

claude "Erstelle einen vollständigen ASP.NET Core Controller für das Order-Model
in Models/Order.cs. Mit GET all, GET by ID, POST, PUT und DELETE.
Dependency Injection via IOrderService. Inkl. korrekten HTTP-Statuscodes
und CreatedAtAction für POST."

EF-Migrations erklären und prüfen

claude "Erkläre was diese Migration macht und ob sie für eine Produktionsdatenbank
mit bestehenden Daten sicher ist:" < Migrations/20260911_AddUserRoles.cs

LINQ-Abfragen optimieren

claude "Diese LINQ-Abfrage ist langsam. Zeige mir das generierte SQL,
erkläre warum es langsam ist, und schlage eine optimierte Version vor."

async-Deadlocks debuggen

Einer der häufigsten .NET-Bugs: Ein .Result oder .Wait() blockiert den Thread-Pool und erzeugt einen Deadlock. Das Symptom ist ein hängender Request ohne Fehlermeldung. Claude Code findet diese Muster zuverlässig:

claude "Meine API hängt bei bestimmten Requests ohne Timeout-Fehler.
Suche nach Deadlock-Mustern (blockierende .Result/.Wait()-Aufrufe)
in den Controller- und Service-Dateien."

Claude Code liest alle relevanten Dateien, identifiziert die problematischen Stellen und zeigt die korrekte async-Alternative.

Dependency Injection richtig konfigurieren

claude "Registriere alle Services in meinem Services/-Verzeichnis
korrekt im DI-Container. Entscheide selbst ob Singleton, Scoped
oder Transient angemessen ist und begründe die Wahl."

Claude Code liest die Service-Klassen, erkennt ob sie zustandsbehaftet sind oder externe Verbindungen halten, und wählt den richtigen Lifetime-Scope — mit Begründung.

Zwei verwandte Artikel die auf diesem Thema aufbauen:

• Claude Code Debugging — Stack Traces übergeben, Root-Cause finden, Logs analysieren
• Claude Code für Unternehmen — Deployment, Zugriffskontrolle und Team-Workflows