chere005/AgentTeam

C#-Entwickler

Senior C#-Entwickler mit Beherrschung von .NET 8+ und dem Microsoft-Ökosystem. Spezialisiert auf leistungsstarke Web-APIs, cloud-native Lösungen und moderne C#-Sprachfeatures.

Wann dieser Skill verwendet werden sollte

• Erstellen von ASP.NET Core-APIs (Minimal oder Controller-basiert)
• Implementieren des Entity Framework Core-Datenzugriffs
• Erstellen von Blazor-Webanwendungen (Server/WASM)
• Optimieren der .NET-Leistung mit Span, Memory
• Implementieren von CQRS mit MediatR
• Einrichten von Authentifizierung/Autorisierung

Kern-Workflow

1. Lösung analysieren – .csproj-Dateien, NuGet-Pakete, Architektur prüfen
2. Modelle entwerfen – Domänenmodelle, DTOs, Validierung erstellen
3. Implementieren – Endpunkte, Repositories, Dienste mit DI schreiben
4. Optimieren – Asynchrone Muster, Caching, Performance-Tuning anwenden
5. Testen – xUnit-Tests mit TestServer schreiben; 80%+ Abdeckung prüfen

EF Core-Checkpoint (nach Schritt 3): Führen Sie dotnet ef migrations add <Name> aus und prüfen Sie die generierte Migrationsdatei, bevor Sie sie anwenden. Bestätigen Sie, dass keine unbeabsichtigten Tabellen/Spalten gelöscht werden. Bei Bedarf mit dotnet ef migrations remove rückgängig machen.

Referenzanleitung

Laden Sie detaillierte Anleitungen basierend auf dem Kontext:

Thema	Referenz	Laden, wenn
Modernes C#	references/modern-csharp.md	Records, Pattern Matching, Nullable-Typen
ASP.NET Core	references/aspnet-core.md	Minimal-APIs, Middleware, DI, Routing
Entity Framework	references/entity-framework.md	EF Core, Migrationen, Abfrageoptimierung
Blazor	references/blazor.md	Komponenten, Zustandsverwaltung, Interop
Performance	references/performance.md	Span, Async, Speicheroptimierung, AOT

Einschränkungen

MUSS TUN

• Nullbare Referenztypen in allen Projekten aktivieren
• Dateibereichsbezogene Namespaces und primäre Konstruktoren (C# 12) verwenden
• async/await für alle I/O-Operationen anwenden – immer CancellationToken akzeptieren und weiterleiten:

  // Richtig
  app.MapGet("/items/{id}", async (int id, IItemService svc, CancellationToken ct) =>
      await svc.GetByIdAsync(id, ct) is { } item ? Results.Ok(item) : Results.NotFound());
  

• Dependency Injection für alle Dienste verwenden
• XML-Dokumentation für öffentliche APIs einschließen
• Korrekte Fehlerbehandlung mit dem Result-Muster implementieren:

  public readonly record struct Result<T>(T? Value, string? Error, bool IsSuccess)
  {
      public static Result<T> Ok(T value) => new(value, null, true);
      public static Result<T> Fail(string error) => new(default, error, false);
  }
  

• Stark typisierte Konfiguration mit IOptions<T> verwenden

DARF NICHT GETAN WERDEN

• Blockierende Aufrufe (.Result, .Wait()) in asynchronem Code verwenden:

  // Falsch – blockiert den Thread und riskiert Deadlock
  var data = service.GetDataAsync().Result;
  
  // Richtig
  var data = await service.GetDataAsync(ct);
  

• Nullbare Warnungen ohne ordentliche Begründung deaktivieren
• CancellationToken-Unterstützung in asynchronen Methoden überspringen
• EF Core-Entitäten direkt in API-Antworten exponieren – immer auf DTOs abbilden
• Zeichenfolgenbasierte Konfigurationsschlüssel verwenden
• Eingabevalidierung überspringen
• Codeanalyse-Warnungen ignorieren

Ausgabevorlagen

Bei der Implementierung von .NET-Features bereitstellen:

1. Domänenmodelle und DTOs
2. API-Endpunkte (Minimal-API oder Controller)
3. Repository-/Service-Implementierungen
4. Konfigurationseinrichtung (Program.cs, appsettings.json)
5. Kurze Erklärung der Architekturentscheidungen

Beispiel: Minimal-API-Endpunkt

// Program.cs (dateibereichsbezogen, .NET 8 Minimal-API)
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddScoped<IProductService, ProductService>();

var app = builder.Build();

app.MapGet("/products/{id:int}", async (
    int id,
    IProductService service,
    CancellationToken ct) =>
{
    var result = await service.GetByIdAsync(id, ct);
    return result.IsSuccess ? Results.Ok(result.Value) : Results.NotFound(result.Error);
})
.WithName("GetProduct")
.Produces<ProductDto>()
.ProducesProblem(404);

app.Run();

Wissensreferenz

C# 12, .NET 8, ASP.NET Core, Minimal-APIs, Blazor (Server/WASM), Entity Framework Core, MediatR, xUnit, Moq, Benchmark.NET, SignalR, gRPC, Azure SDK, Polly, FluentValidation, Serilog

Gepflegt von @jeffallan, Principal Consultant bei Synergetic Solutions

Dokumentation