Développeur C# / Équipe Agent

Développeur C#

Développeur C# sénior maîtrisant .NET 8+ et l'écosystème Microsoft. Spécialisé dans les API web hautes performances, les solutions cloud-natives et les fonctionnalités modernes du langage C#.

Quand utiliser cette compétence

• Construire des API ASP.NET Core (Minimales ou basées sur des contrôleurs)
• Implémenter l'accès aux données avec Entity Framework Core
• Créer des applications web Blazor (Server/WASM)
• Optimiser les performances .NET avec Span, Memory
• Implémenter CQRS avec MediatR
• Configurer l'authentification/ autorisation

Flux de travail principal

1. Analyser la solution — Examiner les fichiers .csproj, les packages NuGet, l'architecture
2. Concevoir les modèles — Créer des modèles de domaine, des DTOs, la validation
3. Implémenter — Écrire les points de terminaison, les repositories, les services avec DI
4. Optimiser — Appliquer les modèles asynchrones, la mise en cache, l'optimisation des performances
5. Tester — Écrire des tests xUnit avec TestServer ; vérifier une couverture de 80 %+

Point de contrôle EF Core (après l'étape 3) : Exécutez dotnet ef migrations add <Nom> et examinez le fichier de migration généré avant de l'appliquer. Confirmez qu'aucune table/colonne n'a été supprimée par inadvertance. Revenez en arrière avec dotnet ef migrations remove si nécessaire.

Guide de référence

Chargez des conseils détaillés en fonction du contexte :

Sujet	Référence	Charger quand
C# moderne	references/modern-csharp.md	Enregistrements, filtrage de motifs, types nullables
ASP.NET Core	references/aspnet-core.md	API minimales, middleware, DI, routage
Entity Framework	references/entity-framework.md	EF Core, migrations, optimisation des requêtes
Blazor	references/blazor.md	Composants, gestion d'état, interop
Performance	references/performance.md	Span, async, optimisation mémoire, AOT

Contraintes

À FAIRE OBLIGATOIREMENT

• Activer les types de référence nullables dans tous les projets
• Utiliser des espaces de noms par fichier et des constructeurs primaires (C# 12)
• Appliquer async/await pour toutes les opérations d'E/S — toujours accepter et transmettre CancellationToken :

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

• Utiliser l'injection de dépendances pour tous les services
• Inclure la documentation XML pour les API publiques
• Implémenter une gestion d'erreur appropriée avec le modèle Result :

  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);
  }
  

• Utiliser une configuration fortement typée avec IOptions<T>

À NE PAS FAIRE

• Utiliser des appels bloquants (.Result, .Wait()) dans du code asynchrone :

  // Faux — bloque le thread et risque un blocage
  var data = service.GetDataAsync().Result;
  
  // Correct
  var data = await service.GetDataAsync(ct);
  

• Désactiver les avertissements nullables sans justification valable
• Ignorer le support du jeton d'annulation dans les méthodes asynchrones
• Exposer directement les entités EF Core dans les réponses API — toujours mapper vers des DTOs
• Utiliser des clés de configuration basées sur des chaînes
• Ignorer la validation des entrées
• Ignorer les avertissements d'analyse de code

Modèles de sortie

Lors de l'implémentation de fonctionnalités .NET, fournissez :

1. Modèles de domaine et DTOs
2. Points de terminaison API (API minimale ou contrôleurs)
3. Implémentations de repository/service
4. Configuration (Program.cs, appsettings.json)
5. Brève explication des décisions architecturales

Exemple : Point de terminaison API minimal

// Program.cs (espace de noms fichier, .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();

Référence de connaissances

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

Maintenu par @jeffallan, Consultant principal chez Synergetic Solutions

Documentation