autofacAan de slag met autofac


Opmerkingen

Autofac is een IoC-container voor Microsoft .NET 4.5, Silverlight 5, Windows Store-apps en Windows Phone 8-apps. Het beheert de afhankelijkheden tussen klassen, zodat applicaties gemakkelijk kunnen worden gewijzigd naarmate ze groter en complexer worden. Dit wordt bereikt door reguliere .NET-klassen als componenten te behandelen.

Van Wikipedia :
In software engineering is inversion of control (IoC) een ontwerpprincipe waarbij op maat geschreven delen van een computerprogramma de stroom van controle ontvangen van een generiek raamwerk. Een softwarearchitectuur met dit ontwerp keert de besturing om in vergelijking met traditionele procedurele programmering: bij traditionele programmering roept de aangepaste code die het doel van het programma uitdrukt herbruikbare bibliotheken op om generieke taken uit te voeren, maar met inversie van controle is dit het raamwerk die de aangepaste of taakspecifieke code aanroept.

Autofac installeren

Om Autofac in uw project te gebruiken, hoeft u alleen Autofac vanuit NuGet Package Manager te installeren. Open de oplossing waarin u Autofac wilt gebruiken en selecteer vervolgens Manager NuGet Packages for Solution... door te gaan naar:

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

NuGet-Solution tabblad NuGet-Solution "Autofac" in het zoekvak. Zorg ervoor dat u zich in het gedeelte 'Bladeren' bevindt. Installeer de eerste optie zoals weergegeven in de onderstaande afbeelding (let op de gemarkeerde gebieden in de afbeelding):

Nuget-autofac

Installeren via NuGet voegt automatisch Autofac toe aan de Referenties van de projecten die tijdens de installatie werden geselecteerd.

Bekijk de officiële documentatie .

Autofac instellen

Dit voorbeeld laat zien hoe u aan de slag kunt gaan met Inverion of Control met behulp van Autofac met een relatief eenvoudig project, waarbij u de officiële startdocumenten nauwkeurig volgt.

  1. Maak een consoletoepassing van File -> New -> Project -> Console Application

  2. Installeer Autofac voor dit project. U kunt hier een kijkje nemen Autofac installeren

  3. Voeg 2 interfaces en 2 klassen toe, met de volgende namen:

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

Omwille van de eenvoud worden de gebruikende statements en naamruimten niet getoond.

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

Tot dusverre is de code duidelijk en eenvoudig geweest. Laten we eens kijken naar het gedeelte waar automatische afhankelijkheidsinjectie plaatsvindt, wat natuurlijk wordt gedaan door Autofac!

Vervang de Program in het bestand Program.cs door deze code ( Program wordt automatisch gemaakt door Visual Studio bij het maken van het project. Als het niet bestaat, ga je gang en maak je er een):

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

Wanneer uitgevoerd, moet de uitvoer de huidige datum in de console zijn. U hebt met succes Autofac in uw project gebruikt om afhankelijkheden automatisch te injecteren.

Hier is wat er gebeurt onder de motorkap:

  1. Bij het opstarten van de applicatie maken we een ContainerBuilder en registreren we onze componenten ermee. Een component in eenvoudige bewoordingen is een .NET-type dat een interface implementeert en dus sommige services blootstelt. Services lezen versus componenten .

  2. We registreren onze componenten (klassen) vervolgens met de services (interfaces) die ze blootleggen. Wanneer geregistreerd, weet Autofac welk exemplaar van een klasse moet worden gemaakt wanneer een interface moet worden opgelost .

  3. Tot slot, wanneer we het programma uitvoeren:

    • De methode WriteDate() (in Main() ) vraagt Autofac om een IDateWriter .
    • Autofac ziet dat IDateWriter aan TodayWriter dus begint met het maken van een TodayWriter .
    • Autofac ziet dat de TodayWriter een IOutput in zijn constructor.
    • Autofac ziet dat IOutput aan ConsoleOutput dus een nieuwe ConsoleOutput instantie maakt.
    • Autofac gebruikt de nieuwe ConsoleOutput instantie om de constructie van de TodayWriter te voltooien.
    • Autofac retourneert de volledig geconstrueerde TodayWriter voor WriteDate() om te consumeren.