Verwenden Sie Protokollierung und DI in minimalen APIs in ASP.NET Core 6

 C Programming >> C-Programmierung >  >> Tags >> API
Verwenden Sie Protokollierung und DI in minimalen APIs in ASP.NET Core 6

ASP.NET Core 6 führt ein vereinfachtes Hostingmodell ein, das zum Implementieren einfacher APIs mit minimalen Abhängigkeiten verwendet werden kann. Diese minimalen APIs reduzieren den Boilerplate-Code, den Sie schreiben müssen, um Ihre ASP.NET Core 6-Anwendungen zum Laufen zu bringen, erheblich.

Wir haben in einem früheren Artikel besprochen, wie Sie mit minimalen APIs beginnen können. In diesem Artikel werden wir fortgeschrittenere Aspekte minimaler APIs untersuchen, einschließlich der Implementierung der Protokollierung, des Lesens aus dem Konfigurationssystem und der Verwendung von Dependency Injection.

Um mit den in diesem Artikel bereitgestellten Codebeispielen arbeiten zu können, sollte Visual Studio 2022 auf Ihrem System installiert sein. Wenn Sie noch keine Kopie haben, können Sie Visual Studio 2022 hier herunterladen.

Erstellen Sie ein minimales ASP.NET Core-Web-API-Projekt in Visual Studio 2022

Lassen Sie uns zunächst ein ASP.NET Core-Projekt in Visual Studio 2022 erstellen. Wenn Sie diesen Schritten folgen, wird ein neues ASP.NET Core-Web-API-6-Projekt in Visual Studio 2022 erstellt:

  1. Starten Sie die Visual Studio 2022-IDE.
  2. Klicken Sie auf „Neues Projekt erstellen.“
  3. Wählen Sie im Fenster „Neues Projekt erstellen“ „ASP.NET Core Web API“ aus der Liste der angezeigten Vorlagen aus.
  4. Klicken Sie auf "Weiter".
  5. Geben Sie im Fenster „Neues Projekt konfigurieren“ den Namen und den Speicherort für das neue Projekt an.
  6. Aktivieren Sie optional das Kontrollkästchen „Lösung und Projekt im gleichen Verzeichnis ablegen“, je nach Ihren Einstellungen.
  7. Klicken Sie auf "Weiter".
  8. Deaktivieren Sie im nächsten Fenster „Zusätzliche Informationen“ das Kontrollkästchen „Controller verwenden…“, da wir in diesem Beispiel minimale APIs verwenden werden. Belassen Sie den „Authentifizierungstyp“ auf „Keine“ (Standard).
  9. Stellen Sie sicher, dass die Kontrollkästchen „Docker aktivieren“, „Für HTTPS konfigurieren“ und „Open API-Unterstützung aktivieren“ deaktiviert sind, da wir hier keine dieser Funktionen verwenden werden.
  10. Klicken Sie auf Erstellen.

Dadurch wird ein neues ASP.NET Core 6-Web-API-Projekt in Visual Studio 2022 erstellt. Wir verwenden dieses Projekt, um in den folgenden Abschnitten dieses Artikels mit einer minimalen API zu arbeiten.

Führen Sie eine minimale Web-API aus

Sie können Ihre minimale API mit nur wenigen Codezeilen zum Laufen bringen:

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();
app.MapGet("/", () => "This is an example of a minimal API");
app.Run();

Konfigurieren Sie mehrere Ports für eine minimale Web-API

Das folgende Code-Snippet veranschaulicht, wie Sie Ihre minimale API so konfigurieren können, dass sie auf einem bestimmten Port ausgeführt wird.

var app = WebApplication.Create(args);
app.MapGet("/", () => "Hello World!");
app.Run("http://localhost:5178");

Wenn Sie die Anwendung ausführen und zu dieser URL navigieren, sollte die Meldung „Hello World!“ angezeigt werden. Meldung, die in Ihrem Webbrowser angezeigt wird.

Sie können mehrere Ports verwenden, indem Sie die URLs wie im folgenden Codeausschnitt gezeigt hinzufügen.

app.Urls.Add("http://localhost:5178");
app.Urls.Add("http://localhost:5179");

Wenn Sie in diesem Fall zu einem dieser Endpunkte navigieren, wird dasselbe „Hello World!“ angezeigt. Nachricht wird angezeigt.

Sie können den Port sogar aus der Umgebung auslesen, wie im folgenden Code-Snippet gezeigt.

var app = WebApplication.Create(args);
var port = Environment.GetEnvironmentVariable("PORT") ?? "5155";
app.MapGet("/", () => "Hello World!");
app.Run($"http://localhost:{port}");

Verwenden Sie die Protokollierung in einer minimalen Web-API

Sie können die Protokollierung auch in Ihren minimalen APIs verwenden. So können Sie mit Serilog Daten auf der Konsole protokollieren:

var logger = new LoggerConfiguration()
    .WriteTo.Console()
    .CreateLogger();

