asp.net-core
middleware

Osservazioni

Utilizzo del middleware ExceptionHandler per inviare al client un errore JSON personalizzato

Definisci la tua classe che rappresenterà il tuo errore personalizzato.

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

   // other fields

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

Quindi inserire il prossimo middleware ExceptionHandler nel metodo Configure. Fai attenzione che l'ordine del middleware è importante.

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 per impostare la risposta ContentType

L'idea è di usare HttpContext.Response.OnStarting callback, poiché questo è l'ultimo evento che viene generato prima che le intestazioni vengano inviate. Aggiungi quanto segue al tuo metodo di Invoke middleware.

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

Passa i dati attraverso la catena del middleware

Dalla documentazione :

La raccolta HttpContext.Items è la posizione migliore in cui archiviare i dati necessari solo durante l'elaborazione di una determinata richiesta. I suoi contenuti vengono scartati dopo ogni richiesta. Si utilizza al meglio come mezzo di comunicazione tra componenti o middleware che operano in momenti diversi durante una richiesta e non hanno alcuna relazione diretta tra loro per il passaggio di parametri o valori di ritorno.

HttpContext.Items è una semplice raccolta di dizionari di tipo IDictionary<object, object> . Questa collezione è

• disponibile dall'inizio di HttpRequest
• e viene scartato alla fine di ogni richiesta.

È possibile accedervi semplicemente assegnando un valore a una voce con chiave o richiedendo il valore per una determinata chiave.

Ad esempio, alcuni semplici middleware potrebbero aggiungere qualcosa alla raccolta Articoli:

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

e più avanti nella pipeline, un altro pezzo di middleware potrebbe accedervi:

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

Esegui, Mappa, Usa

Correre

Termina la catena. Nessun altro metodo middleware verrà eseguito dopo questo. Dovrebbe essere posizionato alla fine di qualsiasi oleodotto.

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

Uso

Esegue un'azione prima e dopo il prossimo delegato.

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

Ilustration di come funziona:

MapWhen

Abilita la pipeline di ramificazione. Esegue il middleware specificato se la condizione è soddisfatta.

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

Carta geografica

Simile a MapWhen. Esegue il middleware se il percorso richiesto dall'utente equivale al percorso fornito nel parametro.

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

}

Basato su ASP.net Core Docs