autofac Handledning
Komma igång med autofac

Anmärkningar

Installera Autofac

För att använda Autofac i ditt projekt behöver du bara installera Autofac från NuGet Package Manager. Öppna lösningen som vill använda Autofac i och välj sedan Manager NuGet Packages for Solution... genom att gå till:

Tools -> NuGet Package Manager -> Manager NuGet Packages for Solution...

NuGet-Solution "Autofac" i sökrutan på fliken NuGet-Solution . Se till att du är i avsnittet "Bläddra". Installera det första alternativet som visas på bilden nedan (notera de markerade regionerna i bilden):

Installering via NuGet lägger automatiskt till Autofac i referenserna för de projekt som valts under installationen.

Ta en titt på den officiella dokumentationen .

Ställa in Autofac

Det här exemplet visar hur man kommer igång med Inverion of Control med Autofac med ett relativt enkelt projekt, noggrant följer de officiella dokumenten för att komma igång .

1. Skapa en konsolapplikation från File -> New -> Project -> Console Application

2. Installera Autofac för detta projekt. Du kan ta en titt här Installera Autofac

3. Lägg till 2 gränssnitt och 2 klasser, med följande namn:

     Interfaces  |  Classes
   --------------------------
   IOutput       | ConsoleOutput (implementing IOutput)
   IDateWriter   | TodayWriter (implementing IDateWriter)
   

För enkelhetens skull visas inte användande uttalanden och namnutrymmen.

IOuput.cs

public interface IOutput
{
    void Write(string content);
}

ConsoleOutput.cs

public class ConsoleOutput : IOutput
{
    public void Write(string content)
    {
        Console.WriteLine(content);
    }
}

IDateWriter.cs

public interface IDateWriter
{
    void WriteDate();
}

TodayWriter.cs

public class TodayWriter : IDateWriter
{
    private IOutput _output;

    public TodayWriter(IOutput output)
    {
        _output = output;
    }

    public void WriteDate()
    {
        _output.Write(DateTime.Today.ToShortDateString());
    }
}

Hittills har koden varit enkel och enkel. Låt oss komma till den del där automatisk beroendeinjektion äger rum, vilket naturligtvis görs av Autofac!

Byt ut Program i filen Program.cs med den här koden ( Program skapas automatiskt av Visual Studio vid projektets skapande. Om den inte finns, gå vidare och skapa en):

class Program
{
    private static IContainer Container { get; set; }

    static void Main(string[] args)
    {
        var builder = new ContainerBuilder();
        builder.RegisterType<ConsoleOutput>().As<IOutput>();
        builder.RegisterType<TodayWriter>().As<IDateWriter>();
        Container = builder.Build();

        WriteDate();
    }

    public static void WriteDate()
    {
        using (var scope = Container.BeginLifetimeScope())
        {
            var writer = scope.Resolve<IDateWriter>();
            writer.WriteDate();
        }
    }
}

Vid körning bör utgången vara det aktuella datumet i konsolen. Du har framgångsrikt använt Autofac i ditt projekt för att injicera beroende automatiskt.

Här är vad som händer under huven:

1. Vid programstart skapar vi en ContainerBuilder och registrerar våra komponenter med den. En komponent i enkla termer är en .NET-typ som implementerar ett gränssnitt och därmed exponerar vissa tjänster . Läs tjänster kontra komponenter .

2. Vi registrerar sedan våra komponenter (klasser) med de tjänster (gränssnitt) de exponerar. När registrerad vet Autofac vilken instans av en klass som ska skapas när ett gränssnitt ska lösas .

3. Slutligen, när vi kör programmet:

   • WriteDate() (i Main() ) ber Autofac om en IDateWriter .
   • Autofac ser att IDateWriter till TodayWriter så börjar skapa en TodayWriter .
   • Autofac ser att TodayWriter behöver en IOutput i sin konstruktör.
   • Autofac ser att IOutput kartor till ConsoleOutput så skapar en ny ConsoleOutput instans.
   • Autofac använder den nya instansen ConsoleOutput att slutföra konstruktionen av TodayWriter .
   • Autofac returnerar den helt konstruerade TodayWriter för WriteDate() att konsumera.