ahhay automapper

C# und Autofac

Autofac IoC Container

Für Inversion of Control (IoC) stehen eine ganze Reihe von Container zur Verfügung. In diesem Artikel wird der IoC-Container Autofac vorgestellt. Dies setzt ein grundlegendes Verständnis von entkoppelter Architektur und dem Konzept der Inversion of Control voraus.

Mit IoC sollen unabhängige Komponenten verknüpft werden, für diesen Artikel wurde ein einfaches Beispiel für Dependency Injection mit Autofac erstellt. Zur Umsetzung wurde ein Template für Konsolenanwendung verwendet und Autofac wurde über ein Nuget Package geladen.

Schritt 1

Autofac mittels Nuget zum Projekt hinzufügen

Schritt 2

In der Hauptklasse der Konsolenanwendung ist ein Aufruf für die Methode BuildContainer implementiert.

class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine("Starting builder!");
            
        var prg = new Program();
        prg.BuildContainer();
            
        Console.ReadLine();
    }
    ...
}

Schritt 3

Im dritten Schritt werden jeweils zwei Klassen und dazugehörige Interface implementiert. Aus dem Container werden die Klassen geladen und deren Methode über die Schnittstellen aufgerufen.

public class EmailHandler : IEmailHandler
{
    public void Execute()
    {
        Console.WriteLine("Email-Handler Executing!");
    } 
}
...
public interface IEmailHandler
{
    void Execute();
}
...
...
public class FileHandler : IFileHandler
{
    public void Execute()
    {
        Console.WriteLine("File-Handler Executing!");
    } 
}
...
public interface IFileHandler
{
    void Execute();
}

Schritt 4

In der BuildContainer Methode der Klasse "Programm" wird der Container mit den Klassen FileHandler und EmailHandler befüllt.

class Program
{
    ...

    public void BuildContainer()
    {
        var builder = new ContainerBuilder();
        builder.RegisterType<FileHandler>().As<IFileHandler>();
        builder.RegisterType<EmailHandler>().As<IEmailHandler>();
        var container = builder.Build();

        container.Resolve<IFileHandler>().Execute();
        container.Resolve<IEmailHandler>().Execute();
    }
}

Schritt 5

Die Klasse NotificationSender verwendet die Instanzen von EmailHandler und FileHandler. Auf diese Instanzen kann mittels constructor oder property injection zugegriffen werden.

public class NotificationSender
{
    public IEmailHandler EmailHandler;
    public IFileHandler FileHandler;

    //injection through constructor  
    public NotificationSender(IEmailHandler tmpService)
    {
        EmailHandler = tmpService;
    }
    //Injection through property  
    public IFileHandler SetFileHandler
    {
        set { FileHandler = value; }
    }
    public void SendNotification()
    {
        EmailHandler.Execute();
        FileHandler.Execute();
    } 
}

Ergebnis

Führt man die Konsolenanwendung aus, wird der Container befüllt und in der NotificationSender-Klasse werden die Methoden Execute ausgeführt.