unity-container - manager - unity global script

Unity Registre dos interfaces como un singleton

Question

¿Cómo registro dos interfaces diferentes en Unity 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 ve bien ..

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

Chris

Answer 1

El enfoque del adaptador parecía voluminoso para una cosa tan simple, así que miré 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 fue posible en mi caso debido a la falta de dependencias.

Answer 2

Una solución que también puede funcionar para instancias con nombre es usar el patrón del adaptador para crear adaptadores desechables a la interfaz que se ajusta a las instancias 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();
    }
} 

Luego registre el adaptador de interfaz alrededor de su tipo de singleton registrado.

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

A continuación, puede ocultar cualquier singleton detrás de cualquier cantidad de interfaces y trabajar usando Resolve y ResolveAll.

Answer 3

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.

Podrías modificarlo un poco (odio el 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 de IoC va a solicitar el tipo concreto de EventService (con suerte no), agregaría una RegisterInstance más de tipo RegisterInstance<EventService> . Es de esperar que no lo necesite y que todos los objetos dependientes soliciten un IEventService , en lugar de un EventService .

Espero que esto ayude, Anderson

Answer 4

[Editar]

La solución para hacer esto a través de la configuración XML se puede encontrar here . Sobre la base de esa respuesta, propondría un enfoque simplificado de solo código 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 forma, la clase EventService no es publicada 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 debería 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>());