Minimális API-k rövid útmutatója

Ez a dokumentum:

• Rövid útmutató a minimális API-khoz.
• Tapasztalt fejlesztőknek készült. Bevezetésként tekintse meg oktatóanyagot: Minimális API létrehozása ASP.NET Core.

A minimális API-k a következőkből állnak:

• WebApplication és WebApplicationBuilder
• Útvonalkezelők

WebApplication

A következő kódot egy ASP.NET Core-sablon hozza létre:

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

app.MapGet("/", () => "Hello World!");

app.Run();

Az előző kód a parancssori dotnet new web vagy a Visual Studio Üres websablonjának kiválasztásával hozható létre.

A következő kód létrehoz egy WebApplication (app) anélkül, hogy explicit módon létrehoz egy WebApplicationBuilder:

var app = WebApplication.Create(args);

app.MapGet("/", () => "Hello World!");

app.Run();

WebApplication.Create inicializálja a WebApplication osztály új példányát előre konfigurált alapértelmezett értékekkel.

Portok használata

Amikor webalkalmazást hoz létre a Visual Studióval vagy dotnet new, létrejön egy Properties/launchSettings.json fájl, amely meghatározza azokat a portokat, amelyekre az alkalmazás válaszol. Az alábbi portbeállítási mintákban az alkalmazás Visual Studióból való futtatása hibaüzenetet ad vissza Unable to connect to web server 'AppName'. A Visual Studio hibát ad vissza, mert a Properties/launchSettings.jsonmegadott portot várja, de az alkalmazás a app.Run("http://localhost:3000")által megadott portot használja. Futtassa a következő portmódosítási mintákat a parancssorból.

Az alábbi szakaszok azt a portot állítják be, amelyekre az alkalmazás válaszol.

var app = WebApplication.Create(args);

app.MapGet("/", () => "Hello World!");

app.Run("http://localhost:3000");

Az előző kódban az alkalmazás reagál a 3000porton.

Több port

Az alábbi kódban az alkalmazás válaszol a port 3000 és 4000.

var app = WebApplication.Create(args);

app.Urls.Add("http://localhost:3000");
app.Urls.Add("http://localhost:4000");

app.MapGet("/", () => "Hello World");

app.Run();

A port beállítása a parancssorból

Az alábbi parancs lehetővé teszi, hogy az alkalmazás a 7777porton fogadjon.

dotnet run --urls="https://localhost:7777"

Ha a Kestrel végpont is konfigurálva van a appsettings.json fájlban, a appsettings.json megadott URL-címet használja a rendszer. További információért lásd: Kestrel végpont konfiguráció

A port beolvasása a környezetből

A következő kód beolvassa a portot a környezetből:

var app = WebApplication.Create(args);

var port = Environment.GetEnvironmentVariable("PORT") ?? "3000";

app.MapGet("/", () => "Hello World");

app.Run($"http://localhost:{port}");

A port környezetből való beállításának elsődleges módja a ASPNETCORE_URLS környezeti változó használata, amely az alábbi szakaszban látható.

Portok beállítása a ASPNETCORE_URLS környezeti változón keresztül

A port beállításához elérhető a ASPNETCORE_URLS környezeti változó:

ASPNETCORE_URLS=http://localhost:3000

ASPNETCORE_URLS több URL-címet is támogat:

ASPNETCORE_URLS=http://localhost:3000;https://localhost:5000

Figyelés az összes felületen

Az alábbi minták azt mutatják be, hogy az összes felületen figyelnek

http://*:3000

var app = WebApplication.Create(args);

app.Urls.Add("http://*:3000");

app.MapGet("/", () => "Hello World");

app.Run();

http://+:3000

var app = WebApplication.Create(args);

app.Urls.Add("http://+:3000");

app.MapGet("/", () => "Hello World");

app.Run();

http://0.0.0.0:3000

var app = WebApplication.Create(args);

app.Urls.Add("http://0.0.0.0:3000");

app.MapGet("/", () => "Hello World");

app.Run();

Hallgatás minden felületen az ASPNETCORE_URLS használatával

Az előző minták használhatják a ASPNETCORE_URLS-t.

ASPNETCORE_URLS=http://*:3000;https://+:5000;http://0.0.0.0:5005

Figyeljen minden interfészen az ASPNETCORE_HTTPS_PORTS használatával

Az előző minták használhatják a ASPNETCORE_HTTPS_PORTS és ASPNETCORE_HTTP_PORTSkódokat.

ASPNETCORE_HTTP_PORTS=3000;5005
ASPNETCORE_HTTPS_PORTS=5000

További információ: Végpontok konfigurálása a ASP.NET Core Kestrel webkiszolgálóhoz

HTTPS beállítása fejlesztési tanúsítvánnyal

var app = WebApplication.Create(args);

app.Urls.Add("https://localhost:3000");

app.MapGet("/", () => "Hello World");

app.Run();

A fejlesztési tanúsítvánnyal kapcsolatos további információkért lásd: Az ASP.NET Core HTTPS fejlesztési tanúsítvány hitelesítése Windows és macOS.

HTTPS megadása egyéni tanúsítvány használatával

Az alábbi szakaszok bemutatják, hogyan adhatja meg az egyéni tanúsítványt a appsettings.json fájllal és konfigurációval.

Adja meg a testreszabott tanúsítványt a appsettings.json jelöléssel

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*",
  "Kestrel": {
    "Certificates": {
      "Default": {
        "Path": "cert.pem",
        "KeyPath": "key.pem"
      }
    }
  }
}

Az egyéni tanúsítvány megadása konfigurációval

var builder = WebApplication.CreateBuilder(args);

// Configure the cert and the key
builder.Configuration["Kestrel:Certificates:Default:Path"] = "cert.pem";
builder.Configuration["Kestrel:Certificates:Default:KeyPath"] = "key.pem";

var app = builder.Build();

app.Urls.Add("https://localhost:3000");

app.MapGet("/", () => "Hello World");

app.Run();

A tanúsítvány API-k használata

using System.Security.Cryptography.X509Certificates;

var builder = WebApplication.CreateBuilder(args);

