autofacDémarrer avec autofac


Remarques

Autofac est un conteneur IoC pour les applications Microsoft .NET 4.5, Silverlight 5, Windows Store et Windows Phone 8. Il gère les dépendances entre les classes afin que les applications restent faciles à modifier à mesure qu'elles augmentent en taille et en complexité. Ceci est réalisé en traitant les classes .NET régulières comme des composants.

De Wikipedia :
En génie logiciel, l'inversion du contrôle (IoC) est un principe de conception dans lequel les parties écrites d'un programme informatique reçoivent le flux de contrôle d'un cadre générique. Une architecture logicielle avec cette conception inverse le contrôle par rapport à la programmation procédurale traditionnelle: en programmation traditionnelle, le code personnalisé qui exprime la finalité des appels de programme dans des bibliothèques réutilisables pour prendre en charge des tâches génériques, mais avec inversion de contrôle qui appelle le code personnalisé ou spécifique à la tâche.

Installation d'Autofac

Pour utiliser Autofac dans votre projet, il vous suffit d'installer Autofac à partir de NuGet Package Manager. Ouvrez la solution qui souhaite utiliser Autofac, puis sélectionnez Manager NuGet Packages for Solution... en allant sur:

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

Dans l'onglet NuGet-Solution , tapez "Autofac" dans la zone de recherche. Assurez-vous que vous êtes dans la section "Parcourir". Installez la première option comme indiqué dans l'image ci-dessous (notez les régions marquées dans l'image):

Nuget-Autofac

L'installation via NuGet ajoutera automatiquement Autofac aux références des projets sélectionnés lors de l'installation.

Regardez la documentation officielle .

Mise en place de Autofac

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.