Afhankelijkheidsinjectie in controllers in ASP.NET Core

Door Shadi Alnamrouti en Rick Anderson

ASP.NET Core MVC-controllers vragen afhankelijkheden expliciet aan via constructors. ASP.NET Core heeft ingebouwde ondersteuning voor afhankelijkheidsinjectie (DI). DI maakt apps gemakkelijker te testen en te onderhouden.

Voorbeeldcode bekijken of downloaden (hoe download je)

Constructor injection

Services worden toegevoegd als constructorparameter en de runtime haalt de service op uit de servicecontainer. Services worden doorgaans gedefinieerd met behulp van interfaces. Denk bijvoorbeeld aan een app waarvoor de huidige tijd is vereist. De volgende interface maakt de IDateTime service beschikbaar:

public interface IDateTime
{
    DateTime Now { get; }
}

Met de volgende code wordt de IDateTime interface geïmplementeerd:

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

Voeg de service toe aan de servicecontainer:

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

    services.AddControllersWithViews();
}

Voor meer informatie over AddSingleton, zie .

In de volgende code wordt een begroeting voor de gebruiker weergegeven op basis van het tijdstip van de dag:

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

Voer de app uit en er wordt een bericht weergegeven op basis van de tijd.

Injectie van acties met FromServices

Hiermee FromServicesAttribute kunt u een service rechtstreeks in een actiemethode injecteren zonder constructorinjectie te gebruiken:

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

Actie-injectie met FromKeyedServices

De volgende code laat zien hoe u toegang krijgen tot sleutelservices vanuit de DI-container met behulp van het [FromKeyedServices] kenmerk:

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

Toegangsinstellingen vanaf een controller

Het openen van app- of configuratie-instellingen vanuit een controller is een gemeenschappelijk patroon. Het optiespatroon dat wordt beschreven in het patroon Opties in ASP.NET Core is de voorkeursbenadering voor het beheren van instellingen. Over het algemeen moet u IConfiguration niet rechtstreeks in een controller injecteren.

Maak een klasse die de opties vertegenwoordigt. For example:

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

Voeg de configuratieklasse toe aan de servicesverzameling:

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

    services.AddControllersWithViews();
}

Configureer de app om de instellingen te lezen uit een bestand met JSON-indeling:

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

De volgende code vraagt de IOptions<SampleWebSettings> instellingen van de servicecontainer aan en gebruikt deze in de Index methode:

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

Additional resources

• Zie Controllerlogica testen in ASP.NET Core voor meer informatie over het eenvoudiger testen van code door expliciet afhankelijkheden in controllers aan te vragen.
• Ondersteuning voor serviceafhankelijkheidsinjectiecontainer met sleutel
• Vervang de standaardcontainer voor afhankelijkheidsinjectie door een implementatie van derden.

Door Shadi Alnamrouti, Rick Anderson en Steve Smith

ASP.NET Core MVC-controllers vragen afhankelijkheden expliciet aan via constructors. ASP.NET Core heeft ingebouwde ondersteuning voor afhankelijkheidsinjectie (DI). DI maakt apps gemakkelijker te testen en te onderhouden.

Voorbeeldcode bekijken of downloaden (hoe download je)

Constructor injection

Services worden toegevoegd als constructorparameter en haalt de runtime de service op uit de servicecontainer. Services worden doorgaans gedefinieerd met behulp van interfaces. Denk bijvoorbeeld aan een app waarvoor de huidige tijd is vereist. De volgende interface maakt de IDateTime service beschikbaar:

public interface IDateTime
{
    DateTime Now { get; }
}

Met de volgende code wordt de IDateTime interface geïmplementeerd:

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

Voeg de service toe aan de servicecontainer:

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

    services.AddControllersWithViews();
}

Voor meer informatie over AddSingleton, zie DI-servicelevensduur.

In de volgende code wordt een begroeting voor de gebruiker weergegeven op basis van het tijdstip van de dag:

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