builder.WebHost.ConfigureKestrel(options =>
{
    options.ConfigureHttpsDefaults(httpsOptions =>
    {
        var certPath = Path.Combine(builder.Environment.ContentRootPath, "cert.pem");
        var keyPath = Path.Combine(builder.Environment.ContentRootPath, "key.pem");

        httpsOptions.ServerCertificate = X509Certificate2.CreateFromPemFile(certPath, 
                                         keyPath);
    });
});

var app = builder.Build();

app.Urls.Add("https://localhost:3000");

app.MapGet("/", () => "Hello World");

app.Run();

A környezet olvasása

var app = WebApplication.Create(args);

if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/oops");
}

app.MapGet("/", () => "Hello World");
app.MapGet("/oops", () => "Oops! An error happened.");

app.Run();

További információ a környezet használatáról: ASP.NET Core futtatókörnyezetek

Configuration

A következő kód a konfigurációs rendszerből olvas be:

var app = WebApplication.Create(args);

var message = app.Configuration["HelloKey"] ?? "Config failed!";

app.MapGet("/", () => message);

app.Run();

További információ: ASP.NET Core konfiguráció

Logging

Az alábbi kód egy üzenetet ír az alkalmazás indítási naplójába:

var app = WebApplication.Create(args);

app.Logger.LogInformation("The app started");

app.MapGet("/", () => "Hello World");

app.Run();

További információ: Naplózás a .NET-ben és a ASP.NET Core-ban

A függőség-injektálás (DI) konténer elérése

Az alábbi kód bemutatja, hogyan kérhet le szolgáltatásokat a DI-tárolóból az alkalmazás indításakor:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddControllers();
builder.Services.AddScoped<SampleService>();

var app = builder.Build();

app.MapControllers();

using (var scope = app.Services.CreateScope())
{
    var sampleService = scope.ServiceProvider.GetRequiredService<SampleService>();
    sampleService.DoSomething();
}

app.Run();

Az alábbi kód bemutatja, hogyan érheti el a kulcsokat a DI-tárolóból a [FromKeyedServices] attribútum használatával:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddKeyedSingleton<ICache, BigCache>("big");
builder.Services.AddKeyedSingleton<ICache, SmallCache>("small");

var app = builder.Build();

app.MapGet("/big", ([FromKeyedServices("big")] ICache bigCache) => bigCache.Get("date"));

app.MapGet("/small", ([FromKeyedServices("small")] ICache smallCache) => smallCache.Get("date"));

app.Run();

public interface ICache
{
    object Get(string key);
}
public class BigCache : ICache
{
    public object Get(string key) => $"Resolving {key} from big cache.";
}

public class SmallCache : ICache
{
    public object Get(string key) => $"Resolving {key} from small cache.";
}

További információ a DI-ről a Függőséginjektálás az ASP.NET Corecímű részben található.

WebApplicationBuilder

Ez a szakasz WebApplicationBuilderhasználatával tartalmaz mintakódot.

A tartalomgyöker, az alkalmazásnév és a környezet módosítása

A következő kód állítja be a tartalom gyökerét, az alkalmazás nevét és a környezetet:

var builder = WebApplication.CreateBuilder(new WebApplicationOptions
{
    Args = args,
    ApplicationName = typeof(Program).Assembly.FullName,
    ContentRootPath = Directory.GetCurrentDirectory(),
    EnvironmentName = Environments.Staging,
    WebRootPath = "customwwwroot"
});

Console.WriteLine($"Application Name: {builder.Environment.ApplicationName}");
Console.WriteLine($"Environment Name: {builder.Environment.EnvironmentName}");
Console.WriteLine($"ContentRoot Path: {builder.Environment.ContentRootPath}");
Console.WriteLine($"WebRootPath: {builder.Environment.WebRootPath}");

var app = builder.Build();

WebApplication.CreateBuilder inicializálja a WebApplicationBuilder osztály új példányát előre konfigurált alapértelmezett beállításokkal.

További információ: ASP.NET Alapvető alapismeretek áttekintése

A tartalomgyöker, az alkalmazás neve és a környezet módosítása környezeti változók vagy parancssor használatával

Az alábbi táblázat a tartalomgyöker, az alkalmazásnév és a környezet módosításához használt környezeti változót és parancssori argumentumot mutatja be:

funkció	Környezet változó	Parancssori argumentum
Alkalmazás neve	ASPNETCORE_APPLICATIONNAME	--applicationName
Környezet neve	ASPNETCORE_ENVIRONMENT	--environment
Tartalomgyökér	ASPNETCORE_CONTENTROOT	--contentRoot

Konfigurációszolgáltatók hozzáadása

Az alábbi minta hozzáadja az INI-konfigurációszolgáltatót:

var builder = WebApplication.CreateBuilder(args);

builder.Configuration.AddIniFile("appsettings.ini");

var app = builder.Build();

Részletes információért lásd: Fájlkonfigurációs szolgáltatók az ASP.NET Core konfigurációjában.

Olvasási konfiguráció

Alapértelmezés szerint a WebApplicationBuilder több forrásból olvassa be a konfigurációt, beleértve a következőket:

• appSettings.json és appSettings.{environment}.json
• Környezeti változók
• A parancssor

A konfigurációs források teljes listáját a Alapértelmezett konfiguráció című részben találja, amely része a konfigurációnak az ASP.NET Coredokumentumban.

Az alábbi kód beolvassa HelloKey konfigurációból, és megjeleníti az értéket a / végponton. Ha a konfiguráció értéke null, a "Hello" messagevan hozzárendelve:

var builder = WebApplication.CreateBuilder(args);

var message = builder.Configuration["HelloKey"] ?? "Hello";

var app = builder.Build();

app.MapGet("/", () => message);

app.Run();

A környezet olvasása

var builder = WebApplication.CreateBuilder(args);

if (builder.Environment.IsDevelopment())
{
    Console.WriteLine($"Running in development.");
}

var app = builder.Build();

app.MapGet("/", () => "Hello World!");

app.Run();

Naplózási szolgáltatók hozzáadása

var builder = WebApplication.CreateBuilder(args);

// Configure JSON logging to the console.
builder.Logging.AddJsonConsole();

var app = builder.Build();

app.MapGet("/", () => "Hello JSON console!");

app.Run();

Szolgáltatások hozzáadása

var builder = WebApplication.CreateBuilder(args);

// Add the memory cache services.
builder.Services.AddMemoryCache();

