Erstellen einer C#-Webanwendung mit ASP.NET Core

Ausführen der Standardanwendung

Tim beginnt damit, die Standardanwendung auszuführen, um zu zeigen, was Entwickler von Haus aus erhalten. Bei der Ausführung erstellt das Projekt die API, lädt die erforderlichen NuGet-Pakete herunter und startet eine Webseite. Diese Ersteinrichtung demonstriert die grundlegende Struktur und die Funktionen der API ohne jegliche Änderungen.

Interaktion mit der API

Die Webseite, die gestartet wird, wird von Swagger unterstützt, das jetzt als OpenAPI bekannt ist. Swagger bietet eine benutzerfreundliche Schnittstelle für die Interaktion mit der API. Sie ermöglicht es sowohl Entwicklern als auch Nicht-Entwicklern, die API-Endpunkte leicht zu verstehen und zu testen. Diese Schnittstelle ist besonders nützlich, um die Funktionsweise der API zu veranschaulichen und für Dokumentationszwecke.

Swagger erforschen

Swagger stellt die verfügbaren Endpunkte in der API vor. In der Standardkonfiguration ist einer der vorkonfigurierten Endpunkte der Endpunkt "Wettervorhersage". Wenn Sie auf diesen Endpunkt klicken und die Funktion "Ausprobieren" verwenden, können die Benutzer den API-Aufruf ausführen und die Antwort sehen. Diese Antwort enthält eine Wettervorhersage im JSON-Format, die zeigt, wie die Daten von der API zurückgegeben werden.

Tim bei 8:32 hebt hervor, dass die rohen JSON-Daten zwar schwierig direkt im Browser zu lesen sind, aber durch das Dokumentations-Overlay von Swagger viel besser verdaulich sind. Die Dokumentation enthält detaillierte Informationen über den Endpunkt, einschließlich der Anfragemethode (GET, POST usw.), der Struktur der zurückgegebenen Daten und aller erforderlichen Parameter.

JSON-Dokumentation und API-Versionierung

Swagger generiert auch eine JSON-Datei, auf die Tim um 9:10 Uhr hinweist und die die API in einem maschinenlesbaren Format dokumentiert. Diese Dokumentation ist für andere Anwendungen, die mit der API interagieren müssen, von entscheidender Bedeutung, da sie die verfügbaren Endpunkte, Datenschemata und erwarteten Antworten beschreibt.

Tim bei 9:29 weist auf die Bedeutung der Versionskontrolle in APIs hin. Das Standard-Setup enthält einen Versionsindikator, der auf das Potenzial für mehrere API-Versionen hinweist. Die Versionskontrolle ist für die Aufrechterhaltung der Abwärtskompatibilität unerlässlich. Wenn Änderungen an der API bestehende Clients stören könnten, können die Entwickler dank mehrerer Versionen neue Funktionen oder Änderungen einführen, ohne die aktuellen Benutzer zu stören.

Zweck von APIs

Tim betont, dass sich die meisten Anwendungen um das Abrufen, Bearbeiten und Anzeigen von Daten drehen. APIs dienen als Vermittler zwischen der Benutzeroberfläche und den zugrunde liegenden Daten und bieten einen sicheren und effizienten Datenzugriff. Diese Zentralisierung ist aus mehreren Gründen wichtig:

1. Sicherheit: APIs bieten eine sichere Möglichkeit, den Datenzugriff zu verwalten. Mobile und clientseitige Anwendungen sollten keine direkte Verbindung zu Datenbanken herstellen, um die Einbettung von Datenbankanmeldeinformationen in den Client-Code zu vermeiden, was ein erhebliches Sicherheitsrisiko darstellt.

2. Abstraktion: APIs abstrahieren die Datenschicht von der Benutzeroberfläche und ermöglichen es verschiedenen Client-Anwendungen (mobile Apps, Web-Apps, Desktop-Apps), mit derselben Datenquelle zu interagieren, ohne die Datenbank oder ihre Anmeldedaten offenzulegen.

Vielseitigkeit in verschiedenen Frameworks

Tim weist darauf hin, dass APIs nicht auf bestimmte Frameworks oder Sprachen beschränkt sind. Auf eine C#-API kann beispielsweise von JavaScript-Frameworks wie Angular, React oder Vue zugegriffen werden, was die plattformübergreifenden Möglichkeiten von APIs verdeutlicht.

1. Überblick über Program.cs

Tim bespricht Program.cs und stellt fest, dass es die Webanwendung erstellt und Dienste wie Dependency Injection für Controller und Swagger (OpenAPI) konfiguriert. Der Code richtet wichtige Dienste ein, bevor die Anwendung erstellt und ausgeführt wird.

using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.
builder.Services.AddControllers();
// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

var app = builder.Build();

// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

app.UseHttpsRedirection();

app.UseAuthorization();

app.MapControllers();

app.Run();

using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.
builder.Services.AddControllers();
// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

var app = builder.Build();

// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

app.UseHttpsRedirection();

app.UseAuthorization();

app.MapControllers();

app.Run();

2. die Konfiguration der Umgebung

