Dependency Injection in Controller in ASP.NET Core

Von Shadi Alnamrouti und Rick Anderson

ASP.NET Core MVC-Controller fordern Abhängigkeiten explizit über Konstruktoren an. ASP.NET Core verfügt über integrierte Unterstützung für Dependency Injection ( DI). DI erleichtert das Testen und die Wartung von Apps.

Anzeigen oder Herunterladen von Beispielcode (Vorgehensweise zum Herunterladen)

Constructor Injection

Dienste werden als Konstruktorparameter hinzugefügt, und die Runtime löst den Dienst aus dem Dienstcontainer auf. Dienste werden meist mithilfe von Schnittstellen definiert. Stellen Sich sich z.B. eine App vor, für die die aktuelle Uhrzeit erforderlich ist. Die folgende Schnittstelle macht den IDateTime-Dienst verfügbar:

public interface IDateTime
{
    DateTime Now { get; }
}

Im folgenden Code wird die IDateTime-Schnittstelle implementiert:

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

Fügen Sie anschließend dem Dienstcontainer den Dienst hinzu:

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

    services.AddControllersWithViews();
}

Weitere Informationen zu AddSingleton finden Sie unter Dependency Injection in ASP.NET Core.

Im folgenden Code sehen Sie eine Begrüßung des Benutzers, die sich an der jeweiligen Tageszeit orientiert:

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

Führen Sie die App aus, und eine Nachricht wird angezeigt, die von der Tageszeit abhängt.

Action Injection mit FromServices

Mit dem FromServicesAttribute ist es möglich, einen Dienst direkt in eine Aktionsmethode einzufügen, ohne eine Constructor Injection verwenden zu müssen:

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

Action Injection mit FromKeyedServices

Der folgende Code zeigt, wie Sie aus dem DI-Container mit Hilfe des [FromKeyedServices] Attributs auf verschlüsselte Dienste zugreifen können:

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

Zugreifen auf Einstellungen von einem Controller

Das Zugreifen auf App- oder Konfigurationseinstellungen von einem Controller aus ist ein häufiges Szenario. Das unter Optionsmuster in ASP.NET Core beschriebene Optionsmuster ist der bevorzugte Ansatz, um Einstellungen zu verwalten. Fügen Sie generell IConfiguration nicht direkt in einen Controller ein.

Erstellen Sie eine Klasse, die die Optionen darstellt. Beispiel:

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

Hinzufügen der Konfigurationsklasse in die Dienstauflistung:

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

    services.AddControllersWithViews();
}

Konfigurieren Sie die App, sodass sie die Einstellungen aus einer Datei mit JSON-Formatierung liest:

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

Der folgende Code fordert die IOptions<SampleWebSettings>-Einstellungen aus dem Dienstcontainer an, und verwendet sie in der 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();
    }
}

Zusätzliche Ressourcen

• Informationen zum einfacheren Testen von Code mithilfe der expliziten Anforderung von Abhängigkeiten in Controllern finden Sie unter Testen von Controllerlogik in ASP.NET Core.
• Unterstützung von Containern für abhängigkeitsbasierte Dienste
• Informationen zum Ersetzen von Standarddienstcontainern mit einer Drittanbieterimplementierung.