Übersicht über APIs

ASP.NET Core bietet zwei Ansätze zum Erstellen von HTTP-APIs: Minimale APIs und controllerbasierte APIs. Für neue Projekte empfehlen wir die Verwendung minimaler APIs , da sie einen vereinfachten, leistungsstarken Ansatz zum Erstellen von APIs mit minimalem Code und minimaler Konfiguration bieten.

Minimale APIs – Empfohlen für neue Projekte

Minimale APIs sind der empfohlene Ansatz zum Erstellen schneller HTTP-APIs mit ASP.NET Core. Sie ermöglichen es Ihnen, voll funktionsfähige REST Endpunkte mit minimalem Code und minimaler Konfiguration zu erstellen. Überspringen Sie herkömmliches Gerüst und vermeiden Sie unnötige Controller, indem Sie API-Routen und -Aktionen fließend deklarieren.

Hier ist ein einfaches Beispiel, das eine API im Stammverzeichnis der Web-App erstellt:

var app = WebApplication.Create(args);

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

app.Run();

Die meisten APIs akzeptieren Parameter als Teil der Route:

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

Minimale APIs unterstützen die Konfiguration und Anpassung, die erforderlich ist, um auf mehrere APIs zu skalieren, komplexe Routen zu verarbeiten, Autorisierungsregeln anzuwenden und den Inhalt der API-Antworten zu steuern.

Erste Schritte mit minimalen APIs

• Lernprogramm: Erstellen einer minimalen API mit ASP.NET Core
• Kurzübersicht: Kurzübersicht über minimale APIs
• Beispiele: Eine vollständige Liste allgemeiner Szenarien mit Codebeispielen finden Sie in der Kurzübersicht zu minimalen APIs

Controllerbasierte APIs – Alternativer Ansatz

ASP.NET Core unterstützt auch einen controllerbasierten Ansatz, bei dem Controller Klassen sind, von ControllerBasedenen abgeleitet wird. Dieser Ansatz folgt herkömmlichen objektorientierten Mustern und kann bevorzugt werden für:

• Große Anwendungen mit komplexer Geschäftslogik
• Teams, die mit dem MVC-Muster vertraut sind
• Anwendungen, die bestimmte MVC-Features erfordern

Hier sehen Sie Beispielcode für eine API, die auf Controllern basiert:

namespace APIWithControllers;

public class Program
{
    public static void Main(string[] args)
    {
        var builder = WebApplication.CreateBuilder(args);

        builder.Services.AddControllers();
        var app = builder.Build();

        app.UseHttpsRedirection();

        app.MapControllers();

        app.Run();
    }
}

using Microsoft.AspNetCore.Mvc;

namespace APIWithControllers.Controllers;
[ApiController]
[Route("[controller]")]
public class WeatherForecastController : ControllerBase
{
    private static readonly string[] Summaries = new[]
    {
        "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching"
    };

    private readonly ILogger<WeatherForecastController> _logger;

    public WeatherForecastController(ILogger<WeatherForecastController> logger)
    {
        _logger = logger;
    }

    [HttpGet(Name = "GetWeatherForecast")]
    public IEnumerable<WeatherForecast> Get()
    {
        return Enumerable.Range(1, 5).Select(index => new WeatherForecast
        {
            Date = DateOnly.FromDateTime(DateTime.Now.AddDays(index)),
            TemperatureC = Random.Shared.Next(-20, 55),
            Summary = Summaries[Random.Shared.Next(Summaries.Length)]
        })
        .ToArray();
    }
}

Der folgende Code bietet die gleiche Funktionalität mithilfe des empfohlenen Minimal-API-Ansatzes:

namespace MinimalAPI;

public class Program
{
    public static void Main(string[] args)
    {
        var builder = WebApplication.CreateBuilder(args);

        var app = builder.Build();

        app.UseHttpsRedirection();

        var summaries = new[]
        {
            "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching"
        };

        app.MapGet("/weatherforecast", (HttpContext httpContext) =>
        {
            var forecast = Enumerable.Range(1, 5).Select(index =>
                new WeatherForecast
                {
                    Date = DateOnly.FromDateTime(DateTime.Now.AddDays(index)),
                    TemperatureC = Random.Shared.Next(-20, 55),
                    Summary = summaries[Random.Shared.Next(summaries.Length)]
                })
                .ToArray();
            return forecast;
        });

        app.Run();
    }
}

Beide API-Projekte verweisen auf die folgende Klasse:

namespace APIWithControllers;

public class WeatherForecast
{
    public DateOnly Date { get; set; }

    public int TemperatureC { get; set; }

    public int TemperatureF => 32 + (int)(TemperatureC / 0.5556);

    public string? Summary { get; set; }
}

Auswählen zwischen Ansätzen

Beginnen Sie mit minimalen APIs für neue Projekte. Sie bieten:

• Einfachere Syntax - Weniger Codebausteine
• Bessere Leistung – Reduzierter Mehraufwand im Vergleich zu Controllern
• Einfachere Tests – Vereinfachte Komponenten- und Integrationstests
• Moderner Ansatz – Nutzt die neuesten .NET-Features

Berücksichtigen Sie bei Bedarf controllerbasierte APIs :

• Modellbindungserweiterung (IModelBinderProvider, IModelBinder)
• Erweiterte Überprüfungsfeatures (IModelValidator)
• Anwendungsteile oder das Anwendungsmodell
• JsonPatch-Unterstützung
• OData-Unterstützung

Die meisten dieser Features können in minimalen APIs mit benutzerdefinierten Lösungen implementiert werden, aber Controller bieten diese sofort verfügbar.

Siehe auch

• Lernprogramm: Erstellen einer minimalen API mit ASP.NET Core – Minimales API-Lernprogramm
• Kurzübersicht zu minimalen APIs – Kurzübersicht zu minimalen APIs
• Erstellen von Web-APIs mit ASP.NET Core – Übersicht über controllerbasierte APIs
• Lernprogramm: Erstellen einer controllerbasierten Web-API mit ASP.NET Core – Lernprogramm für controllerbasierte API