asp.net-core
Middleware

Bemerkungen

Verwenden der ExceptionHandler-Middleware zum Senden benutzerdefinierter JSON-Fehler an den Client

Definieren Sie Ihre Klasse, die Ihren benutzerdefinierten Fehler darstellt.

public class ErrorDto
{
   public int Code { get; set; }
   public string Message { get; set; }

   // other fields

   public override string ToString()
   {
      return JsonConvert.SerializeObject(this);
   }
}

Setzen Sie dann die nächste ExceptionHandler- Middleware in die Methode Configure. Beachten Sie, dass die Reihenfolge der Middleware wichtig ist.

app.UseExceptionHandler(errorApp =>
    {
        errorApp.Run(async context =>
        {
            context.Response.StatusCode = 500; // or another Status 
            context.Response.ContentType = "application/json";

            var error = context.Features.Get<IExceptionHandlerFeature>();
            if (error != null)
            {
                var ex = error.Error;

                await context.Response.WriteAsync(new ErrorDto()
                {
                    Code = <your custom code based on Exception Type>,
                    Message = ex.Message // or your custom message
                    
                    ... // other custom data
                }.ToString(), Encoding.UTF8);
            }
        });
    });

Middleware zum Festlegen der Antwort ContentType

Die Idee ist, HttpContext.Response.OnStarting Callback zu verwenden, da dies das letzte Ereignis ist, das ausgelöst wird, bevor die Header gesendet werden. Fügen Sie der Middleware-Methode Invoke Folgendes hinzu.

public async Task Invoke(HttpContext context)
{
    context.Response.OnStarting((state) =>
    {
        if (context.Response.StatusCode == (int)HttpStatusCode.OK)
        {
           if (context.Request.Path.Value.EndsWith(".map"))
           {
             context.Response.ContentType = "application/json";
           }
        }          
        return Task.FromResult(0);
    }, null);

    await nextMiddleware.Invoke(context);
}

Daten durch die Middleware-Kette weiterleiten

Aus der Dokumentation :

Die HttpContext.Items- Auflistung ist der beste Ort zum Speichern von Daten, die nur während der Verarbeitung einer bestimmten Anforderung benötigt werden. Sein Inhalt wird nach jeder Anforderung verworfen. Es wird am besten als Mittel zur Kommunikation zwischen Komponenten oder Middleware verwendet, die zu verschiedenen Zeitpunkten während einer Anforderung arbeiten und keine direkte Beziehung zueinander haben, durch die Parameter oder Werte zurückgegeben werden.

HttpContext.Items ist eine einfache Wörterbuchsammlung des Typs IDictionary<object, object> . Diese Sammlung ist

• verfügbar ab dem Beginn eines HttpRequest
• und wird am Ende jeder Anforderung verworfen.

Sie können darauf zugreifen, indem Sie einfach einem Schlüsseleintrag einen Wert zuweisen oder den Wert für einen bestimmten Schlüssel abfragen.

Beispielsweise könnte einige einfache Middleware der Items-Sammlung etwas hinzufügen:

app.Use(async (context, next) =>
{
    // perform some verification
    context.Items["isVerified"] = true;
    await next.Invoke();
});

und später in der Pipeline konnte eine weitere Middleware darauf zugreifen:

app.Run(async (context) =>
{
    await context.Response.WriteAsync("Verified request? " + context.Items["isVerified"]);
});

Run, Map, Use

Lauf

Beendet die Kette. Danach wird keine andere Middleware-Methode ausgeführt. Sollte am Ende einer Pipeline platziert werden.

app.Run(async context =>
{
    await context.Response.WriteAsync("Hello from " + _environment);
});

Benutzen

Führt eine Aktion vor und nach dem nächsten Delegierten aus.

app.Use(async (context, next) =>
{
    //action before next delegate
    await next.Invoke(); //call next middleware
    //action after called middleware
});

Illustration, wie es funktioniert:

MapWhen

Aktiviert die Verzweigungspipeline. Führt die angegebene Middleware aus, wenn die Bedingung erfüllt ist.

private static void HandleBranch(IApplicationBuilder app)
{
    app.Run(async context =>
    {
        await context.Response.WriteAsync("Condition is fulfilled");
    });
}

public void ConfigureMapWhen(IApplicationBuilder app)
{
    app.MapWhen(context => {
        return context.Request.Query.ContainsKey("somekey");
    }, HandleBranch);
}

Karte

Ähnlich wie bei MapWhen. Führt Middleware aus, wenn der vom Benutzer angeforderte Pfad dem in Parameter angegebenen Pfad entspricht.

private static void HandleMapTest(IApplicationBuilder app)
{
    app.Run(async context =>
    {
        await context.Response.WriteAsync("Map Test Successful");
    });
}

public void ConfigureMapping(IApplicationBuilder app)
{
    app.Map("/maptest", HandleMapTest);

}

Basierend auf ASP.net-Kerndokumenten