// Add a custom scoped service.
builder.Services.AddScoped<ITodoRepository, TodoRepository>();
var app = builder.Build();

Az IHostBuilder testreszabása

A IHostBuilder meglévő bővítési metódusok a Gazdagép tulajdonsághasználatával érhetők el.

var builder = WebApplication.CreateBuilder(args);

// Wait 30 seconds for graceful shutdown.
builder.Host.ConfigureHostOptions(o => o.ShutdownTimeout = TimeSpan.FromSeconds(30));

var app = builder.Build();

app.MapGet("/", () => "Hello World!");

app.Run();

Az IWebHostBuilder testreszabása

A IWebHostBuilder bővítménymetelyek a WebApplicationBuilder.WebHost tulajdonság használatával érhetők el.

var builder = WebApplication.CreateBuilder(args);

// Change the HTTP server implemenation to be HTTP.sys based
builder.WebHost.UseHttpSys();

var app = builder.Build();

app.MapGet("/", () => "Hello HTTP.sys");

app.Run();

Webes gyökér módosítása

Alapértelmezés szerint a webes gyökér a wwwroot mappában lévő tartalomgyökerhez képest van. A webes gyökér az, ahol a Statikus fájl köztes szoftver statikus fájlokat keres. A webes gyökér a WebHostOptions, a parancssor vagy a UseWebRoot metódus használatával módosítható:

var builder = WebApplication.CreateBuilder(new WebApplicationOptions
{
    Args = args,
    // Look for static files in webroot
    WebRootPath = "webroot"
});

var app = builder.Build();

app.Run();

Egyéni függőséginjektáló (DI) tároló

Az alábbi példa Autofachasznál:

var builder = WebApplication.CreateBuilder(args);

builder.Host.UseServiceProviderFactory(new AutofacServiceProviderFactory());

// Register services directly with Autofac here. Don't
// call builder.Populate(), that happens in AutofacServiceProviderFactory.
builder.Host.ConfigureContainer<ContainerBuilder>(builder => builder.RegisterModule(new MyApplicationModule()));

var app = builder.Build();

Köztes szoftver hozzáadása

Bármely meglévő ASP.NET Core middleware konfigurálható a WebApplication:

var app = WebApplication.Create(args);

// Setup the file server to serve static files.
app.UseFileServer();

app.MapGet("/", () => "Hello World!");

app.Run();

További információ: ASP.NET Core Middleware

Fejlesztői kivételoldal

WebApplication.CreateBuilder inicializálja a WebApplicationBuilder osztály új példányát előre konfigurált alapértelmezett értékekkel. A fejlesztői kivételoldal engedélyezve van az előre konfigurált alapértelmezett beállításokban. Ha a következő kódot a fejlesztési környezetben futtatja, a / navigálással egy barátságos oldal jelenik meg, ami megmutatja a kivételt.

var builder = WebApplication.CreateBuilder(args);

var app = builder.Build();

app.MapGet("/", () =>
{
    throw new InvalidOperationException("Oops, the '/' route has thrown an exception.");
});

app.Run();

ASP.NET Core Middleware

Az alábbi táblázat felsorolja a minimális API-kban gyakran használt köztes szoftvereket.

Middleware	Description	API
Authentication	Hitelesítési támogatást nyújt.	UseAuthentication
Authorization	Engedélyezési támogatást nyújt.	UseAuthorization
CORS	A forrásközi erőforrásmegosztást konfigurálja.	UseCors
Kivételkezelő	Globálisan kezeli a köztes szoftverfolyamat által kidobott kivételeket.	UseExceptionHandler
Továbbított fejlécek	Továbbítja a proxizott fejléceket az aktuális kérelemre.	UseForwardedHeaders
HTTPS-átirányítás	Átirányítja az összes HTTP-kérést a HTTPS-be.	UseHttpsRedirection
HTTP szigorú átviteli biztonsági (HSTS)	Biztonsági funkciókat javító middleware, amely egy speciális válaszfejlécet ad hozzá.	UseHsts
Kérelemnaplózás	TÁMOGATJA a HTTP-kérések és válaszok naplózását.	UseHttpLogging
Kérelem időtúllépései	Támogatja a kérések időtúllépéseinek konfigurálását, a globális alapértelmezett és végpontonkénti beállításokat.	UseRequestTimeouts
W3C-kérésnaplózás	Támogatja a HTTP-kérések és válaszok naplózását W3C formátumban.	UseW3CLogging
Válasz gyorsítótárazása	Támogatást nyújt a gyorsítótárazási válaszokhoz.	UseResponseCaching
Választömörítés	Támogatja a válaszok tömörítését.	UseResponseCompression
Session	Támogatást nyújt a felhasználói munkamenetek kezeléséhez.	UseSession
Statikus fájlok	Támogatja a statikus fájlok és a címtárböngészés kiszolgálását.	UseStaticFiles, UseFileServer
WebSockets	Engedélyezi a WebSockets protokollt.	UseWebSockets

A következő szakaszok a kérések kezelését ismertetik: útválasztás, paraméterkötés és válaszok.

Routing

A konfigurált WebApplication támogatja Map{Verb} , és MapMethods hol {Verb} van egy teve-eset http metódus, például Get: , Post, Putvagy Delete:

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

app.MapGet("/", () => "This is a GET");
app.MapPost("/", () => "This is a POST");
app.MapPut("/", () => "This is a PUT");
app.MapDelete("/", () => "This is a DELETE");

app.MapMethods("/options-or-head", new[] { "OPTIONS", "HEAD" }, 
                          () => "This is an options or head request ");

app.Run();

A metódusoknak átadott Delegate argumentumokat "útvonalkezelőknek" nevezzük.

Útvonalkezelők

Az útvonalkezelők olyan metódusok, amelyek az útvonal egyezésekor futnak. Az útvonalkezelők lehetnek lambdakifejezések, helyi függvények, példánymetódusok vagy statikus metódusok. Az útvonalkezelők lehetnek szinkronok vagy aszinkronok.

Lambda kifejezés

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

app.MapGet("/inline", () => "This is an inline lambda");

var handler = () => "This is a lambda variable";

app.MapGet("/", handler);

app.Run();

Helyi függvény

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

string LocalFunction() => "This is local function";

app.MapGet("/", LocalFunction);

app.Run();

Példánymetódus

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

var handler = new HelloHandler();

