Comment faire pour résoudre interface basée sur le service où il est passé à

J'ai une interface.

public interface ISomeInterface {...}

et deux implémentations (SomeImpl1 et SomeImpl2):

public class SomeImpl1 : ISomeInterface {...}
public class SomeImpl2 : ISomeInterface {...}

J'ai également deux services où j'ai injecter ISomeInterface (via le constructeur):

public class Service1 : IService1 
{
   public Service1(ISomeInterface someInterface)
   {
   }
...
}

public class Service2 : IService2 
{
   public Service2(ISomeInterface someInterface)
   {
   }
...
}

Je suis en utilisant Autofac comme mon outil IoC.
La question. Comment puis-je configurer Autofac enregistrements de sorte SomeImpl1 sera automatiquement injecté dans Service1, et SomeImpl2 sera automatiquement injecté dans Service2.

Merci!

InformationsquelleAutor Andrei M | 2011-06-07

autofac c#

32

Autofac prend en charge identification des services par nom. Grâce à lui, vous pouvez enregistrer vos implémentations avec un nom (à l'aide de la Named méthode d'extension). Vous pouvez ensuite régler entre eux par leur nom dans le IServiceX d'inscription des délégués, à l'aide de la ResolveNamed méthode d'extension. Le code suivant illustre cette.
```
var cb = new ContainerBuilder();
cb.Register(c => new SomeImpl1()).Named<ISomeInterface>("impl1");
cb.Register(c => new SomeImpl2()).Named<ISomeInterface>("impl2");
cb.Register(c => new Service1(c.ResolveNamed<ISomeInterface>("impl1"))).As<IService1>();
cb.Register(c => new Service2(c.ResolveNamed<ISomeInterface>("impl2"))).As<IService2>();
var container = cb.Build();

var s1 = container.Resolve<IService1>();//Contains impl1
var s2 = container.Resolve<IService2>();//Contains impl2
```
Alternative à l'aide RegisterType (par opposition à Register)

Vous pouvez obtenir le même résultat à l'aide de la RegisterType méthode d'extension en combinaison avec WithParameter et ResolvedParameter. Cela est utile si le constructeur prenant un paramètre nommé prend également d'autres non-nommé de paramètres que vous n'avez pas soin de préciser, dans un enregistrement délégué:
```
var cb = new ContainerBuilder();
cb.RegisterType<SomeImpl1>().Named<ISomeInterface>("impl1");
cb.RegisterType<SomeImpl2>().Named<ISomeInterface>("impl2");
cb.RegisterType<Service1>().As<IService1>().WithParameter(ResolvedParameter.ForNamed<ISomeInterface>("impl1"));
cb.RegisterType<Service2>().As<IService2>().WithParameter(ResolvedParameter.ForNamed<ISomeInterface>("impl2"));
var container = cb.Build();

var s1 = container.Resolve<IService1>();//Contains impl1
var s2 = container.Resolve<IService2>();//Contains impl2
```
- Merci pour la réponse. Il fonctionne très bien. Mais mon SomeImpl1 et SomeImpl2 a des dépendances sur beaucoup d'autres services. Je ne veux pas de spécifier tous d'entre eux lors de l'inscription. Est-il possible de l'atteindre sans la création d'une instance au cours de l'enregistrement: new SomeImpl1()?
- Je veux dire quelque chose comme: builder.RegisterType<Service1>().En tant que<IService1>().([comment spécifier "impl1" ici pour le premier paramètre de Service1?]);
- J'ai mis à jour la réponse montrant comment réaliser la même chose avec RegisterType.
- Super! Merci beaucoup!
InformationsquelleAutor bentayloruk
4

