Injection de dépendances dans les contrôleurs dans ASP.NET Core

Par Shadi Alnamrouti et Rick Anderson

Les contrôleurs ASP.NET Core MVC demandent les dépendances explicitement via des constructeurs. ASP.NET Core offre une prise en charge intégrée de l’injection de dépendances. L’injection de dépendances facilite le test et la maintenance des applications.

Affichez ou téléchargez l’exemple de code (procédure de téléchargement)

Injection de constructeurs

Les services sont ajoutés sous forme de paramètre de constructeur, et le runtime résout les services à partir du conteneur de services. Les services sont généralement définis à partir d’interfaces. Par exemple, prenons le cas d’une application qui a besoin de l’heure actuelle. L’interface suivante expose le service IDateTime :

public interface IDateTime
{
    DateTime Now { get; }
}

Le code suivant implémente l’interface IDateTime :

public class SystemDateTime : IDateTime
{
    public DateTime Now
    {
        get { return DateTime.Now; }
    }
}

Ajoutez le service au conteneur de services :

public void ConfigureServices(IServiceCollection services)
{
    services.AddSingleton<IDateTime, SystemDateTime>();

    services.AddControllersWithViews();
}

Pour plus d’informations sur AddSingleton, consultez Durée de vie des services d’injonction de dépendances.

Le code suivant adresse une salutation à l’utilisateur qui varie en fonction de l’heure du jour :

public class HomeController : Controller
{
    private readonly IDateTime _dateTime;

    public HomeController(IDateTime dateTime)
    {
        _dateTime = dateTime;
    }

    public IActionResult Index()
    {
        var serverTime = _dateTime.Now;
        if (serverTime.Hour < 12)
        {
            ViewData["Message"] = "It's morning here - Good Morning!";
        }
        else if (serverTime.Hour < 17)
        {
            ViewData["Message"] = "It's afternoon here - Good Afternoon!";
        }
        else
        {
            ViewData["Message"] = "It's evening here - Good Evening!";
        }
        return View();
    }

Exécutez l’application et un message s’affiche en fonction de l’heure.

Injection d’action avec FromServices FromServices

FromServicesAttribute permet d’injecter un service directement dans une méthode d’action sans utiliser l’injection de constructeurs :

public IActionResult About([FromServices] IDateTime dateTime)
{
    return Content( $"Current server time: {dateTime.Now}");
}

Injection d’action avec FromServices FromKeyedServices

Le code suivant montre comment accéder aux services à clé d’accès à partir du conteneur d’injection de dépendances (DI) en utilisant l’attribut [FromKeyedServices] :

using Microsoft.AspNetCore.Mvc;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddKeyedSingleton<ICache, BigCache>("big");
builder.Services.AddKeyedSingleton<ICache, SmallCache>("small");
builder.Services.AddControllers();

var app = builder.Build();

app.MapControllers();

app.Run();

public interface ICache
{
    object Get(string key);
}
public class BigCache : ICache
{
    public object Get(string key) => $"Resolving {key} from big cache.";
}

public class SmallCache : ICache
{
    public object Get(string key) => $"Resolving {key} from small cache.";
}

[ApiController]
[Route("/cache")]
public class CustomServicesApiController : Controller
{
    [HttpGet("big")]
    public ActionResult<object> GetBigCache([FromKeyedServices("big")] ICache cache)
    {
        return cache.Get("data-mvc");
    }

    [HttpGet("small")]
    public ActionResult<object> GetSmallCache([FromKeyedServices("small")] ICache cache)
    {
        return cache.Get("data-mvc");
    }
}

Accéder aux paramètres à partir d’un contrôleur

L’accès aux paramètres de configuration ou d’application à partir d’un contrôleur est un modèle commun. Le modèle d'options décrit dans Modèle d'options dans ASP.NET Core est l'approche préférée pour gérer les paramètres. En règle générale, n’injectez pas directement IConfiguration dans un contrôleur.

Créez une classe qui représente les options. Par exemple :

public class SampleWebSettings
{
    public string Title { get; set; }
    public int Updates { get; set; }
}

Ajoutez la classe de configuration à la collection de services :

public void ConfigureServices(IServiceCollection services)
{
    services.AddSingleton<IDateTime, SystemDateTime>();
    services.Configure<SampleWebSettings>(Configuration);

    services.AddControllersWithViews();
}

Configurez l’application pour qu’elle lise les paramètres à partir d’un fichier au format JSON :

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

    public static IHostBuilder CreateHostBuilder(string[] args) =>
        Host.CreateDefaultBuilder(args)
            .ConfigureAppConfiguration((hostingContext, config) =>
            {
                config.AddJsonFile("samplewebsettings.json",
                    optional: false,
                    reloadOnChange: true);
            })
            .ConfigureWebHostDefaults(webBuilder =>
            {
                webBuilder.UseStartup<Startup>();
            });
}

Le code suivant demande les paramètres IOptions<SampleWebSettings> au conteneur de services et les utilise dans la méthode Index :

public class SettingsController : Controller
{
    private readonly SampleWebSettings _settings;

    public SettingsController(IOptions<SampleWebSettings> settingsOptions)
    {
        _settings = settingsOptions.Value;
    }

    public IActionResult Index()
    {
        ViewData["Title"] = _settings.Title;
        ViewData["Updates"] = _settings.Updates;
        return View();
    }
}

Ressources supplémentaires

• Consultez Tester la logique du contrôleur dans ASP.NET Core pour savoir comment faciliter le test du code en demandant explicitement des dépendances dans les contrôleurs.
• Prise en charge du conteneur d’injection de dépendances de service à clé
• Remplacez le conteneur d’injection de dépendances par défaut par une implémentation tierce.