Kurse:Services

ASP.NET Core MVC – Services & Dependency Injection (DI)

Was sind Services?

Services sind Klassen, die die zentrale Geschäftslogik der Anwendung kapseln. Sie sind:

• Wiederverwendbar
• Selbstständig
• Von Controllern/VIEWS unabhängig

Typische Aufgaben:

• Datenzugriff
• Berechnungen
• API-Kommunikation
• Benachrichtigungen & Logging

Vorteile

• Kapselung: Geschäftslogik getrennt von Controller/View
• Wiederverwendbarkeit
• Testbarkeit
• Dependency Injection möglich

Beispielcode – Einfacher Service ohne DI

// CitiesService.cs
namespace Services {
  public class CitiesService {
    private List<string> _cities = new List<string> { "London", "Paris", "New York" };
    public List<string> GetCities() => _cities;
  }
}

// HomeController.cs
public class HomeController : Controller {
  private readonly CitiesService _citiesService = new CitiesService();
  public IActionResult Index() {
    var cities = _citiesService.GetCities();
    return View(cities);
  }
}

Hinweis: Kein DI – in echten Anwendungen besser über DI realisieren.

Interface & DIP-Prinzip

// ICitiesService.cs
public interface ICitiesService {
  List<string> GetCities();
}

// CitiesService.cs
public class CitiesService : ICitiesService {
  public List<string> GetCities() => new List<string> { "London", "Berlin", "Tokyo" };
}

Registrierung in Program.cs

builder.Services.AddTransient<ICitiesService, CitiesService>();

DI im Controller

public class HomeController : Controller {
  private readonly ICitiesService _citiesService;
  public HomeController(ICitiesService citiesService) {
    _citiesService = citiesService;
  }
}

Lebenszyklen von Services

• Transient: Neue Instanz bei jeder Anforderung
• Scoped: Eine Instanz pro HTTP-Anfrage
• Singleton: Eine Instanz für gesamte App-Laufzeit

builder.Services.AddTransient<IExample, ExampleTransient>();
builder.Services.AddScoped<IExample, ExampleScoped>();
builder.Services.AddSingleton<IExample, ExampleSingleton>();

Autofac Integration

builder.Host.UseServiceProviderFactory(new AutofacServiceProviderFactory());
builder.Host.ConfigureContainer<ContainerBuilder>(containerBuilder => {
  containerBuilder.RegisterType<CitiesService>()
                  .As<ICitiesService>()
                  .InstancePerLifetimeScope();
});

Dependency Injection Techniken

• Konstruktor-Injektion (Standard)
• Property-Injektion mit [FromServices]
• Methoden-Injektion direkt im Methodenparameter

// Property
[FromServices]
public ILogger Logger { get; set; }

// Method
public IActionResult Index([FromServices] IUserService service) {
  ...
}

Beispiel – DIP Prinzip

// Ohne DIP
class LightSwitch {
  private SpecificLightBulb bulb = new SpecificLightBulb();
  public void TurnOn() => bulb.Illuminate();
}

// Mit DIP
interface ILight {
  void Illuminate();
}
class LightBulb : ILight {
  public void Illuminate() { ... }
}
class LightSwitch {
  private ILight light;
  public LightSwitch(ILight light) {
    this.light = light;
  }
  public void TurnOn() => light.Illuminate();
}

Best Practices

• Verwende Konstruktor-Injektion als Standard
• Verwende Interfaces für lose Kopplung
• Vermeide den Service Locator Anti-Pattern
• Registriere Abhängigkeiten in Program.cs
• Achte auf kompatible Lebenszyklen
• Nutze Dekoratoren für Logging/Caching
• Nutze das Options-Pattern für Konfiguration
• Keine Überverwendung von DI

Interview-Tipps

• Erkläre DIP, IoC und DI einfach und präzise
• Begründe die Wahl des richtigen Lebenszyklus
• Zeige Best Practices wie Interface-Nutzung, Constructor DI
• Erwähne Autofac als erweiterbares DI-Tool

Zusammenfassung

• DIP: Hohe Module hängen von Abstraktionen ab
• IoC: Framework verwaltet Abhängigkeits-Erzeugung
• DI: Implementierung von IoC
• Lifetimes: Transient / Scoped / Singleton
• Autofac: Leistungsfähige Alternative zum .NET-Core-DI