Voer de app uit en er wordt een bericht weergegeven op basis van de tijd.

Actie-invoer met FromServices

Hiermee FromServicesAttribute kunt u een service rechtstreeks in een actiemethode injecteren zonder constructorinjectie te gebruiken:

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

Toegangsinstellingen vanaf een controller

Het openen van app- of configuratie-instellingen vanuit een controller is een gemeenschappelijk patroon. Het optiespatroon dat wordt beschreven in het patroon Opties in ASP.NET Core is de voorkeursbenadering voor het beheren van instellingen. Over het algemeen mag u de code IConfiguration niet rechtstreeks in een controller injecteren.

Maak een klasse die de opties vertegenwoordigt. For example:

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

Voeg de configuratieklasse toe aan de servicesverzameling:

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

    services.AddControllersWithViews();
}

Configureer de app om de instellingen te lezen uit een bestand met JSON-indeling:

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

De volgende code vraagt de IOptions<SampleWebSettings> instellingen van de servicecontainer aan en gebruikt deze in de Index methode:

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

Additional resources

• Zie Controllerlogica testen in ASP.NET Core voor meer informatie over het eenvoudiger testen van code door expliciet afhankelijkheden in controllers aan te vragen.

• Vervang de standaardcontainer voor afhankelijkheidsinjectie door een implementatie van derden.

Door Shadi Namrouti, Rick Anderson en Steve Smith

ASP.NET Core MVC-controllers vragen afhankelijkheden expliciet aan via constructors. ASP.NET Core heeft ingebouwde ondersteuning voor afhankelijkheidsinjectie (DI). DI maakt apps gemakkelijker te testen en te onderhouden.

Voorbeeldcode bekijken of downloaden (hoe download je)

Constructor injection

Diensten worden toegevoegd als constructorparameter en de runtime haalt de dienst op uit de dienstcontainer. Services worden doorgaans gedefinieerd met behulp van interfaces. Denk bijvoorbeeld aan een app waarvoor de huidige tijd is vereist. De volgende interface maakt de IDateTime service beschikbaar:

public interface IDateTime
{
    DateTime Now { get; }
}

Met de volgende code wordt de IDateTime interface geïmplementeerd:

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

Voeg de service toe aan de servicecontainer:

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

    services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
}

Voor meer informatie over AddSingleton, zie DI-servicelevensduur.

In de volgende code wordt een begroeting voor de gebruiker weergegeven op basis van het tijdstip van de dag:

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

Voer de app uit en er wordt een bericht weergegeven op basis van de tijd.

Injectie van acties met FromServices

Hiermee FromServicesAttribute kunt u een service rechtstreeks in een actiemethode injecteren zonder constructorinjectie te gebruiken:

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

    return View();
}

Toegangsinstellingen vanaf een controller

Het openen van app- of configuratie-instellingen vanuit een controller is een gemeenschappelijk patroon. Het optiespatroon dat wordt beschreven in het patroon Opties in ASP.NET Core is de voorkeursbenadering voor het beheren van instellingen. Over het algemeen moet u IConfiguration niet rechtstreeks in een controller injecteren.

Maak een klasse die de opties vertegenwoordigt. For example:

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

Voeg de configuratieklasse toe aan de servicesverzameling:

public void ConfigureServices(IServiceCollection services)
{
    services.AddSingleton<IDateTime, SystemDateTime>();
    services.Configure<SampleWebSettings>(Configuration);
    
    services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
}

Configureer de app om de instellingen te lezen uit een bestand met JSON-indeling:

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

De volgende code vraagt de IOptions<SampleWebSettings> instellingen van de servicecontainer aan en gebruikt deze in de Index methode:

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

Additional resources

• Zie Controllerlogica testen in ASP.NET Core voor meer informatie over het eenvoudiger testen van code door expliciet afhankelijkheden in controllers aan te vragen.

• Vervang de standaardcontainer voor afhankelijkheidsinjectie door een implementatie van derden.