PricingLoginStart free
C# Academy · Lektion

Ruttgrupper, parametrar och validering

Organisera endpoints med MapGroup, bind parametrar från rutter, frågor och request body samt validera med data annotations.

Lektion 2 av 413 steg

Ruttgrupper, parametrar och validering är en gratis lektion i C# Academy på CoddyKit. Detta är lektion 2 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för C# Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i C# Academy innehåller totalt 4 lektioner.

Routgrupper för organisering

MapGroup() (introducerades i .NET 7) gör det möjligt att gruppera relaterade endpoints under ett gemensamt prefix och tillämpa gemensam konfiguration – middleware, autentiseringspolicyer och taggar – utan att upprepa den för varje endpoint.

Skapa en routgrupp

Anropa app.MapGroup("/api/products") och mappa sedan endpoints på den returnerade gruppen. Prefixet läggs automatiskt till framför alla routes.

var products = app.MapGroup("/api/products").WithTags("Products");

products.MapGet("/",     GetAll);
products.MapGet("/{id}", GetById);
products.MapPost("/",    Create);
products.MapPut("/{id}", Update);
products.MapDelete("/{id}", Delete);
// Routes: /api/products, /api/products/{id}

Tillämpa autentisering på en grupp

Använd RequireAuthorization() på gruppen för att skydda alla endpoints på en gång. Enskilda endpoints kan fortfarande åsidosätta detta med AllowAnonymous().

var adminGroup = app.MapGroup("/admin")
    .RequireAuthorization("AdminPolicy")
    .WithTags("Admin");

adminGroup.MapGet("/users",    GetAllUsers);
adminGroup.MapDelete("/users/{id}", DeleteUser);

// This one inside the group opts out
adminGroup.MapGet("/status", () => "OK").AllowAnonymous();

Begränsningar för routparametrar

Begränsa routparametrar med typmönster. Routern avvisar automatiskt requests som inte matchar och returnerar 404.

// Only matches numeric IDs
app.MapGet("/products/{id:int}", (int id) => id);

// GUID constraint
app.MapGet("/orders/{orderId:guid}", (Guid orderId) => orderId);

// Length constraint
app.MapGet("/codes/{code:length(6)}", (string code) => code);

// Min value
app.MapGet("/page/{page:min(1)}", (int page) => page);

Bindning från olika källor

Parametrar binds från olika källor med hjälp av attribut. Som standard hämtas enkla typer från route/query och komplexa typer från body.

app.MapPost("/search", (
    [FromQuery] string q,
    [FromQuery] int page,
    [FromHeader(Name = "X-Api-Version")] string version,
    [FromBody] SearchFilters filters,
    AppDbContext db) =>
{
    // q and page from query string
    // version from request header
    // filters from JSON body
    return Results.Ok();
});

Anpassad parameterbindning med TryParse

För anpassade typer som används som route- eller query-parametrar implementerar ni en statisk TryParse-metod. Ramverket anropar den automatiskt för att tolka strängvärdet.

public record ProductFilter(string? Category, decimal? MinPrice)
{
    public static bool TryParse(string value, out ProductFilter result)
    {
        var parts = value.Split(':');
        result = new ProductFilter(
            parts.Length > 0 ? parts[0] : null,
            parts.Length > 1 && decimal.TryParse(parts[1], out var p) ? p : null);
        return true;
    }
}

// Usage: GET /products?filter=Electronics:50
app.MapGet("/products", ([FromQuery] ProductFilter filter) => filter);

Validering med data annotations

Dekorera request-DTO:er med attribut för data annotations. I Minimal APIs används gränssnittet IValidatableObject eller ett valideringsfilter för att utlösa validering.

using System.ComponentModel.DataAnnotations;

record CreateProductRequest
{
    [Required, MaxLength(200)]
    public string Name { get; init; } = "";

    [Range(0.01, 999999)]
    public decimal Price { get; init; }

    [Range(0, int.MaxValue)]
    public int Stock { get; init; }
}

Endpoint-filter för validering

