Wie funktioniert die ASP.NET Core 2.1. Middleware Pipeline?

ASP.NET Core verwendet Middleware zur Behandlung von Requests. Jedes Mal, wenn ein Request von ASP.NET behandelt wird, durchläuft dieser eine Middleware, die in einer Middleware Pipeline registriert wurde. Jede dieser Middlewares durchleuchtet den Request, leistet ein Stück Arbeit und entscheidet, ob die Middleware Pipeline weiter durchlaufen werden soll.

Die Middleware Pipeline, kann sich als eine Sequenz von Middlewares vorgestellt werden, wo die Middleware in der angeführten Reihenfolge quasi nach dem First-Come, First-Serve Prinzip abgearbeitet werden. Beispiel: Middleware X und Middleware Y, X hat die Möglichkeit den Request zu bearbeiten, danach tut Y das gleiche und nachdem Y fertig ist, kann X noch etwas extra Arbeit an der Response erledigen.

Die Middleware Pipeline wird in der Startup.cs verwaltet. In der ConfigureServices Methode kann Middleware hinzugefügt werden und in der Configure Methode wird diese konfiguriert. Anbei ein Beispiel:

public void ConfigureServices(IServiceCollection services) 
   services.AddMvc(); 
}

public void Configure(IApplicationBuilder app, IHostingEnvironment env) 
   app.UseStaticFiles(); 
   app.UseMvcWithDefaultRoute(); 
}

StaticFiles und Mvc ist Middleware. Die Middlewares werden in der definierten Reihenfolge abgearbeitet.

Darüber hinaus gibt es eine eingebaute Extension Methode im IApplicationBuilder Interface, die es ermöglicht, direkt in der Configure Methode Middleware einzufügen:

app.Use(async (HttpContext context, Func<Task> next) => 
   Console.WriteLine("Hallo von der Custom Middleware!"); 
   await next.Invoke(); 
});

Die Middleware benötigt zumindest einen Parameter vom Typ RequestDelegate. Der RequestDelegate ist nur eine Definition einer Funktion:

public delegate Task RequestDelegate(HttpContext context);

Dabei handelt es sich also um eine Funktion, die einen HttpContext übergeben bekommt und einen Task zurück gibt und steht als Synonym für die Next Middleware in der Pipeline. Beim Aufruf dieses Delegaten, wird die nächste Middleware in der Pipeline ausgeführt, da alle Middlewares auf diese Art und Weise zusammen hängen.

Außerdem gibt es noch eine Extension Methode für die Run Middleware, diese schließt einen Request immer ab. Danach kann keine weitere Use Middleware eingebaut werden.

app.Run(async (context) => 
 { 
    await context.Response.WriteAsync("Zum Abschluss Happy Coding!"); 
 }); 


Natürlich ist es nicht so ideal die gesamte Middleware in die Startup.cs zu packen, daher bietet es sich an eine eigene Klasse für die Middleware Extensions zu schreiben.

public static class MiddlewareExtensions 
 {
 
    // 1. Run Middleware 
    public static void RunAbschlussMiddleware(this IApplicationBuilder app) 
    { 
        app.Run(async (context) => 
        { 
            await context.Response.WriteAsync("Zum Abschluss Happy Coding!"); 
        }); 
     }
 
    // 2. Use Middleware 
    public static IApplicationBuilder UseHelloDd(this IApplicationBuilder app) 
    { 
         return app.Use(async (context, next) => 
        { 
             await context.Response.WriteAsync("Hallo Custom Middleware!"); 
             await next(); 
        }); 
    } 


Die Middleware aus den Extension Methoden kann dann ganz normal wie jede weitere Middleware in der Startup.cs Configure und ConigureServices Methode verwendet werden.

Dieser Blogbeitrag soll kurz und bündig die Funktionsweise von Middleware in ASP.NET Core 2.1. erläutern. Viel Spaß beim Ausprobieren!!

Kommentare sind geschlossen