0Pricing
C# Academy · Leçon

Créer votre première API Minimal

Initialisez un projet d’API Minimal, définissez des gestionnaires de routes et renvoyez des résultats typés avec un minimum de code superflu.

Créer votre première API Minimal est une leçon C# Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C# Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C# Academy comprend 4 leçons au total.

Que sont les API minimales ?

Les API minimales, introduites dans .NET 6, vous permettent de créer des points de terminaison HTTP avec un minimum de code préparatoire : aucun contrôleur ni attribut d'action, seulement des gestionnaires de routes définis directement dans Program.cs. Elles sont idéales pour les microservices et les API légères.

L'API minimale la plus simple

Une API HTTP complète en seulement quelques lignes. Les méthodes MapGet, MapPost, MapPut et MapDelete définissent les gestionnaires de routes pour chaque verbe HTTP.

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.MapGet("/", () => "Hello, Minimal API!");
app.MapGet("/ping", () => Results.Ok(new { status = "pong" }));

app.Run();
// That's it — no Startup.cs, no controllers

Résultats typés pour des réponses HTTP appropriées

Utilisez Results ou TypedResults pour obtenir les bons codes d'état HTTP et les bons types de contenu. TypedResults est préférable pour l'inférence des schémas OpenAPI.

app.MapGet("/products/{id}", async (int id, AppDbContext db) =>
{
    var product = await db.Products.FindAsync(id);
    return product is null
        ? Results.NotFound()
        : Results.Ok(product);
});

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

Paramètres de route et chaînes de requête

Les paramètres de route sont extraits du chemin de l'URL, les paramètres de chaîne de requête sont automatiquement liés à partir de la requête, et le corps de la requête est désérialisé depuis JSON.

// Route param {id} + query param ?includeDeleted
app.MapGet("/orders/{id}", async (
    int id,
    bool includeDeleted = false,
    AppDbContext db) =>
{
    var query = db.Orders.AsQueryable();
    if (!includeDeleted) query = query.Where(o => !o.IsDeleted);
    var order = await query.FirstOrDefaultAsync(o => o.Id == id);
    return order is null ? Results.NotFound() : Results.Ok(order);
});

Injection de dépendances dans les gestionnaires de routes

Les services enregistrés dans le conteneur DI peuvent être injectés directement comme paramètres des gestionnaires de routes. L'infrastructure les résout automatiquement.

builder.Services.AddScoped<ProductService>();

app.MapGet("/products", async (ProductService svc) =>
{
    var products = await svc.GetAllAsync();
    return Results.Ok(products);
});

app.MapDelete("/products/{id}", async (int id, ProductService svc) =>
{
    var deleted = await svc.DeleteAsync(id);
    return deleted ? Results.NoContent() : Results.NotFound();
});

Liaison du corps de la requête

Les paramètres correspondant à des services enregistrés sont injectés ; tous les autres sont liés au corps de la requête (JSON par défaut). Utilisez explicitement [FromBody] si nécessaire.

record CreateProductRequest(string Name, decimal Price, int Stock);

app.MapPost("/products", async (
    CreateProductRequest req,
    ProductService svc) =>
{
    var product = await svc.CreateAsync(req.Name, req.Price, req.Stock);
    return TypedResults.Created($"/products/{product.Id}", product);
});

Renvoyer différents codes d'état

Results fournit des méthodes fabrique pour toutes les réponses HTTP courantes. Utilisez-les pour créer des API REST sémantiquement correctes.

app.MapPut("/products/{id}", async (int id, Product update, AppDbContext db) =>
{
    var existing = await db.Products.FindAsync(id);
    if (existing is null) return Results.NotFound();

    existing.Name  = update.Name;
    existing.Price = update.Price;
    await db.SaveChangesAsync();
    return Results.Ok(existing);
});

// Other useful Results:
// Results.BadRequest("message")
// Results.Conflict()
// Results.UnprocessableEntity(errors)
// Results.Accepted()

Ajouter des métadonnées avec WithName et WithTags

Ajoutez des métadonnées aux points de terminaison pour améliorer la documentation et le routage. Utilisez WithName, WithTags et WithSummary pour organiser la sortie OpenAPI.

