asp.net-core
middleware

Opmerkingen

De ExceptionHandler-middleware gebruiken om een aangepaste JSON-fout naar de client te verzenden

Definieer uw klasse die uw aangepaste fout zal vertegenwoordigen.

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

   // other fields

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

Zet vervolgens de volgende ExceptionHandler- middleware om de methode te configureren. Let op dat middleware bestellen belangrijk is.

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 om het antwoord ContentType in te stellen

Het idee is om HttpContext.Response.OnStarting te gebruiken, omdat dit de laatste gebeurtenis is die wordt HttpContext.Response.OnStarting voordat de headers worden verzonden. Voeg het volgende toe aan uw middleware Invoke methode.

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

Gegevens doorgeven via de middlewareketen

Uit documentatie :

De HttpContext.Items- collectie is de beste locatie om gegevens op te slaan die alleen nodig zijn tijdens het verwerken van een bepaald verzoek. De inhoud ervan wordt na elk verzoek weggegooid. Het wordt het best gebruikt als een manier om te communiceren tussen componenten of middleware die op verschillende tijdstippen tijdens een aanvraag werken en geen directe relatie met elkaar hebben waardoor parameters kunnen worden doorgegeven of waarden kunnen worden geretourneerd.

HttpContext.Items is een eenvoudige woordenboekcollectie van het type IDictionary<object, object> . Deze verzameling is

• beschikbaar vanaf het begin van een HttpRequest
• en wordt aan het einde van elk verzoek verwijderd.

U kunt er toegang toe krijgen door eenvoudigweg een waarde toe te wijzen aan een ingetoetst item of door de waarde voor een gegeven sleutel aan te vragen.

Enkele eenvoudige middleware kan bijvoorbeeld iets toevoegen aan de Items-collectie:

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

en later in de pijplijn kon een ander stuk middleware toegang krijgen:

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

Rennen, Kaart, Gebruik

Rennen

Beëindigt keten. Hierna zal geen andere middleware-methode worden uitgevoerd. Moet aan het einde van een pijpleiding worden geplaatst.

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

Gebruik

Voert actie uit voor en na de volgende afgevaardigde.

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

Illustratie van hoe het werkt:

MapWhen

Maakt vertakkende pijplijn mogelijk. Voert gespecificeerde middleware uit als aan de voorwaarde is voldaan.

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

Kaart

Vergelijkbaar met MapWhen. Voert middleware uit als pad aangevraagd door gebruiker gelijk is aan pad in parameter.

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

}

Gebaseerd op ASP.net Core Docs