Dela via

Beroendeinmatning till styrenheter i ASP.NET Core

Av Shadi Alnamrouti och Rick Anderson

ASP.NET Core MVC-styrenheter begär uttryckligen beroenden via konstruktorer. ASP.NET Core har inbyggt stöd för beroendeinmatning (DI). DI gör appar enklare att testa och underhålla.

Visa eller ladda ned exempelkod (hur du laddar ned)

Konstruktorinjektion

Tjänster adderas som en konstruktorparameter, och runtime-systemet hämtar tjänsten från tjänstcontainern. Tjänster definieras vanligtvis med hjälp av gränssnitt. Tänk dig till exempel en app som kräver aktuell tid. Följande gränssnitt exponerar IDateTime tjänsten:

public interface IDateTime
{
    DateTime Now { get; }
}

Följande kod implementerar IDateTime gränssnittet:

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

Lägg till tjänsten i tjänstcontainern:

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

    services.AddControllersWithViews();
}

Mer information om AddSingletonfinns i DI-tjänstens livslängd.

Följande kod visar en hälsning till användaren baserat på tid på dagen:

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

Kör appen och ett meddelande visas baserat på tiden.

Åtgärdsinjektion med FromServices

Möjliggör FromServicesAttribute inmatning av en tjänst direkt i en åtgärdsmetod utan att använda konstruktorinmatning:

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

Åtgärdsinjektion med FromKeyedServices

Följande kod visar hur du får åtkomst till nyckelade tjänster från DI-containern med hjälp av attributet [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");
    }
}

Åtkomstinställningar från en kontrollant

Att komma åt app- eller konfigurationsinställningar inifrån en kontrollant är ett vanligt mönster. Alternativmönstret som beskrivs i Alternativmönster i ASP.NET Core är den bästa metoden för att hantera inställningar. I allmänhet ska du inte mata IConfiguration in direkt i en styrenhet.

Skapa en klass som representerar alternativen. Till exempel:

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

Lägg till konfigurationsklassen i tjänstsamlingen:

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

    services.AddControllersWithViews();
}

Konfigurera appen så att den läser inställningarna från en JSON-formaterad fil:

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

Följande kod begär IOptions<SampleWebSettings> inställningarna från tjänstcontainern och använder dem i Index -metoden:

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

Ytterligare resurser

Av Shadi Alnamrouti, Rick Anderson och Steve Smith

ASP.NET Core MVC-styrenheter begär uttryckligen beroenden via konstruktorer. ASP.NET Core har inbyggt stöd för beroendeinmatning (DI). DI gör appar enklare att testa och underhålla.

Visa eller ladda ned exempelkod (hur du laddar ned)

Konstruktorinjektion

Tjänster adderas som en konstruktorparameter, och runtime-systemet hämtar tjänsten från tjänstcontainern. Tjänster definieras vanligtvis med hjälp av gränssnitt. Tänk dig till exempel en app som kräver aktuell tid. Följande gränssnitt exponerar IDateTime tjänsten:

public interface IDateTime
{
    DateTime Now { get; }
}

Följande kod implementerar IDateTime gränssnittet:

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

Lägg till tjänsten i tjänstcontainern:

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

    services.AddControllersWithViews();
}

Mer information om AddSingletonfinns i DI-tjänstens livslängd.

Följande kod visar en hälsning till användaren baserat på tid på dagen:

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

Kör appen och ett meddelande visas baserat på tiden.

Åtgärdsinjektion med FromServices

Möjliggör FromServicesAttribute inmatning av en tjänst direkt i en åtgärdsmetod utan att använda konstruktorinmatning:

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

Åtkomstinställningar från en kontrollant

Att komma åt app- eller konfigurationsinställningar inifrån en kontrollant är ett vanligt mönster. Alternativmönstret som beskrivs i Alternativmönster i ASP.NET Core är den bästa metoden för att hantera inställningar. I allmänhet ska du inte mata IConfiguration in direkt i en styrenhet.

Skapa en klass som representerar alternativen. Till exempel:

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

Lägg till konfigurationsklassen i tjänstsamlingen:

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

    services.AddControllersWithViews();
}

Konfigurera appen så att den läser inställningarna från en JSON-formaterad fil:

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

Följande kod begär IOptions<SampleWebSettings> inställningarna från tjänstcontainern och använder dem i Index -metoden:

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

Ytterligare resurser

ASP.NET Core MVC-styrenheter begär uttryckligen beroenden via konstruktorer. ASP.NET Core har inbyggt stöd för beroendeinmatning (DI). DI gör appar enklare att testa och underhålla.

Visa eller ladda ned exempelkod (hur du laddar ned)

Konstruktorinjektion

Tjänster adderas som en konstruktorparameter, och runtime-systemet hämtar tjänsten från tjänstcontainern. Tjänster definieras vanligtvis med hjälp av gränssnitt. Tänk dig till exempel en app som kräver aktuell tid. Följande gränssnitt exponerar IDateTime tjänsten:

public interface IDateTime
{
    DateTime Now { get; }
}

Följande kod implementerar IDateTime gränssnittet:

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

Lägg till tjänsten i tjänstcontainern:

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

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

Mer information om AddSingletonfinns i DI-tjänstens livslängd.

Följande kod visar en hälsning till användaren baserat på tid på dagen:

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

Kör appen och ett meddelande visas baserat på tiden.

Åtgärdsinjektion med FromServices

Möjliggör FromServicesAttribute inmatning av en tjänst direkt i en åtgärdsmetod utan att använda konstruktorinmatning:

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

    return View();
}

Åtkomstinställningar från en kontrollant

Att komma åt app- eller konfigurationsinställningar inifrån en kontrollant är ett vanligt mönster. Alternativmönstret som beskrivs i Alternativmönster i ASP.NET Core är den bästa metoden för att hantera inställningar. I allmänhet ska du inte mata IConfiguration in direkt i en styrenhet.

Skapa en klass som representerar alternativen. Till exempel:

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

Lägg till konfigurationsklassen i tjänstsamlingen:

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

Konfigurera appen så att den läser inställningarna från en JSON-formaterad fil:

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

Följande kod begär IOptions<SampleWebSettings> inställningarna från tjänstcontainern och använder dem i Index -metoden:

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

Ytterligare resurser