autofac Mise en place de Autofac


Exemple

Cet exemple montrera comment démarrer avec Inverion of Control en utilisant Autofac avec un projet relativement simple, en suivant de près les documents initiaux officiels .

  1. Créer une application console à partir de File -> New -> Project -> Console Application

  2. Installez Autofac pour ce projet. Vous pouvez jeter un oeil ici Installer Autofac

  3. Ajoutez 2 interfaces et 2 classes, avec les noms suivants:

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

Pour simplifier, les instructions using et les espaces de noms ne sont pas affichés.

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

Jusqu'à présent, le code était simple et clair. Permet d'accéder à la partie où l'injection de dépendance automatique a lieu, ce qui est bien sûr fait par Autofac!

Remplacez la classe de Program dans le fichier Program.cs par ce code (la classe de Program est créée automatiquement par Visual Studio lors de la création du projet. Si elle n'existe pas, créez-en une):

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

Lorsqu'elle est exécutée, la sortie doit être la date actuelle dans la console. Vous avez utilisé Autofac avec succès dans votre projet pour injecter automatiquement des dépendances.

Voici ce qui se passe sous le capot:

  1. Au démarrage de l'application, nous créons un ContainerBuilder et enregistrons nos composants . Un composant en termes simples est un type .NET qui implémente une interface et expose ainsi certains services . Services de lecture vs composants .

  2. Nous enregistrons ensuite nos composants (classes) avec les services (interfaces) qu'ils exposent. Une fois enregistré, Autofac sait quelle instance d'une classe créer lors de la résolution d' une interface.

  3. Enfin, lorsque nous exécutons le programme:

    • La méthode WriteDate() (dans Main() ) demande à Autofac un IDateWriter .
    • Autofac voit que IDateWriter correspond à TodayWriter donc commence à créer un TodayWriter .
    • Autofac voit que le TodayWriter besoin d'un IOutput dans son constructeur.
    • Autofac voit que IOutput sur ConsoleOutput ce qui crée une nouvelle instance de ConsoleOutput .
    • Autofac utilise la nouvelle instance de ConsoleOutput pour terminer la construction de TodayWriter .
    • Autofac renvoie le entièrement construit TodayWriter pour WriteDate() à consommer.