asp.net-core
middle~~POS=TRUNC

Anmärkningar

Använda ExceptionHandler-mellanprogrammet för att skicka anpassat JSON-fel till klienten

Definiera din klass som representerar ditt anpassade fel.

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

   // other fields

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

Lägg sedan nästa ExceptionHandler mellanprogram till Konfigurera metoden. Var uppmärksam på att beställningen av mellanvaror är viktig.

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 för att ställa in svar ContentType

Tanken är att använda HttpContext.Response.OnStarting , eftersom det här är den sista händelsen som avfyras innan rubrikerna skickas. Lägg till följande till din Middleware Invoke metod.

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

Skicka data genom mellanvarukedjan

Från dokumentation :

HttpContext.Items- samlingen är den bästa platsen att lagra data som bara behövs vid bearbetning av en given begäran. Innehållet tas bort efter varje begäran. Det används bäst som ett sätt att kommunicera mellan komponenter eller mellanprogram som fungerar vid olika tidpunkter under en begäran, och har inga direkta förhållanden med varandra genom vilka parametrar eller returneringsvärden ska passeras.

HttpContext.Items är en enkel ordbokssamling av typ IDictionary<object, object> . Denna samling är

• tillgängligt från början av en HttpRequest
• och kasseras i slutet av varje begäran.

Du kan komma åt det genom att helt enkelt tilldela ett värde till en nycklad post eller genom att begära värdet för en given nyckel.

Några enkla Middleware kan till exempel lägga till något i artikelsamlingen:

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

och senare i rörledningen kunde ytterligare ett stycke mellanvaror komma åt det:

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

Run, Map, Use

Springa

Avslutar kedjan. Ingen annan mellanprogrammetod kommer att köras efter detta. Bör placeras i slutet av någon pipeline.

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

Använda sig av

Utför åtgärder före och efter nästa delegat.

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

Illustration av hur det fungerar:

MapWhen

Aktiverar grenrörledningen. Kör specificerad mellanprogram om villkoret är uppfyllt.

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

Karta

Liknar MapWhen. Kör mellanprogram om sökvägen begärs av användaren är lika med banan som anges i parametern.

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

}

Baserat på ASP.net Core Docs