Sie können Serilog auch zum Erstellen von Protokollen verwenden, die Anwendungsneustarts beibehalten. Serilog unterstützt die Protokollierung in einer Datenbank, Datei, Cloud-Speicher und anderen Zielen. Das folgende Code-Snippet veranschaulicht, wie Sie Serilog in minimalen APIs verwenden können.

var builder = WebApplication.CreateBuilder(args);
Log.Logger = new LoggerConfiguration()
    .MinimumLevel.Debug()
    .WriteTo.File("logs.txt", rollingInterval: RollingInterval.Day)
    .CreateLogger();

Das folgende Code-Snippet zeigt, wie Sie die Protokollierung in Ihrer minimalen API verwenden können.

app.MapGet("/", (ILoggerFactory loggerFactory) => {
    var logger = loggerFactory.CreateLogger("Start");
    logger.LogInformation("Starting...");
    return "Logging at work!";
});

Aus dem Konfigurationssystem in einer minimalen API lesen

Sie können auch aus dem Konfigurationssystem in Ihrer minimalen API lesen. Das folgende Code-Snippet zeigt, wie dies erreicht werden kann.

var app = WebApplication.Create(args);
var message = app.Configuration["TextMessage"] ?? "This is a default message.";
app.MapGet("/", () => message);
app.Run();

Verwenden Sie Dependency Injection in einer minimalen Web-API

Wenn Sie eine HttpClient-Instanz verwenden möchten, um eine Verbindung zu einer Remote-Ressource herzustellen, können Sie Abhängigkeitsinjektion verwenden, wie im folgenden Code-Snippet gezeigt.

app.MapGet("/", (IHttpClientFactory httpClientFactory) => "Inside HttpGet method");

Denken Sie daran, HttpClient mit dem folgenden Code zum Container hinzuzufügen.

builder.Services.AddHttpClient();

Sie können auch die Abhängigkeitsinjektion in einer HttpPost-Methode nutzen. Das folgende Code-Snippet zeigt, wie Sie eine Instanz von IHttpClientFactory als Parameter an Ihre HttpPost-Methode übergeben können.

app.MapPost("/", (IHttpClientFactory httpClientFactory) =>
{
    var client = httpClientFactory.CreateClient();
    return Results.Ok();
});

Injizieren Sie eine benutzerdefinierte Klasse in eine minimale Web-API

Sie können auch eine Instanz einer benutzerdefinierten Klasse in Ihre minimale API einfügen. Lassen Sie uns zur Veranschaulichung zwei Typen implementieren:die IAuthorRepository-Schnittstelle und die AuthorRepository-Klasse. Wir verwenden diese Typen, um die Abhängigkeitsinjektion in unserer minimalen API zu implementieren.

Erstellen Sie eine neue Datei namens IAuthorRepository.cs und fügen Sie den folgenden Code ein:

    public interface IAuthorRepository
    {
        public List<Author> GetAuthors();
        public Author GetAuthor(int id);
    }

Die AuthorRepository-Klasse implementiert die IAuthorRepository-Schnittstelle wie unten gezeigt.

 public class AuthorRepository: IAuthorRepository
    {
        private readonly List<Author> _authors;
        public AuthorRepository()
        {
            _authors = new List<Author>
            {
                new Author
                {
                    Id = 1,
                    FirstName = "Joydip",
                    LastName = "Kanjilal"
                },
                new Author
                {
                    Id = 2,
                    FirstName = "Steve",
                    LastName = "Smith"
                },
                new Author
                {
                    Id = 3,
                    FirstName = "Julie",
                    LastName = "Lerman"
                },
                new Author
                {
                    Id = 4,
                    FirstName = "Simon",
                    LastName = "Bisson"
                }
            };
        }
        public List<Author> GetAuthors()
        {
            return _authors;
        }
        public Author GetAuthor(int id)
        {
            return _authors.Find(x=> x.Id == id);
        }
    }

Injizieren Sie eine benutzerdefinierte Schnittstelle in eine minimale Web-API

Das folgende Code-Snippet veranschaulicht, wie Sie eine Instanz der IAuthorRepository-Schnittstelle einfügen können.

app.MapGet("api/author/{id:int}", async (IAuthorRepository authorRepository, HttpContext httpContext) =>
{
    var id = int.Parse((string)httpContext.Request.RouteValues["id"]);
    var author = authorRepository.GetAuthor(id);
    if (author == null)
    {
        return Results.NotFound();
    }
    return Results.Ok(author);
});

Schließlich enthält .NET 6 eine großartige neue Funktion, globale Using-Direktiven. Um globale Usings zu nutzen, erstellen Sie eine neue Datei namens Usings.cs und verschieben Sie alle Ihre using-Anweisungen dorthin. Sie können diese Funktion mit Ihrem ASP.NET Core 6 oder minimalen APIs verwenden.

Ich werde in einem zukünftigen Beitrag hier mehr über minimale APIs (wie das Arbeiten mit Sicherheit und Middleware) zu sagen haben.