asp.net-core
Middleware

Remarques

Utilisation du middleware ExceptionHandler pour envoyer une erreur JSON personnalisée au client

Définissez votre classe qui représentera votre erreur personnalisée.

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

   // other fields

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

Ensuite, mettez le middleware ExceptionHandler suivant à la méthode Configure. Attention, la commande de middleware est 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 pour définir la réponse ContentType

L'idée est d'utiliser le rappel HttpContext.Response.OnStarting , car il s'agit du dernier événement déclenché avant l'envoi des en-têtes. Ajoutez ce qui suit à votre méthode 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);
}

Passer des données à travers la chaîne de middleware

De la documentation :

La collection HttpContext.Items est le meilleur emplacement pour stocker des données uniquement nécessaires lors du traitement d'une requête donnée. Son contenu est supprimé après chaque demande. Il est préférable de l'utiliser comme moyen de communication entre des composants ou des intergiciels fonctionnant à différents moments au cours d'une requête et n'ayant aucune relation directe entre eux pour transmettre des paramètres ou renvoyer des valeurs.

HttpContext.Items est une collection de dictionnaires simple de type IDictionary<object, object> . Cette collection est

• disponible dès le début d'une HttpRequest
• et est rejeté à la fin de chaque demande.

Vous pouvez y accéder simplement en attribuant une valeur à une entrée à clé ou en demandant la valeur d'une clé donnée.

Par exemple, certains Middleware simples pourraient ajouter quelque chose à la collection Items:

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

et plus tard, un autre middleware pourrait y accéder:

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

Exécuter, mapper, utiliser

Courir

Termine la chaîne. Aucune autre méthode de middleware ne fonctionnera après cela. Devrait être placé à la fin de tout pipeline.

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

Utilisation

Effectue une action avant et après le prochain délégué.

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

Illustration de son fonctionnement:

MapWhen

Active le pipeline de branchement. Exécute le middleware spécifié si la condition est remplie.

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

Carte

Similaire à MapWhen. Exécute le middleware si le chemin demandé par l'utilisateur est égal au chemin fourni en paramètre.

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

}

Basé sur ASP.net Core Docs