ASP .NET Core 6 / C# – Configuration des services et des middlewares

Avant ASP .NET Core 6

Avant ASP .NET Core 6, nous avions l’habitude de configurer les services dans la méthode ConfigureServices de la classe Startup, et les middlewares permettant de traiter les requêtes et réponses HTTP dans la méthode Configure de cette même classe. Cette classe était utilisée dans la classe Program pour indiquer à l’hôte de l’application, la classe de démarrage à prendre en compte :

public class Program
{
	public static void Main(string[] args)
	{
		CreateHostBuilder(args).Build().Run();
	}

	public static IHostBuilder CreateHostBuilder(string[] args) =>
		Host.CreateDefaultBuilder(args)
		    .ConfigureWebHostDefaults(webBuilder =>
			 {
				 webBuilder.UseStartup<Startup>();
			 });
}

public class Startup
{
    private IConfiguration Configuration { get; init; }

    public Startup(IConfiguration aConfiguration)
    {
        this.Configuration = aConfiguration;
    }

    public void ConfigureServices(IServiceCollection aServices)
    {
        aServices.AddControllersWithViews();
    }

    public void Configure(IApplicationBuilder aApp, IWebHostEnvironment aEnv)
    {
        aApp.UseHttpsRedirection();
        aApp.UseStaticFiles();
        aApp.UseRouting();
        aApp.UseAuthentication();
        aApp.UseAuthorization();

        aApp.UseEndpoints(endpoints =>
        {
            endpoints.MapControllerRoute(
                name: "default",
                pattern: "{controller=Home}/{action=Index}/{id?}");
        });
    }
}

Depuis ASP .NET Core 6

Bien que le modèle présenté ci-dessus peut toujours être implémenté, depuis la version 6 d’ASP .NET Core, Microsoft propose une nouvelle manière d’implémenter le démarrage de l’application. Lors de la création d’une nouvelle application ASP .NET Core MVC, seule la classe Program est présente. Son contenu est le suivant :

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddControllersWithViews();

var app = builder.Build();

app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthentication();
app.UseAuthorization();

app.UseEndpoints(endpoints =>
{
    endpoints.MapControllerRoute(
        name: "default",
        pattern: "{controller=Home}/{action=Index}/{id?}");
});

app.Run();

Les instructions ne sont pas présentes dans une méthode d’une classe, car le concept « des instructions de niveau supérieur » est utilisé (voir mon article sur ce sujet). Si on observe attentivement ce bloc de code, on remarque trois parties :

  • La première contenant l’instanciation du builder et la configuration des services (composée des deux premières instructions)
  • Une deuxième qui commence à la compilation du builder de l’application jusqu’à l’avant dernière instruction (middlewares)
  • La dernière qui exécute l’application

On pourrait regretter le découpage physique que proposait la précédente implémentation décrite au chapitre précédent, qui permettait de ne pas mélanger des blocs d’instructions qui jouent un rôle différent. Cependant, étant donné qu’il ne s’agit que de la configuration de l’application, on peut considérer que cela ajoute des classes imposant une couche d’abstraction supplémentaire sans apporter de réelle plus-value. Pour retrouver un découpage analogue à l’implémentation précédente, nous pouvons utiliser dans le fichier Program.cs le concept de fonctions locales (ConfigureServices et Configure) :

using DemoAppStartup;

WebApplicationBuilder builder = WebApplication.CreateBuilder(args);

ConfigureServices(builder.Services);

WebApplication app = builder.Build();
Configure(app, builder.Environment);

app.Run();

void ConfigureServices(IServiceCollection services)
{
    services.AddControllersWithViews();
}

void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    app.UseHttpsRedirection();
    app.UseStaticFiles();
    app.UseRouting();
    app.UseAuthentication();
    app.UseAuthorization();

    app.UseEndpoints(endpoints =>
    {
        endpoints.MapControllerRoute(
            name: "default",
            pattern: "{controller=Home}/{action=Index}/{id?}");
    });
}

Étiquettes :

About: James RAVAILLE

Travaillant avec la plateforme Microsoft .NET depuis 2002, j'alterne les missions de formation et d'ingénierie avec cette plateforme. J'écris ce blog pour transmettre mes connaissances à tout développeur, qu'il soit débutant ou expérimenté.