Inserimento di dipendenze in controller in ASP.NET Core

Di Shadi Alnamrouti e Rick Anderson

I controller ASP.NET Core MVC richiedono le proprie dipendenze in modo esplicito tramite costruttori. ASP.NET Core include il supporto predefinito per l'inserimento di dipendenze. L'inserimento delle dipendenze rende più facile testare e gestire le app.

Visualizzare o scaricare il codice di esempio (procedura per il download)

Iniezione del costruttore

I servizi vengono aggiunti come parametri del costruttore e il runtime risolve il servizio dal contenitore di servizi. In genere i servizi vengono definiti tramite interfacce. Si consideri ad esempio un'app che richiede l'ora corrente. L'interfaccia seguente espone il servizio IDateTime:

public interface IDateTime
{
    DateTime Now { get; }
}

Il codice seguente implementa l'interfaccia IDateTime:

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

Aggiungere il servizio al contenitore di servizi:

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

    services.AddControllersWithViews();
}

Per altre informazioni su AddSingleton, vedere le durate dei servizi di inserimento delle dipendenze.

Il codice seguente visualizza un messaggio di saluto all'utente in base all'orario:

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

Eseguire l'app e verrà visualizzato un messaggio in base all'orario.

Inserimento di azioni con FromServices

FromServicesAttribute consente di inserire un servizio direttamente in un metodo di azione senza usare l'inserimento del costruttore:

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

Inserimento di azioni con FromKeyedServices

Il codice seguente illustra come accedere ai servizi con chiave dal contenitore di inserimento delle dipendenze usando l'attributo [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");
    }
}

Accedere alle impostazioni da un controller

L'accesso alle impostazioni di un'app o alle impostazioni di configurazione da un controller è un tipo di azione comune. Il modello di opzioni descritto in Modello di opzioni in ASP.NET Core è l'approccio preferito per gestire le impostazioni. In linea generale, non inserire direttamente IConfiguration in un controller.

Creare una classe che rappresenta le opzioni. Per esempio:

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

Aggiungere la classe di configurazione alla raccolta di servizi:

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

    services.AddControllersWithViews();
}

Configurare l'app per leggere le impostazioni da un file in formato 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>();
            });
}

Il codice seguente richiede le impostazioni IOptions<SampleWebSettings> dal contenitore dei servizi e le usa nel metodo 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();
    }
}

Risorse aggiuntive

• Vedere Testare la logica del controller in ASP.NET Core per informazioni su come semplificare il test del codice richiedendo esplicitamente le dipendenze nei controller.
• Supporto del contenitore di inserimento delle dipendenze del servizio con chiave
• Sostituire il contenitore di inserimento delle dipendenze predefinito con un'implementazione di terze parti.