app.MapGet("/", handler.Hello);

app.Run();

class HelloHandler
{
    public string Hello()
    {
        return "Hello Instance method";
    }
}

Statikus metódus

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

app.MapGet("/", HelloHandler.Hello);

app.Run();

class HelloHandler
{
    public static string Hello()
    {
        return "Hello static method";
    }
}

A Program.cs kívül definiált végpont

A minimális API-knak nem kell a(z) Program.cs-ban lennie.

Program.cs

using MinAPISeparateFile;

var builder = WebApplication.CreateSlimBuilder(args);

var app = builder.Build();

TodoEndpoints.Map(app);

app.Run();

TodoEndpoints.cs

namespace MinAPISeparateFile;

public static class TodoEndpoints
{
    public static void Map(WebApplication app)
    {
        app.MapGet("/", async context =>
        {
            // Get all todo items
            await context.Response.WriteAsJsonAsync(new { Message = "All todo items" });
        });

        app.MapGet("/{id}", async context =>
        {
            // Get one todo item
            await context.Response.WriteAsJsonAsync(new { Message = "One todo item" });
        });
    }
}

Lásd még a később ebben a cikkben található Útvonalcsoportok részt.

Elnevezett végpontok és hivatkozás létrehozása

A végpontok nevet adhatnak a végpont URL-címeinek létrehozásához. A névvel ellátott végpontok használatával elkerülhető, hogy az alkalmazásokban ne kelljen kemény kódútvonalakat használni:

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

app.MapGet("/hello", () => "Hello named route")
   .WithName("hi");

app.MapGet("/", (LinkGenerator linker) => 
        $"The link to the hello route is {linker.GetPathByName("hi", values: null)}");

app.Run();

Az előző kód megjeleníti a The link to the hello route is /hello-t a / végpontról.

MEGJEGYZÉS: A végpontok neve megkülönbözteti a kis- és nagybetűket.

Végpontnevek:

• Globálisan egyedinek kell lennie.
• OpenAPI-műveletazonosítóként használatos, ha az OpenAPI-támogatás engedélyezve van. További információ: OpenAPI.

Útvonalparaméterek

Az útvonalparaméterek az útvonalminta definíciójának részeként rögzíthetők:

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

app.MapGet("/users/{userId}/books/{bookId}", 
    (int userId, int bookId) => $"The user id is {userId} and book id is {bookId}");

app.Run();

Az előző kód a The user id is 3 and book id is 7 értéket adja vissza az URI /users/3/books/7-ből.

Az útvonalkezelő deklarálhatja a rögzítendő paramétereket. Amikor egy olyan útvonalra irányuló kérést küld, amelynek a paraméterei rögzítésre vannak deklarálva, a rendszer elemzi és továbbítja a paramétereket a kezelőnek. Ez megkönnyíti az értékek biztonságos típusba rögzítését. Az előző kódban userId és bookId is int.

Az előző kódban, ha bármelyik útvonalértéket nem lehet int-é konvertálni, kivétel keletkezik. A GET kérés /users/hello/books/3 a következő kivételt okozza:

BadHttpRequestException: Failed to bind parameter "int userId" from "hello".

Helyettesítő karakter és az összes útvonal elfogása

A következő átfogó útvonal a "/posts/hello" végpontról Routing to hello-t ad vissza:

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

app.MapGet("/posts/{*rest}", (string rest) => $"Routing to {rest}");

app.Run();

Útvonalkorlátozások

Az útvonalkorlátozások korlátozzák az útvonalak egyező viselkedését.

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

