Comment Inscrire ces classe Dans Autofac

EDIT: j'ai lu et pensé que c'était une question sur la façon d'utiliser autofac pour enregistrer les dépendances. Si vous voulez garder la même UnitOfWork, vous avez besoin à portée de la durée de vie de l'instance à quelque chose. Si vous êtes en utilisant ce dans un ASP.NET ou WCF application, vous pouvez enregistrer vos dépendances comme ceci:

typeBuilder.RegisterType<UnitOfWork>().InstancePerLifetimeScope();
typeBuilder.RegisterType<Repository>();
typeBuilder.RegisterType<Service>();

---

Première chose que vous devez faire afin d'utiliser un conteneur comme Autofac est d'enregistrer toutes vos dépendances. Dans Autofac vous pouvez faire un peu de moyens, mais tous reposent sur l'utilisation de l'un ContainerBuilder. Le ContainerBuilder s'appuie sur des méthodes d'extension, donc assurez-vous d'avoir un using de déclaration pour l'Autofac espace de noms.

Vous pouvez définir de façon explicite les méthodes de fabrique:

//Explicitly 
var builder = new ContainerBuilder();
builder.Register<UnitOfWork>(b => new UnitOfWork());
builder.Register<Repository>(b => new Repository(b.Resolve<UnitOfWork>()));
builder.Register(b => new Service(b.Resolve<Repository>(), b.Resolve<UnitOfWork>()));

À l'aide de ContainerBuilder nous avons accès à la Register<>() d'une méthode à l'interface de service (qui est de savoir comment nous devons nous poser le récipient pour le service) dans ce cas, je ne suis pas en utilisant des interfaces, juste le type réel. Tout moment vous demander le conteneur pour un UnitOfWork il va utiliser la méthode de factorisation new UnitOfWork() d'en générer un. Dans la vraie vie, vous serait probablement demander une IUnitOfWork. Cela peut être un peu verbeux, mais c'est très pratique lorsque vous avez besoin d'une logique personnalisée pour la dépendance à la création.

Vous pouvez utiliser le générateur comme toute autre dépendance conteneur et il suffit de s'inscrire sur les types.

//Implicitly
var typeBuilder = new ContainerBuilder();
typeBuilder.RegisterType<UnitOfWork>();
typeBuilder.RegisterType<Repository>();
typeBuilder.RegisterType<Service>();

Cette approche repose sur l'enregistrement de toutes les dépendances nécessaires à la construction d'une classe. Le conteneur va ensuite utiliser la réflexion pour résoudre les arguments du constructeur. Si un argument n'est pas enregistré, le conteneur va lever une exception avec le type dont il n'a pas pu résoudre. Dans ce cas, le service a une dépendance sur UnitOfWork et Repository. Repository dispose également d'une dépendance sur UnitOfWork. Ces dépendances sont exprimées comme des arguments du constructeur. Pour demander un Repository ou un Service à partir du conteneur, toutes les dépendances doivent être enregistrés

Vous pouvez utiliser l'approche de configuration.

Si vous utilisez une application.fichier de configuration, vous pouvez définir votre fichier de configuration comme ceci:

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <configSections>
    <section name="autofac" type="Autofac.Configuration.SectionHandler, Autofac.Configuration"/>
  </configSections>

  <autofac defaultAssembly="AutoFacTest">
    <components>
      <component
              type="AutoFacTest.Repository, AutoFacTest"
              service="AutoFacTest.Repository" />

      <component
               type="AutoFacTest.UnitOfWork, AutoFacTest"
               service="AutoFacTest.UnitOfWork" />

      <component
              type="AutoFacTest.Service, AutoFacTest"
              service="AutoFacTest.Service" />
    </components>
  </autofac>
</configuration>

Tout d'abord, notez que nous avons à définir une section de configuration (avis de l' <ConfigSections>). Ensuite, on peut créer un <autofac> section qui définit l'ensemble de nos dépendances. La notation est assez simple, vous créez un <component> pour chaque dépendance. Chaque composant a un service attribut qui définit le type qui vous sera demandé. Il y a aussi un type attribut qui définit l'objet de l'être créé lorsqu'une instance de la demande de service. Ceci est analogue à builder.Register<UnitOfWork>(b => new UnitOfWork()) où UnitOfWork est le service demandé (et dans ce cas) est aussi du genre à être créé.

Pour créer le générateur de rapports à l'aide de la configuration, de l'utilisation d'un ConfigurationSettingsReader()

//Config
var configBuilder = new ContainerBuilder();
configBuilder.RegisterModule(new ConfigurationSettingsReader("autofac"));

Vous avez à passer le nom de votre section de configuration (dans ce cas, autofac). Une fois que vous avez configuré les dépendances, vous avez à construire un conteneur. Le ContainerBuilder contient une méthode pour ce faire:

var container = builder.Build();
var typeContainer = typeBuilder.Build();
var configContainer = configBuilder.Build();

Et une fois que vous avez le conteneur, vous pouvez demander les instances de votre service:

container.Resolve<Service>().DoAwesomeness();
typeContainer.Resolve<Service>().DoAwesomeness();
configContainer.Resolve<Service>().DoAwesomeness();

Programme complet:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Autofac;
using Autofac.Configuration;
namespace AutoFacTest
{
class Program
{
static void Main(string[] args)
{
//Explicitly 
var builder = new ContainerBuilder();
builder.Register<UnitOfWork>(b => new UnitOfWork());
builder.Register<Repository>(b => new Repository(b.Resolve<UnitOfWork>()));
builder.Register(b => new Service(b.Resolve<Repository>(), b.Resolve<UnitOfWork>()));
//Implicitly
var typeBuilder = new ContainerBuilder();
typeBuilder.RegisterType<UnitOfWork>();
typeBuilder.RegisterType<Repository>();
typeBuilder.RegisterType<Service>();
//Config
var configBuilder = new ContainerBuilder();
configBuilder.RegisterModule(new ConfigurationSettingsReader("autofac"));
var container = builder.Build();
var typeContainer = typeBuilder.Build();
var configContainer = configBuilder.Build();
container.Resolve<Service>().DoAwesomeness();
typeContainer.Resolve<Service>().DoAwesomeness();
configContainer.Resolve<Service>().DoAwesomeness();
Console.Read();
}
}
public class Repository
{
private readonly UnitOfWork _unitOfWork;
public Repository(UnitOfWork uow)
{
_unitOfWork = uow;
}
public void PrintStuff(string text)
{
Console.WriteLine(text);
}
}
public class Service
{
private readonly Repository _repository;
private readonly UnitOfWork _unitOfWork;
public Service(Repository repo, UnitOfWork uow)
{
_repository = repo;
_unitOfWork = uow;
}
public void DoAwesomeness()
{
_repository.PrintStuff("Did awesome stuff!");
_unitOfWork.Commit();
}
}
public class UnitOfWork
{
public bool Commit()
{
return true;
}
}
}

OriginalL'auteur JaySilk84