Si vous pouvez passer du constructeur d'injection à la propriété de l'injection, et de laisser les deux services proviennent de la même classe de base (ou de mettre en œuvre la même interface), vous pouvez effectuer les opérations suivantes:
```
builder.RegisterType<ServiceBase>().OnActivating(e =>
{
    var type = e.Instance.GetType();

    //get ISomeInterface based on instance type, i.e.:
    ISomeInterface dependency =
        e.Context.ResolveNamed<ISomeInterface>(type.Name);

    e.Instance.SomeInterface = dependency;
});
```
Pour que cela fonctionne, vous devez définir la propriété sur le type de base (ou l'interface). Cette solution est très flexible et pourrait même vous permettre de choses complexes tels que l'injection d'un type générique, basé sur le type parent, comme on peut le voir ci-dessous:
```
builder.RegisterType<ServiceBase>().OnActivating(e =>
{
    var type = 
       typeof(GenericImpl<>).MakeGenericType(e.Instance.GetType());

    e.Instance.SomeInterface = (ISomeInterface)e.Context.Resolve(type);
});
```
Cette approche a quelques inconvénients:
1. Nous avons besoin de la propriété d'injection.
2. Nous avons besoin d'un type de base ou de l'interface qui contient la propriété.
3. Nous avons besoin de réflexion pour construire le type, qui pourraient avoir un impact sur la performance (au lieu de l'enceinte de confinement efficace délégué) (bien que nous puissions être en mesure d'accélérer les choses par la mise en cache du type).
À la hausse, cette conception est simple et fonctionne pour presque n'importe quel conteneur.

InformationsquelleAutor Steven

Quatre variantes de faire cela est décrit dans autofac documentation:

Option 1: La Refonte De Vos Interfaces

Lorsque vous exécutez dans une situation où vous avez un tas de composants
que mettre en œuvre des services identiques, mais ils ne peuvent pas être traitées
de manière identique, ce qui est généralement un problème de conception de l'interface.

À partir d'un développement orienté objet point de vue, vous voulez votre
les objets de respecter le principe de substitution de Liskov et ce genre
des ruptures qui.

En faisant de la refonte de l'interface, vous n'avez pas à choisir une
la dépendance par le contexte” - vous d'utiliser les types de différencier et de laisser
auto-wireup de la magie se produire au cours de la résolution.

Si vous avez la possibilité d'influer sur le changement de votre solution, c'est le
option recommandée.

Option 2: Modifier les Enregistrements

Vous pouvez associer manuellement le type approprié avec la consommation de la composante de cette façon:

var builder = new ContainerBuilder();
builder.Register(ctx => new ShippingProcessor(new PostalServiceSender()));
builder.Register(ctx => new CustomerNotifier(new EmailNotifier()));
var container = builder.Build();

//Lambda registrations resolve based on the specific type, not the
//ISender interface.
builder.Register(ctx => new ShippingProcessor(ctx.Resolve<PostalServiceSender>()));
builder.Register(ctx => new CustomerNotifier(ctx.Resolve<EmailNotifier>()));
var container = builder.Build();

Option 3: Utilisation D'Un Détrompeur Services

builder.RegisterType<PostalServiceSender>()
           .As<ISender>()
           .Keyed<ISender>("order");
    builder.RegisterType<EmailNotifier>()
           .As<ISender>()
           .Keyed<ISender>("notification");

builder.RegisterType<ShippingProcessor>()
           .WithParameter(
             new ResolvedParameter(
               (pi, ctx) => pi.ParameterType == typeof(ISender),
               (pi, ctx) => ctx.ResolveKeyed<ISender>("order")));
    builder.RegisterType<CustomerNotifier>();
           .WithParameter(
             new ResolvedParameter(
               (pi, ctx) => pi.ParameterType == typeof(ISender),
               (pi, ctx) => ctx.ResolveKeyed<ISender>("notification")));

Option 4: Utilisation Des Métadonnées

builder.RegisterType<PostalServiceSender>()
           .As<ISender>()
           .WithMetadata("SendAllowed", "order");
    builder.RegisterType<EmailNotifier>()
           .As<ISender>()
           .WithMetadata("SendAllowed", "notification");

builder.RegisterType<ShippingProcessor>()
           .WithParameter(
             new ResolvedParameter(
               (pi, ctx) => pi.ParameterType == typeof(ISender),
               (pi, ctx) => ctx.Resolve<IEnumerable<Meta<ISender>>>()
                               .First(a => a.Metadata["SendAllowed"].Equals("order"))));
    builder.RegisterType<CustomerNotifier>();
           .WithParameter(
             new ResolvedParameter(
               (pi, ctx) => pi.ParameterType == typeof(ISender),
               (pi, ctx) => ctx.Resolve<IEnumerable<Meta<ISender>>>()
                               .First(a => a.Metadata["SendAllowed"].Equals("notification"))));

InformationsquelleAutor Ivan

Vous devez vous connecter pour publier un commentaire.