Unidad Registro dos interfaces como un producto único

Question

¿Cómo registro dos interfaces diferentes en unidad con la misma instancia ... Actualmente estoy usando

 _container.RegisterType<EventService, EventService>(new ContainerControlledLifetimeManager()); 
     _container.RegisterInstance<IEventService>(_container.Resolve<EventService>()); 
     _container.RegisterInstance<IEventServiceInformation>(_container.Resolve<EventService>()); 

que funciona, pero no se ven bien ..

Entonces, creo que entiendes la idea. EventService implementa dos interfaces, quiero una referencia al mismo objeto si resuelvo las interfaces.

Chris

Answer 1

Editar

Después de algunos comentarios en los comentarios he decidido que la respuesta de Sven es una respuesta muy superior. Gracias a Chris Tavares por señalar los méritos técnicos.

---

Esa es prácticamente la única forma de hacerlo.

Se podría modificar ligeramente (odio RegisterType con el mismo tipo para cada parámetro genérico):

EventService es = _container.Resolve<EventService>(); 
_container.RegisterInstance<IEventService>(es); 
_container.RegisterInstance<IEventServiceInformation>(es); 

Si uno o más de sus hijos COI se va a solicitar el tipo concreto EventService (esperemos que no) agregaría uno más RegisterInstance del tipo RegisterInstance<EventService>. Esperemos que no lo necesite y todos los objetos dependientes piden un IEventService, en lugar de un EventService.

Espero que esto ayude, Anderson

Answer 2

[Editar]

La solución para hacer esto a través de la configuración de XML se puede encontrar here. Sobre la base de esa respuesta me gustaría proponer un enfoque de sólo código simplificado de la siguiente manera:

_container.RegisterType<IEventService, EventService>(new ContainerControlledLifetimeManager()); 
_container.RegisterType<IEventServiceInformation, EventService>(new ContainerControlledLifetimeManager()); 
bool singleton = ReferenceEquals(_container.Resolve<IEventService>(), _container.Resolve<IEventServiceInformation>()); 

De esta manera, la propia clase EventService no se publica por el contenedor. Como la clase se debe considerar como un detalle de implementación, este es el enfoque preferible.

[Respuesta original]

Un poco tarde una respuesta, pero debe hacer el truco:

_container.RegisterType<EventService>(new ContainerControlledLifetimeManager()); 
_container.RegisterType<IEventService, EventService>(); 
_container.RegisterType<IEventServiceInformation, EventService>(); 

bool singleton = ReferenceEquals(_container.Resolve<IEventService>(), _container.Resolve<IEventServiceInformation>()); 

Answer 3

Una solución que también puede funcionar para las instancias con nombre es usar el adapter para crear los adaptadores desechables a la interfaz que envuelve las instancias de singleton. Entonces, las instancias resueltas siempre se dirigirán a la instancia singleton, evento si se resuelven usando ResolveAll. Esto ayuda al tener un montón de servicios que implementan una interfaz genérica como IStartable o algo así.

public class EventServiceAdapter<T> : IEventService where T : IEventService 
{ 
    private readonly T _adapted; 
    EventServiceAdapter(T adapted) 
    { 
     _adapted = adapted; 
    } 
    public string SomeMethod() 
    { 
     return _adapted.SomeMethod(); 
    } 
} 

A continuación, registre el adaptador de interfaz alrededor de su tipo de singleton registrado.

_container 
    .RegisterType<EventService>(new ContainerControlledLifetimeManager()) 
    .RegisterType<IEventService, EventServiceAdapter<EventService>>("namedEventService"); 

entonces usted puede ocultar cualquier Singleton detrás de cualquier número de interfaces, y el trabajo utilizando tanto Resolver y ResolveAll.

Answer 4

El enfoque del adaptador parecía voluminoso para algo tan simple, así que busqué un poco más. Para solucionar el problema con las instancias mencionadas, debe registrar el tipo y registrar las fábricas para las interfaces.

InjectionFactory factory = new InjectionFactory(x => x.Resolve<SimulationService>()); 
this.Container.RegisterType<SimulationService>(new ContainerControlledLifetimeManager()); 
this.Container.RegisterType<IContentProvider>("SimulationContentProvider", factory); 
this.Container.RegisterType<ISimulationService>(factory); 

De esta manera no es necesario crear una instancia de la clase concreta (en el registro), que no era posible en mi caso debido a las dependencias que faltan.