Endpoint-filter körs före eller efter hanteraren. Använd dem för att lägga till modellvalidering och avvisa ogiltiga requests innan de når affärslogiken.

app.MapPost("/products", CreateProduct)
   .AddEndpointFilter(async (ctx, next) =>
   {
       var req = ctx.GetArgument<CreateProductRequest>(0);
       var errors = new List<ValidationResult>();
       if (!Validator.TryValidateObject(req,
               new ValidationContext(req), errors, true))
       {
           return Results.ValidationProblem(
               errors.ToDictionary(e => e.MemberNames.First(),
                                   e => new[] { e.ErrorMessage! }));
       }
       return await next(ctx);
   });

Integration med FluentValidation

För komplexa valideringsregler används FluentValidation tillsammans med paketet SharpGrip.FluentValidation.AutoValidation.Endpoints för automatisk validering i Minimal APIs.

public class CreateProductValidator : AbstractValidator<CreateProductRequest>
{
    public CreateProductValidator()
    {
        RuleFor(x => x.Name).NotEmpty().MaximumLength(200);
        RuleFor(x => x.Price).GreaterThan(0);
        RuleFor(x => x.Stock).GreaterThanOrEqualTo(0);
    }
}

builder.Services.AddFluentValidationAutoValidation();
builder.Services.AddValidatorsFromAssemblyContaining<CreateProductValidator>();

Kapslade routgrupper

Routgrupper kan kapslas för att modellera hierarkiska resurser, till exempel orders som innehåller orderrader.

var api = app.MapGroup("/api").RequireAuthorization();

var orders = api.MapGroup("/orders");
orders.MapGet("/", GetAllOrders);
orders.MapGet("/{id:int}", GetOrder);

// Nested: /api/orders/{orderId}/lines
var lines = orders.MapGroup("/{orderId:int}/lines");
lines.MapGet("/",        GetOrderLines);
lines.MapPost("/",       AddOrderLine);
lines.MapDelete("/{id}", RemoveOrderLine);

I praktiken: Versionsindelad API-grupp

Gruppera endpoints efter API-version för att stödja parallella versioner utan att duplicera konfiguration av autentisering eller taggar.

var v1 = app.MapGroup("/api/v1")
    .RequireAuthorization()
    .WithTags("v1");

var v2 = app.MapGroup("/api/v2")
    .RequireAuthorization()
    .WithTags("v2");

v1.MapGet("/products", GetProductsV1);
v2.MapGet("/products", GetProductsV2); // richer response

Snabb kontroll

Vad är syftet med MapGroup() i Minimal APIs?

Besvara frågan i den interaktiva lektionen

Sammanfattning: Routgrupper, parametrar och validering

Viktiga punkter:

  • MapGroup(): delar prefix och konfiguration mellan flera endpoints
  • Routbegränsningar (:int, :guid, :min) avvisar automatiskt routes som inte matchar
  • [FromQuery], [FromHeader], [FromBody] anger bindningskällan uttryckligen
  • Implementera TryParse på anpassade typer för automatisk route-/query-bindning
  • Endpoint-filter möjliggör tvärgående funktioner som validering
Gratis att börja

Lär dig C# med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser
93
Lektioner
346
Börja lära dig gratisVisa hela kursen

Vanliga frågor

Är lektionen ”Ruttgrupper, parametrar och validering” gratis?

Ja – hela texten till ”Ruttgrupper, parametrar och validering” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i C# Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i C# Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Ruttgrupper, parametrar och validering”?

Organisera endpoints med MapGroup, bind parametrar från rutter, frågor och request body samt validera med data annotations. Ni övar på C# Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig C# Academy?

Du behöver inga förkunskaper. Utbildningen i C# Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 2 av 4.

Hur lång tid tar lektionen ”Ruttgrupper, parametrar och validering”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här C# Academy-lektionen?

Ja. Varje C# Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

  1. Skapa ditt första Minimal API
  2. Ruttgrupper, parametrar och validering
  3. Middleware och filter i Minimal APIs
  4. OpenAPI, versionshantering och distribution
← Tillbaka till C# Academy