app.MapGet("/products/{id}", GetProduct)
   .WithName("GetProductById")
   .WithTags("Products")
   .WithSummary("Retrieves a product by its ID")
   .Produces<Product>()
   .Produces(404);

static async Task<IResult> GetProduct(int id, AppDbContext db)
{
    var p = await db.Products.FindAsync(id);
    return p is null ? Results.NotFound() : Results.Ok(p);
}

Autorisation dans les API minimales

Appliquez RequireAuthorization() pour protéger les points de terminaison, ou utilisez AllowAnonymous() pour les rendre accessibles sans authentification. Les stratégies fonctionnent comme dans les contrôleurs.

builder.Services.AddAuthentication().AddJwtBearer();
builder.Services.AddAuthorization();

app.UseAuthentication();
app.UseAuthorization();

app.MapGet("/profile", (ClaimsPrincipal user) =>
    Results.Ok(user.Identity!.Name))
   .RequireAuthorization();

app.MapGet("/public", () => "No auth needed")
   .AllowAnonymous();

Organiser avec des méthodes statiques

Pour les API plus importantes, déplacez les gestionnaires de routes vers des méthodes statiques ou des méthodes d’extension afin de garder Program.cs propre et facile à parcourir.

// Extension method groups endpoints by feature
public static class ProductEndpoints
{
    public static void MapProductEndpoints(this WebApplication app)
    {
        app.MapGet("/products",    GetAll);
        app.MapGet("/products/{id}", GetById);
        app.MapPost("/products",   Create);
    }

    private static async Task<IResult> GetAll(AppDbContext db)
        => Results.Ok(await db.Products.AsNoTracking().ToListAsync());

    // ... other handlers
}

// In Program.cs:
app.MapProductEndpoints();

API minimale complète pour créer, lire, modifier et supprimer

Une API minimale complète pour les opérations de création, lecture, mise à jour et suppression d’une ressource Todo — concise, testable et prête pour la production.

app.MapGet("/todos", async (AppDbContext db) =>
    Results.Ok(await db.Todos.AsNoTracking().ToListAsync()));

app.MapGet("/todos/{id}", async (int id, AppDbContext db) =>
{
    var todo = await db.Todos.FindAsync(id);
    return todo is null ? Results.NotFound() : Results.Ok(todo);
});

app.MapPost("/todos", async (Todo todo, AppDbContext db) =>
{
    db.Todos.Add(todo);
    await db.SaveChangesAsync();
    return Results.Created($"/todos/{todo.Id}", todo);
});

app.MapDelete("/todos/{id}", async (int id, AppDbContext db) =>
{
    int n = await db.Todos.Where(t => t.Id == id).ExecuteDeleteAsync();
    return n > 0 ? Results.NoContent() : Results.NotFound();
});

Vérification rapide

Comment un gestionnaire de route d’une API minimale reçoit-il un service DI enregistré ?

Récapitulatif&nbsp;: créer votre première API minimale

Points clés :

  • MapGet/Post/Put/Delete définissent directement les gestionnaires de routes dans Program.cs
  • Utilisez Results / TypedResults pour obtenir les bons codes d’état HTTP
  • Les paramètres de route, de requête, de corps et de DI sont tous liés automatiquement
  • Utilisez RequireAuthorization() et AllowAnonymous() pour l’authentification
  • Organisez les grandes API avec des méthodes d’extension ou des groupes de routes

Questions Fréquemment Posées

La leçon « Créer votre première API Minimal » est-elle gratuite ?

Oui — le texte complet de « Créer votre première API Minimal » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C# Academy, passe à CoddyKit PRO. Le cours C# Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Créer votre première API Minimal » ?

Initialisez un projet d’API Minimal, définissez des gestionnaires de routes et renvoyez des résultats typés avec un minimum de code superflu. Tu pratiques C# Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer C# Academy ?

Aucune expérience préalable n'est requise. C# Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « Créer votre première API Minimal » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon C# Academy ?

Oui. Chaque leçon C# Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Créer votre première API Minimal
  2. Groupes de routes, paramètres et validation
  3. Intergiciels et filtres dans les API Minimal
  4. OpenAPI, versionnement et déploiement
← Retour à C# Academy