Tim erklärt, wie die Umgebungseinstellungen in launchSettings.json konfiguriert werden. Die Standardumgebung ist für lokale Tests auf "Entwicklung" eingestellt, wodurch Swagger aktiviert wird. In der Produktion ist Swagger normalerweise aus Sicherheitsgründen deaktiviert, kann aber durch Entfernen der Entwicklungsprüfung aktiviert werden.

{
  "profiles": {
    "IIS Express": {
      "commandName": "IISExpress",
      "launchBrowser": true,
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      }
    },
    "WebApplication": {
      "commandName": "Project",
      "launchBrowser": true,
      "applicationUrl": "https://localhost:5001;http://localhost:5000",
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      }
    }
  }
}

3. HTTPS-Umleitung und -Controller

Tim weist auf die HTTPS-Umleitung und das Mapping von Controllern hin. Dieses Setup stellt sicher, dass die API-Routen richtig konfiguriert sind. Er bevorzugt die Verwendung des Präfixes "api", um die HTTP-Anfrage- und Antwortrouten zu verdeutlichen, die geändert werden können, um sicherzustellen, dass die API-Pfade eindeutig sind.

4. wettervorhersage-controller

Tim taucht in WeatherForecastController.cs ein und hebt die Routen-Konfiguration hervor. Die Standardroute ist /weatherforecast, die modifiziert werden kann, um ein 'api'-Präfix einzuschließen. Der Controller verwendet HTTP GET zum Abrufen von Daten, die über die angegebene Route abgerufen werden können.

using Microsoft.AspNetCore.Mvc;

[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]
    public IEnumerable<WeatherForecast> Get()
    {
        return Enumerable.Range(1, 5).Select(index => new WeatherForecast
        {
            Date = DateTime.Now.AddDays(index),
            TemperatureC = Random.Shared.Next(-20, 55),
            Summary = Summaries[Random.Shared.Next(Summaries.Length)]
        })
        .ToArray();
    }
}

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

    public int TemperatureC { get; set; }

    public string? Summary { get; set; }
}

using Microsoft.AspNetCore.Mvc;

[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]
    public IEnumerable<WeatherForecast> Get()
    {
        return Enumerable.Range(1, 5).Select(index => new WeatherForecast
        {
            Date = DateTime.Now.AddDays(index),
            TemperatureC = Random.Shared.Next(-20, 55),
            Summary = Summaries[Random.Shared.Next(Summaries.Length)]
        })
        .ToArray();
    }
}

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

    public int TemperatureC { get; set; }

    public string? Summary { get; set; }
}

5. HTTP Verben und Routing

Tim erklärt, wie HTTP-Verben (GET, POST, PUT, DELETE) API-Endpunkte definieren. Bei einer GET-Anfrage ruft der Browser die angegebene Methode im Controller auf. Für andere Verben werden Tools wie Postman zum Testen benötigt.

REST-API

Tim Corey stellt REST (Representational State Transfer) und seine Prinzipien vor:

1. Was ist REST: REST ist ein Architekturstil für die Entwicklung vernetzter Anwendungen. Es basiert auf zustandsloser Kommunikation und verwendet Standard-HTTP-Methoden (GET, POST, PUT, DELETE) zur Durchführung von Operationen.

2. RESTful-Prinzipien: RESTful APIs verwenden URL-Muster, um Ressourcen darzustellen. Zum Beispiel ruft /users alle Benutzer ab, während /users/5 einen bestimmten Benutzer mit der ID 5 abruft.

3. REST-Konformität: Tim merkt an, dass es eine Herausforderung sein kann, eine vollständige REST-Konformität zu erreichen, da REST ursprünglich ein theoretisches Modell war. Die Einhaltung der REST-Prinzipien kann jedoch zu intuitiveren und konsistenteren APIs führen.

Tim betont, dass bei der Gestaltung der APIs zwar die REST-Konformität angestrebt wird, aber auch praktische Erwägungen eine Rolle spielen sollten, um Benutzerfreundlichkeit und Funktionalität zu gewährleisten.

Minimal-API-Anwendung

Corey stellt Minimal APIs vor, einen rationalisierten Ansatz für die API-Entwicklung in ASP.NET Core:

1. Einrichten von Minimal-APIs: Tim zeigt, wie man ein Minimal-API-Projekt erstellt, indem man beim Einrichten des Projekts die Option "Use Controllers" deaktiviert.

2. Vereinfachter Code: Minimale APIs erfordern keine Controller- und Routen-Attribute, sodass Entwickler Endpunkte direkt in Program.cs mithilfe von Methoden wie app.MapGet(), app.MapPost() usw. definieren können.

3. Codebeispiel: Tim liefert ein Codebeispiel, bei dem eine einzige Codezeile einen Endpunkt definiert. Er demonstriert, wie man eine GET-Anfrage mit minimaler Konfiguration auf einen Endpunkt abbildet.

using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.Hosting;

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

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

app.Run();

using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.Hosting;

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

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

app.Run();

Minimale APIs sollen die Entwicklung vereinfachen, insbesondere für kleinere Anwendungen oder Microservices.