app.MapGet("/todos/{id:int}", (int id) => db.Todos.Find(id));
app.MapGet("/todos/{text}", (string text) => db.Todos.Where(t => t.Text.Contains(text));
app.MapGet("/posts/{slug:regex(^[a-z0-9_-]+$)}", (string slug) => $"Post {slug}");

app.Run();

Az alábbi táblázat az előző útvonalsablonokat és azok viselkedését mutatja be:

Útvonalsablon	Példa egyező URI-ra
/todos/{id:int}	/todos/1
/todos/{text}	/todos/something
/posts/{slug:regex(^[a-z0-9_-]+$)}	/posts/mypost

További információért lásd: Útválasztási korlátozások hivatkozása a Útválasztás ASP.NET Corerészében.

Útvonalcsoportok

A MapGroup bővítménymetódus segít a végpontcsoportok közös előtaggal való rendszerezésében. Csökkenti az ismétlődő kódot, és lehetővé teszi a végpontok teljes csoportjainak testreszabását egyetlen hívással olyan metódusokhoz, mint a RequireAuthorization és WithMetadata, amelyek végpont metaadatait adják hozzá.

A következő kód például két hasonló végpontcsoportot hoz létre:

app.MapGroup("/public/todos")
    .MapTodosApi()
    .WithTags("Public");

app.MapGroup("/private/todos")
    .MapTodosApi()
    .WithTags("Private")
    .AddEndpointFilterFactory(QueryPrivateTodos)
    .RequireAuthorization();


EndpointFilterDelegate QueryPrivateTodos(EndpointFilterFactoryContext factoryContext, EndpointFilterDelegate next)
{
    var dbContextIndex = -1;

    foreach (var argument in factoryContext.MethodInfo.GetParameters())
    {
        if (argument.ParameterType == typeof(TodoDb))
        {
            dbContextIndex = argument.Position;
            break;
        }
    }

    // Skip filter if the method doesn't have a TodoDb parameter.
    if (dbContextIndex < 0)
    {
        return next;
    }

    return async invocationContext =>
    {
        var dbContext = invocationContext.GetArgument<TodoDb>(dbContextIndex);
        dbContext.IsPrivate = true;

        try
        {
            return await next(invocationContext);
        }
        finally
        {
            // This should only be relevant if you're pooling or otherwise reusing the DbContext instance.
            dbContext.IsPrivate = false;
        }
    };
}

public static RouteGroupBuilder MapTodosApi(this RouteGroupBuilder group)
{
    group.MapGet("/", GetAllTodos);
    group.MapGet("/{id}", GetTodo);
    group.MapPost("/", CreateTodo);
    group.MapPut("/{id}", UpdateTodo);
    group.MapDelete("/{id}", DeleteTodo);

    return group;
}

Ebben a forgatókönyvben a Location fejléc relatív címét használhatja a 201 Created eredményben:

public static async Task<Created<Todo>> CreateTodo(Todo todo, TodoDb database)
{
    await database.AddAsync(todo);
    await database.SaveChangesAsync();

    return TypedResults.Created($"{todo.Id}", todo);
}

A végpontok első csoportja csak a /public/todos előtagú kéréseknek felel meg, és hitelesítés nélkül is elérhetők. A végpontok második csoportja csak a /private/todos előtagú kéréseknek felel meg, és hitelesítést igényel.

A QueryPrivateTodosvégpontszűrő-előállító egy helyi függvény, amely módosítja az útvonalkezelő TodoDb paramétereit annak érdekében, hogy lehetővé tegye a privát teendőadatok elérését és tárolását.

Az útvonalcsoportok a beágyazott csoportokat és az összetett előtagmintákat is támogatják útvonalparaméterekkel és korlátozásokkal. Az alábbi példában a user csoporthoz hozzárendelt útvonalkezelő rögzítheti a külső csoport előtagjaiban definiált {org} és {group} útvonalparamétereket.

Az előtag üres is lehet. Ez akkor lehet hasznos, ha végponti metaadatokat vagy szűrőket ad hozzá a végpontok egy csoportjához az útvonalminta módosítása nélkül.

var all = app.MapGroup("").WithOpenApi();
var org = all.MapGroup("{org}");
var user = org.MapGroup("{user}");
user.MapGet("", (string org, string user) => $"{org}/{user}");

A szűrők vagy metaadatok csoporthoz való hozzáadása ugyanúgy viselkedik, mint az egyes végpontokhoz való egyenkénti hozzáadásuk, mielőtt további szűrőket vagy metaadatokat ad hozzá egy belső csoporthoz vagy adott végponthoz.

var outer = app.MapGroup("/outer");
var inner = outer.MapGroup("/inner");

inner.AddEndpointFilter((context, next) =>
{
    app.Logger.LogInformation("/inner group filter");
    return next(context);
});

outer.AddEndpointFilter((context, next) =>
{
    app.Logger.LogInformation("/outer group filter");
    return next(context);
});

inner.MapGet("/", () => "Hi!").AddEndpointFilter((context, next) =>
{
    app.Logger.LogInformation("MapGet filter");
    return next(context);
});

A fenti példában a külső szűrő naplózza a bejövő kérést a belső szűrő előtt annak ellenére, hogy másodikként lett hozzáadva. Mivel a szűrők különböző csoportokra lettek alkalmazva, a egymáshoz viszonyított sorrend nem számít. A rendelésszűrők hozzáadásának sorrendje számít, ha ugyanarra a csoportra vagy egy adott végpontra alkalmazzák.

A /outer/inner/ kérés a következőket naplózza:

/outer group filter
/inner group filter
MapGet filter

Paraméterkötés

A paraméterkötés a kérelemadatok erősen gépelt paraméterekké alakításának folyamata, amelyeket az útvonalkezelők fejeznek ki. A kötési forrás határozza meg, hogy a paraméterek honnan vannak kötve. A kötési források lehetnek explicitek vagy következtethetők a HTTP-módszer és a paramétertípus alapján.

Támogatott kötési források:

• Útvonalértékek
• Lekérdezési karakterlánc
• Header
• Törzs (mint JSON)
• Űrlapértékek
• Függőséginjektálás által biztosított szolgáltatások
• Custom

A következő GET útvonalkezelő az alábbi paraméterkötési források némelyikét használja:

var builder = WebApplication.CreateBuilder(args);

// Added as service
builder.Services.AddSingleton<Service>();

var app = builder.Build();

app.MapGet("/{id}", (int id,
                     int page,
                     [FromHeader(Name = "X-CUSTOM-HEADER")] string customHeader,
                     Service service) => { });

class Service { }

Fő paraméterkötési funkciók

• Explicit kötés: Használjon olyan attribútumokat, mint a [FromRoute], [FromQuery], [FromHeader], [FromBody], , [FromForm]és [FromServices] explicit módon adja meg a kötési forrásokat.
• Űrlapérték-kötés: Űrlapértékek kötése [FromForm] attribútummal, beleértve a fájlfeltöltések támogatását IFormFile és IFormFileCollection.
• Összetett típusok: Gyűjteményekhez és összetett típusokhoz való kötés űrlapokból, lekérdezési sztringekből és fejlécekből.
• Egyéni kötés: Egyéni kötési logika implementálása a , TryParse, vagy a BindAsync felületen.
• Választható paraméterek: Támogatja a null értékű típusokat és az opcionális paraméterek alapértelmezett értékeit.
• Függőséginjektálás: A paraméterek automatikusan kötődnek a DI-tárolóban regisztrált szolgáltatásokhoz.
• Speciális típusok: Automatikus kötés a HttpContext, HttpRequest, HttpResponse, CancellationToken, ClaimsPrincipalés StreamPipeReader.

---

Tudj meg többet: A paraméterkötéssel kapcsolatos részletes információkért, beleértve a speciális forgatókönyveket, az érvényesítést, a kötési elsőbbséget és a hibaelhárítást, tekintse meg a paraméterkötést a Minimal API-alkalmazásokban.

Json+PipeReader deszerializálás minimális API-kban

A .NET 10-től kezdve a ASP.NET Core alábbi funkcionális területei a Stream helyett a PipeReader-alapú túlterheléseket használják JsonSerializer.DeserializeAsync :

• Minimális API-k (paraméterkötés, olvasási kérelem törzse)
• MVC (bemeneti formázók, modell)
• A HttpRequestJsonExtensions kérelem törzsének JSON-ként való olvasására használható bővítménymetelyek.

A legtöbb alkalmazás esetében a Streamről a PipeReaderre való áttérés jobb teljesítményt biztosít anélkül, hogy módosításokat kellene végrehajtania az alkalmazáskódban. Ha azonban az alkalmazás egyéni konverterrel rendelkezik, előfordulhat, hogy a konverter nem megfelelően működik Utf8JsonReader.HasValueSequence . Ha nem, akkor az eredmény hibákhoz vezethet, például ArgumentOutOfRangeException, vagy hiányzó adatokhoz a deszerializáláskor. A konverter pipeReaderrel kapcsolatos hibák nélkül történő működéséhez az alábbi lehetőségek állnak rendelkezésre.

1. lehetőség: Ideiglenes kerülő megoldás

A gyors áthidaló megoldás az, hogy visszatér a Streamhez a PipeReader támogatása nélkül. A beállítás implementálásához állítsa a "Microsoft.AspNetCore.UseStreamBasedJsonParsing" AppContext kapcsolót "true" értékre. Javasoljuk, hogy ezt csak ideiglenes kerülő megoldásként végezze el, és frissítse a konvertert, hogy a lehető leghamarabb támogatást nyújtson HasValueSequence . Előfordulhat, hogy a kapcsoló el lesz távolítva a .NET 11-ben. Az egyetlen célja az volt, hogy időt adjon a fejlesztőknek a konverterek frissítésére.

2. lehetőség: Az implementációk JsonConverter gyors javítása

Ehhez a javításhoz egy tömböt foglal le a ReadOnlySequence. Ez a példa a kód megjelenését mutatja be:

public override T? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
{
    var span = reader.HasValueSequence ? reader.ValueSequence.ToArray() : reader.ValueSpan;
    // previous code
}

3. lehetőség: Bonyolultabb, de jobb teljesítményű javítás

Ez a javítás magában foglalja egy külön kódútvonal beállítását a ReadOnlySequence kezeléshez:

public override T? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
{
    if (reader.HasValueSequence)
    {
        reader.ValueSequence;
        // ReadOnlySequence optimized path
    }
    else
    {
        reader.ValueSpan;
        // ReadOnlySpan optimized path
    }
}

További információkért lásd:

• System.Text.Json.Serialization.JsonConverter
• github.com/dotnet/aspnetcore/pull/62895

Érvényesítési támogatás minimális API-kban

Az érvényesítés engedélyezése lehetővé teszi, hogy a ASP.NET Core-futtatókörnyezet végrehajtsa a következőn definiált érvényesítéseket:

• Query
• Header
• A kérés tartalma

Az érvényesítések a névtér attribútumai DataAnnotations alapján vannak definiálva.

Ha egy minimális API-végpont paramétere osztály- vagy rekordtípus, a rendszer automatikusan érvényesítési attribútumokat alkalmaz. Például:

public record Product(
    [Required] string Name,
    [Range(1, 1000)] int Quantity);

A fejlesztők a következővel szabják testre az érvényesítési rendszer viselkedését:

• Egyéni [Validation] attribútum-implementációk létrehozása.
• Az összetett érvényesítési logika felületének IValidatableObject implementálása.

Ha az ellenőrzés sikertelen, a futtatókörnyezet 400 – Hibás kérés választ ad vissza az érvényesítési hibák részleteivel.

A minimális API-k beépített érvényesítési támogatásának engedélyezése

A Minimal API-k beépített érvényesítési támogatásának engedélyezéséhez hívja meg a AddValidation bővítménymetódust, hogy regisztrálja a szükséges szolgáltatásokat az alkalmazás szolgáltatástárolójában:

builder.Services.AddValidation();

Az implementáció automatikusan felderíti a Minimal API-kezelőkben vagy a Minimal API-kezelőkben definiált alaptípusok típusait. Egy végpontszűrő érvényesítést végez ezeken a típusokon, és minden végponthoz hozzá lesz adva.

Az ellenőrzés letiltható adott végpontok esetében a DisableValidation bővítménymetódus használatával, ahogyan az alábbi példában is látható:

app.MapPost("/products",
    ([EvenNumber(ErrorMessage = "Product ID must be even")] int productId, [Required] string name)
        => TypedResults.Ok(productId))
    .DisableValidation();

Érvényesítési hibaválaszok testreszabása az IProblemDetailsService használatával

Implementációval testre szabhatja a minimális API-érvényesítési logika hibaválaszait IProblemDetailsService . Regisztrálja ezt a szolgáltatást az alkalmazás szolgáltatásgyűjteményében a konzisztens és felhasználóspecifikus hibaválaszok engedélyezéséhez. A minimális API-ellenőrzés támogatása a .NET 10 ASP.NET Core-ban jelent meg.

Egyéni érvényesítési hibaválaszok implementálása:

• Az alapértelmezett implementáció implementálása IProblemDetailsService vagy használata
• A szolgáltatás regisztrálása a DI-tárolóban
• Az érvényesítési rendszer automatikusan a regisztrált szolgáltatást használja az érvényesítési hibaválaszok formázására

Az érvényesítési hibaválaszok az IProblemDetailsService szolgáltatással való testreszabásáról további információt a Válaszok létrehozása minimal API-alkalmazásokban című témakörben talál.

Responses

Az útvonalkezelők a következő típusú visszatérési értékeket támogatják:

1. IResult alapú – Ez magában foglalja a Task<IResult>-et és a ValueTask<IResult>-t
2. string – Ebbe beletartozik Task<string> és ValueTask<string>
3. T (Bármilyen más típus) – Ebbe beletartozik Task<T> és ValueTask<T>

Visszaadott érték	Behavior	Content-Type
IResult	A keretrendszer meghívja IResult.ExecuteAsync	A döntést a IResult végrehajtása hozta meg.
string	A keretrendszer közvetlenül a válaszba írja a sztringet	text/plain
T (bármilyen más típus)	A keretrendszer JSON-szerializálja a választ	application/json

Az útvonalkezelő visszatérési értékeinek részletes útmutatója: Válaszok létrehozása minimális API-alkalmazásokban

Példa visszaadott értékekre

karakterlánc visszaadott értékei

app.MapGet("/hello", () => "Hello World");

JSON visszaadott értékek

app.MapGet("/hello", () => new { Message = "Hello World" });

TypedResults visszatérése

A következő kód egy TypedResultsad vissza:

app.MapGet("/hello", () => TypedResults.Ok(new Message() {  Text = "Hello World!" }));

A TypedResults visszaadása előnyben részesíti a Resultsvisszatérését. További információ: TypedResults vs Results.

IResult visszatérési értékek

app.MapGet("/hello", () => Results.Ok(new { Message = "Hello World" }));

Az alábbi példa a beépített eredménytípusokat használja a válasz testreszabásához:

app.MapGet("/api/todoitems/{id}", async (int id, TodoDb db) =>
         await db.Todos.FindAsync(id) 
         is Todo todo
         ? Results.Ok(todo) 
         : Results.NotFound())
   .Produces<Todo>(StatusCodes.Status200OK)
   .Produces(StatusCodes.Status404NotFound);

JSON

app.MapGet("/hello", () => Results.Json(new { Message = "Hello World" }));

Egyéni állapotkód

app.MapGet("/405", () => Results.StatusCode(405));

Text

app.MapGet("/text", () => Results.Text("This is some text"));

Stream

var proxyClient = new HttpClient();
app.MapGet("/pokemon", async () => 
{
    var stream = await proxyClient.GetStreamAsync("http://contoso/pokedex.json");
    // Proxy the response as JSON
    return Results.Stream(stream, "application/json");
});

További példákért lásd Válaszok létrehozása minimal API-alkalmazásokban.

Redirect

app.MapGet("/old-path", () => Results.Redirect("/new-path"));

File

app.MapGet("/download", () => Results.File("myfile.text"));

Beépített eredmények

A Results és TypedResults statikus osztályokban gyakori eredmény-segítők léteznek. A TypedResults visszaadása előnyben részesíti a Resultsvisszatérését. További információ: TypedResults vs Results.

Fejlécek módosítása

A válaszfejlécek módosításához használja a HttpResponse objektumot:

app.MapGet("/", (HttpContext context) => {
    // Set a custom header
    context.Response.Headers["X-Custom-Header"] = "CustomValue";

    // Set a known header
    context.Response.Headers.CacheControl = $"public,max-age=3600";

    return "Hello World";
});

Eredmények testreszabása

Az alkalmazások egyéni IResult típus implementálásával szabályozhatják a válaszokat. Az alábbi kód egy PÉLDA EGY HTML-eredménytípusra:

using System.Net.Mime;
using System.Text;
static class ResultsExtensions
{
    public static IResult Html(this IResultExtensions resultExtensions, string html)
    {
        ArgumentNullException.ThrowIfNull(resultExtensions);

        return new HtmlResult(html);
    }
}

class HtmlResult : IResult
{
    private readonly string _html;

    public HtmlResult(string html)
    {
        _html = html;
    }

    public Task ExecuteAsync(HttpContext httpContext)
    {
        httpContext.Response.ContentType = MediaTypeNames.Text.Html;
        httpContext.Response.ContentLength = Encoding.UTF8.GetByteCount(_html);
        return httpContext.Response.WriteAsync(_html);
    }
}

Javasoljuk, hogy adjon hozzá egy bővítménymetódust a Microsoft.AspNetCore.Http.IResultExtensions az egyéni eredmények felderíthetőbbé tétele érdekében.

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

app.MapGet("/html", () => Results.Extensions.Html(@$"<!doctype html>
<html>
    <head><title>miniHTML</title></head>
    <body>
        <h1>Hello World</h1>
        <p>The time on the server is {DateTime.Now:O}</p>
    </body>
</html>"));

app.Run();

Beírt eredmények

Az IResult interfész olyan minimális API-kból visszaadott értékeket jelölhet, amelyek nem használják ki a JSON implicit támogatását a visszaadott objektum HTTP-válaszra való szerializálásához. A statikus Eredmények osztály különböző IResult típusú válaszok megjelenítésére szolgál. Például állítsa be a válaszállapot-kódot, vagy átirányítsa egy másik URL-címre.

A IResult implementáló típusok nyilvánosak, így teszteléskor lehetővé teszik a típusok helyességére vonatkozó állításokat. Például:

[TestClass()]
public class WeatherApiTests
{
    [TestMethod()]
    public void MapWeatherApiTest()
    {
        var result = WeatherApi.GetAllWeathers();
        Assert.IsInstanceOfType(result, typeof(Ok<WeatherForecast[]>));
    }      
}

A statikus TypedResults osztály megfelelő metódusainak visszatérési típusait megvizsgálva megtalálhatja azt a megfelelő nyilvános IResult típust, amelyre át lehet alakítani.

További példákért lásd Válaszok létrehozása minimal API-alkalmazásokban.

Filters

További információ: Szűrők a Minimális API-alkalmazásokban.

Authorization

Az útvonalak engedélyezési szabályzatokkal védhetők. Ezek deklarálhatók a [Authorize] attribútummal vagy a RequireAuthorization metódussal:

using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Identity;
using Microsoft.EntityFrameworkCore;
using WebRPauth.Data;

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddAuthorization(o => o.AddPolicy("AdminsOnly", 
                                  b => b.RequireClaim("admin", "true")));

var connectionString = builder.Configuration.GetConnectionString("DefaultConnection");
builder.Services.AddDbContext<ApplicationDbContext>(options =>
    options.UseSqlServer(connectionString));
builder.Services.AddDatabaseDeveloperPageExceptionFilter();

builder.Services.AddDefaultIdentity<IdentityUser>(options => options.SignIn.RequireConfirmedAccount = true)
    .AddEntityFrameworkStores<ApplicationDbContext>();

var app = builder.Build();

app.UseAuthorization();

app.MapGet("/auth", [Authorize] () => "This endpoint requires authorization.");
app.MapGet("/", () => "This endpoint doesn't require authorization.");
app.MapGet("/Identity/Account/Login", () => "Sign in page at this endpoint.");

app.Run();

Az előző kód így is írható RequireAuthorization:

app.MapGet("/auth", () => "This endpoint requires authorization")
   .RequireAuthorization();

Az alábbi minta a házirenden alapuló engedélyezés használatát mutatja be.

using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Identity;
using Microsoft.EntityFrameworkCore;
using WebRPauth.Data;

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddAuthorization(o => o.AddPolicy("AdminsOnly", 
                                  b => b.RequireClaim("admin", "true")));

var connectionString = builder.Configuration.GetConnectionString("DefaultConnection");
builder.Services.AddDbContext<ApplicationDbContext>(options =>
    options.UseSqlServer(connectionString));
builder.Services.AddDatabaseDeveloperPageExceptionFilter();

builder.Services.AddDefaultIdentity<IdentityUser>(options => options.SignIn.RequireConfirmedAccount = true)
    .AddEntityFrameworkStores<ApplicationDbContext>();

var app = builder.Build();

app.UseAuthorization();

app.MapGet("/admin", [Authorize("AdminsOnly")] () => 
                             "The /admin endpoint is for admins only.");

app.MapGet("/admin2", () => "The /admin2 endpoint is for admins only.")
   .RequireAuthorization("AdminsOnly");

app.MapGet("/", () => "This endpoint doesn't require authorization.");
app.MapGet("/Identity/Account/Login", () => "Sign in page at this endpoint.");

app.Run();

Végpont elérésének engedélyezése hitelesítés nélküli felhasználók számára

A [AllowAnonymous] lehetővé teszi, hogy a hitelesítés nélküli felhasználók hozzáférjenek a végpontokhoz:

app.MapGet("/login", [AllowAnonymous] () => "This endpoint is for all roles.");


app.MapGet("/login2", () => "This endpoint also for all roles.")
   .AllowAnonymous();

CORS

Az útvonalak CORS- engedélyezhetők CORS-szabályzatokkal. A CORS deklarálható a [EnableCors] attribútummal vagy a RequireCors metódussal. A következő minták engedélyezik a CORS-t:

const string MyAllowSpecificOrigins = "_myAllowSpecificOrigins";

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddCors(options =>
{
    options.AddPolicy(name: MyAllowSpecificOrigins,
                      builder =>
                      {
                          builder.WithOrigins("http://example.com",
                                              "http://www.contoso.com");
                      });
});

var app = builder.Build();
app.UseCors();

app.MapGet("/",() => "Hello CORS!");

app.Run();

using Microsoft.AspNetCore.Cors;

const string MyAllowSpecificOrigins = "_myAllowSpecificOrigins";

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddCors(options =>
{
    options.AddPolicy(name: MyAllowSpecificOrigins,
                      builder =>
                      {
                          builder.WithOrigins("http://example.com",
                                              "http://www.contoso.com");
                      });
});

var app = builder.Build();
app.UseCors();

app.MapGet("/cors", [EnableCors(MyAllowSpecificOrigins)] () => 
                           "This endpoint allows cross origin requests!");
app.MapGet("/cors2", () => "This endpoint allows cross origin requests!")
                     .RequireCors(MyAllowSpecificOrigins);

app.Run();

További információkért nézze meg: Kereszt-származási kérelmek engedélyezése (CORS) az ASP.NET Core

ValidateScopes és ValidateOnBuild

A ValidateScopes és a ValidateOnBuild alapértelmezés szerint engedélyezve vannak a Fejlesztési környezetben, de más környezetekben le vannak tiltva.

Ha ValidateOnBuildtrue, a DI-tároló ellenőrzi a szolgáltatás konfigurációját a létrehozáskor. Ha a szolgáltatáskonfiguráció érvénytelen, a build az alkalmazás indításakor meghiúsul, nem pedig futásidőben, amikor a szolgáltatást kérik.

Ha ValidateScopestrue, a DI-tároló ellenőrzi, hogy a hatókörrel rendelkező szolgáltatás nincs-e feloldva a gyökérhatókörből. A hatókörrel rendelkező szolgáltatás gyökérhatókörből való feloldása memóriavesztést okozhat, mivel a szolgáltatás a kérés hatókörénél hosszabb ideig marad a memóriában.

A ValidateScopes és a ValidateOnBuild alapértelmezés szerint hamisak a nem fejlesztési módban teljesítménybeli okokból.

Az alábbi kód azt mutatja, hogy a ValidateScopes alapértelmezés szerint engedélyezve van fejlesztési módban, de kiadási módban le van tiltva:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddScoped<MyScopedService>();

var app = builder.Build();

if (app.Environment.IsDevelopment())
{
    Console.WriteLine("Development environment");
}
else
{
    Console.WriteLine("Release environment");
}

app.MapGet("/", context =>
{
    // Intentionally getting service provider from app, not from the request
    // This causes an exception from attempting to resolve a scoped service
    // outside of a scope.
    // Throws System.InvalidOperationException:
    // 'Cannot resolve scoped service 'MyScopedService' from root provider.'
    var service = app.Services.GetRequiredService<MyScopedService>();
    return context.Response.WriteAsync("Service resolved");
});

app.Run();

public class MyScopedService { }

Az alábbi kód azt mutatja, hogy a ValidateOnBuild alapértelmezés szerint engedélyezve van fejlesztési módban, de kiadási módban le van tiltva:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddScoped<MyScopedService>();
builder.Services.AddScoped<AnotherService>();

// System.AggregateException: 'Some services are not able to be constructed (Error
// while validating the service descriptor 'ServiceType: AnotherService Lifetime:
// Scoped ImplementationType: AnotherService': Unable to resolve service for type
// 'BrokenService' while attempting to activate 'AnotherService'.)'
var app = builder.Build();

if (app.Environment.IsDevelopment())
{
    Console.WriteLine("Development environment");
}
else
{
    Console.WriteLine("Release environment");
}

app.MapGet("/", context =>
{
    var service = context.RequestServices.GetRequiredService<MyScopedService>();
    return context.Response.WriteAsync("Service resolved correctly!");
});

app.Run();

public class MyScopedService { }

public class AnotherService
{
    public AnotherService(BrokenService brokenService) { }
}

public class BrokenService { }

Az alábbi kód letiltja a ValidateScopes-t és a ValidateOnBuild-et a Development-ben.

var builder = WebApplication.CreateBuilder(args);

if (builder.Environment.IsDevelopment())
{
    Console.WriteLine("Development environment");
    // Doesn't detect the validation problems because ValidateScopes is false.
    builder.Host.UseDefaultServiceProvider(options =>
    {
        options.ValidateScopes = false;
        options.ValidateOnBuild = false;
    });
}

Lásd még

• minimális API-k rövid útmutatója
• OpenAPI-dokumentumok létrehozása
• Válaszok létrehozása minimális API-alkalmazásokban
• Szűrők minimális API-alkalmazásokban
• ASP.NET Core API-k hibáinak kezelése
• Hitelesítés és engedélyezés minimális API-kban
• Minimális API-alkalmazások tesztelése
• Rövid kapcsolatcsoportos útválasztás
• Identity API-végpontok
• kulcsalapú szolgáltatásfüggőség-injektálási tároló támogatása
• A minimális API-végpontok színfalak mögötti pillantása
• alapvető minimális API-k ASP.NET rendszerezése
• Fluent Validation-megbeszélés a GitHubon