Une façon plus agréable d'injecter des trucs
Chaque fois que je crée des éléments tels que des services, des référentiels, des attributs ou quoi que ce soit à injecter dans mes applications, nous devons effectuer cette étape, qui consiste en fait à ajouter les services à l’application.
C’est toujours la même chose, vous allez dans Program.cs, puis procédez à une partie du fichier en ajoutant builder.Services.AddScoped<MyService>(); afin d’injecter le service.
Quelque chose comme ça :
var builder = WebApplication.CreateBuilder(args);
// Add services to the container.
builder.Services.AddRazorPages();
// Repositories
builder.Services.AddScoped<ARepository>(); // 👀
builder.Services.AddScoped<BRepository>(); // 👀
// Services
builder.Services.AddScoped<AService>(); // 👀
builder.Services.AddScoped<BService>(); // 👀
builder.Services.AddScoped<CService>(); // 👀
builder.Services.AddScoped<DService>(); // 👀
var app = builder.Build();
// Configure the HTTP request pipeline.
if (!app.Environment.IsDevelopment())
{
app.UseExceptionHandler("/Error");
// The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthorization();
app.MapRazorPages();
app.Run();
Je veux dire, ça marche, mais je suis difficile et je n’aime pas vraiment ça.
Disons que nous voulons faire plusieurs injections de dépendances, et ce ne sont pas vraiment les mêmes choses, dans mon cas, cela pourrait être quelque chose comme avoir une bibliothèque qui contient tous les référentiels, une autre bibliothèque qui a tous les services et enfin, une autre bibliothèque qui contient des attributs.
Dans ce cas, pouvez-vous imaginer le nombre de lignes que nous devons ajouter à Program.cs.
Disons que nous avons une bibliothèque qui contient certains services, si nous voulons inclure tous nos services, nous devons travailler avec IServiceCollection.
Nous allons donc créer un static class qui aura une méthode static appelée AddServices qui renvoie un IServiceCollection.
Dans ce cas, il sera nommé IServiceCollectionServicesExtensions.
/// <summary>
/// IServiceCollectionServicesExtensions class
/// </summary>
public static class IServiceCollectionServicesExtensions
{
/// <summary>
/// AddCoreServices
/// </summary>
/// <param cref="IServiceCollection" name="services">Parameter for <see cref="IServiceCollection"/></param>
/// <returns>An object of type <see cref="IServiceCollection"/></returns>
public static IServiceCollection AddServices(this IServiceCollection services)
{
services
.AddScoped<AService>()
.AddScoped<BService>()
.AddScoped<CService>()
.AddScoped<DService>();
return services;
}
}
Non seulement cela, nous avons également une autre bibliothèque qui inclut certains référentiels utilisés par ces services, alors faisons de même.
/// <summary>
/// IServiceCollectionServicesExtensions class
/// </summary>
public static class IServiceCollectionServicesExtensions
{
/// <summary>
/// AddCoreServices
/// </summary>
/// <param cref="IServiceCollection" name="services">Parameter for <see cref="IServiceCollection"/></param>
/// <returns>An object of type <see cref="IServiceCollection"/></returns>
public static IServiceCollection AddRepositories(this IServiceCollection services)
{
services
.AddScoped<ARepository>()
.AddScoped<BRepository>();
return services;
}
}
Maintenant, nous avons créé nos référentiels et nos méthodes de services à injecter, mais comment les utiliser ?
Revenons à notre Program.cs et ajoutons ce qui suit :
var builder = WebApplication.CreateBuilder(args);
// Add services to the container.
builder.Services.AddRazorPages();
// Repositories
builder.Services.AddRepositories(); // 👀
// Services
builder.Services.AddServices(); // 👀
var app = builder.Build();
// Configure the HTTP request pipeline.
if (!app.Environment.IsDevelopment())
{
app.UseExceptionHandler("/Error");
// The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthorization();
app.MapRazorPages();
app.Run();
Cela a l’air bien plus propre, n’est-ce pas ? Eh bien, avec cela, nous avons injecté avec succès certains services et référentiels, mais maintenant cela semble plus joli et nous avons réellement ce que nous injectons dans la bibliothèque externe.