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)
Inserimento 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. Ad 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.
Di Shadi Alnamrouti, Rick Anderson e Steve Smith
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)
Inserimento 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}");
}
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. Ad 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.
Di Shadi Namrouti, Rick Anderson e Steve Smith
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)
Inserimento 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.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
}
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)
{
ViewData["Message"] = $"Current server time: {dateTime.Now}";
return View();
}
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. Ad 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.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
}
Configurare l'app per leggere le impostazioni da un file in formato JSON:
public class Program
{
public static void Main(string[] args)
{
CreateWebHostBuilder(args).Build().Run();
}
public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
WebHost.CreateDefaultBuilder(args)
.ConfigureAppConfiguration((hostingContext, config) =>
{
config.AddJsonFile("samplewebsettings.json",
optional: false, // File is not optional.
reloadOnChange: false);
})
.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.
