Dependency Injection in .NET 6

• .NET

Sonntag, 12. Juni 2022 - Matt

Dependency Injection (DI) ist ein zentraler Bestandteil moderner .NET-Anwendungen. Mit .NET 6 hat Microsoft die DI-Funktionalität weiter verbessert und vereinfacht. In diesem Artikel werde ich die Grundlagen von Dependency Injection erläutern und einige der neuen Features in .NET 6 vorstellen.

Was ist Dependency Injection?

Dependency Injection ist ein Designmuster, das die Abhängigkeiten von Klassen verwaltet. Statt dass eine Klasse ihre Abhängigkeiten selbst erstellt, werden diese von außen bereitgestellt (injected). Dies führt zu besser testbarem und wartbarem Code.

Vorteile von Dependency Injection

1. Verbesserte Testbarkeit: Klassen können leichter isoliert und getestet werden, da ihre Abhängigkeiten ersetzt werden können.
2. Geringere Kopplung: Klassen sind weniger stark miteinander gekoppelt, was die Wartung und Erweiterung des Codes erleichtert.
3. Flexibilität: Die Abhängigkeiten können zur Laufzeit konfiguriert und geändert werden.

Einrichten von Dependency Injection in .NET 6

Schritt 1: Projekt erstellen

Erstelle ein neues .NET 6-Projekt in Visual Studio:

1. Öffne Visual Studio.
2. Gehe zu “Datei” > “Neues Projekt”.
3. Wähle “ASP.NET Core Web API” und klicke auf “Weiter”.
4. Gib deinem Projekt einen Namen und wähle den Speicherort aus.
5. Wähle “.NET 6.0 (LTS)” als Ziel-Framework und klicke auf “Erstellen”.

Schritt 2: Services registrieren

Registriere deine Services im DI-Container in der Program.cs-Datei:

var builder = WebApplication.CreateBuilder(args);

// Services hinzufügen
builder.Services.AddTransient<IMyService, MyService>();
builder.Services.AddScoped<IOtherService, OtherService>();
builder.Services.AddSingleton<ILoggerService, LoggerService>();

var app = builder.Build();

// Middleware konfigurieren
if (app.Environment.IsDevelopment())
{
    app.UseDeveloperExceptionPage();
}

app.UseRouting();
app.UseEndpoints(endpoints =>
{
    endpoints.MapControllers();
});

app.Run();

Schritt 3: Services verwenden

Injiziere die registrierten Services in deine Controller oder anderen Klassen:

public class MyController : ControllerBase
{
    private readonly IMyService _myService;
    private readonly IOtherService _otherService;

    public MyController(IMyService myService, IOtherService otherService)
    {
        _myService = myService;
        _otherService = otherService;
    }

    [HttpGet]
    public IActionResult Get()
    {
        var result = _myService.DoSomething();
        _otherService.Log("Action executed.");
        return Ok(result);
    }
}

Beispiel-Services

Hier sind Beispielimplementierungen für die registrierten Services:

public interface IMyService
{
    string DoSomething();
}

public class MyService : IMyService
{
    public string DoSomething()
    {
        return "Service is doing something.";
    }
}

public interface IOtherService
{
    void Log(string message);
}

public class OtherService : IOtherService
{
    public void Log(string message)
    {
        Console.WriteLine(message);
    }
}

public interface ILoggerService
{
    void LogInfo(string info);
}

public class LoggerService : ILoggerService
{
    public void LogInfo(string info)
    {
        Console.WriteLine(info);
    }
}

Neue Features in .NET 6

Minimal APIs

.NET 6 führt Minimal APIs ein, die eine vereinfachte Möglichkeit bieten, APIs mit weniger Boilerplate-Code zu erstellen. Auch hier wird Dependency Injection unterstützt:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddTransient<IMyService, MyService>();

var app = builder.Build();

app.MapGet("/", (IMyService myService) => myService.DoSomething());

app.Run();

Logging mit Dependency Injection

Logging lässt sich direkt über den DI-Container beziehen:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddLogging();
builder.Services.AddTransient<IMyService, MyService>();

var app = builder.Build();

app.MapGet("/", (IMyService myService, ILogger<Program> logger) =>
{
    logger.LogInformation("Endpoint called.");
    return myService.DoSomething();
});

app.Run();

Fazit

Dependency Injection nimmt einem die Verdrahtung der Abhängigkeiten ab und macht Klassen testbar, weil sie ihre Mitspieler nicht mehr selbst beschaffen. In .NET 6 ist der Container ohne Zusatzpaket dabei und deckt die üblichen Fälle ab.

Für weitere Details und eine ausführliche Anleitung besuche die [offizielle Microsoft-Dokumentation](https://docs.microsoft.com/en-us/dotnet/core/extensions/dependency-i

Die Grundlagen samt Lebensdauern stehen in der DI-Dokumentation.