c# - Personalización de la resolución de componentes de Autofac/Problema con co-/contravarianza genérica

customization resolution

Question

Primero, perdón por el vago título de la pregunta. No podría llegar a una más precisa.

Teniendo en cuenta estos tipos:

 { TCommand : ICommand }
«interface» «interface» /
+-----------+ +----------------------/----+
| ICommand | | ICommandHandler<TCommand> |
+-----------+ +---------------------------+
^ | Handle(command: TCommand) |
| +---------------------------+
| ^
| |
+------------+ +-------------------+
| FooCommand | | FooCommandHandler |
+------------+ +-------------------+
^
|
+-------------------+
| SpecialFooCommand |
+-------------------+

Me gustaría escribir un método de Dispatch que acepte cualquier comando y lo envíe a un ICommandHandler<> adecuado. Pensé que usar un contenedor DI (Autofac) podría simplificar enormemente la asignación del tipo de comando a un controlador de comandos:

void Dispatch<TCommand>(TCommand command) where TCommand : ICommand
{
var handler = autofacContainer.Resolve<ICommandHandler<TCommand>>();
handler.Handle(command);
}

Digamos que el contenedor DI conoce todos los tipos mostrados arriba. Ahora estoy llamando:

Dispatch(new SpecialFooCommand(…));

En realidad, esto dará como resultado que Autofac lance una excepción ComponentNotRegisteredException , ya que no hay ICommandHandler<SpecialFooCommand> disponible.

Sin embargo, lo ideal sería que el controlador de comandos de coincidencia más cercana SpecialFooCommand un SpecialFooCommand , es decir. por un FooCommandHandler en el ejemplo anterior.

¿Se puede personalizar Autofac para ese fin, tal vez con una fuente de registro personalizada?

PD: Entiendo que podría existir el problema fundamental de que la co- / contravarianza se interponga en el camino (como en el siguiente ejemplo), y que la única solución podría ser una que no use genéricos en absoluto ... pero lo haría desea atenerse a los tipos genéricos, si es posible.

ICommandHandler<FooCommand> fooHandler = new FooCommandHandler(…);
ICommandHandler<ICommand> handler = fooHandler;
// ^
// doesn''t work, types are incompatible

Answer 1

Lo que pides no es posible sin una codificación propia. Básicamente, está preguntando lo siguiente: Si no se encuentra el tipo que intenté resolver, devuelva otro tipo que pueda convertirse, por ejemplo, si intenta resolver IEnumerable devuelva un tipo que esté registrado para ICollection . Esto no es compatible. Una solución simple sería la siguiente: Registre FooCommandHandler como un controlador para ICommandHandler<SpecialFooCommand> . Para que esto funcione, ICommandHandler debe ser contravariant :

interface ICommand { }
class FooCommand : ICommand { }
class SpecialFooCommand : FooCommand { }
interface ICommandHandler<in T> where T : ICommand
{
void Handle(T command);
}
class FooCommandHandler : ICommandHandler<FooCommand>
{
public void Handle(FooCommand command)
{
// ...
}
}
var builder = new ContainerBuilder();
builder.RegisterType<FooCommandHandler>()
.As<ICommandHandler<SpecialFooCommand>>()
.As<ICommandHandler<FooCommand>>();
var container = builder.Build();
var fooCommand = new FooCommand();
var specialCommand = new SpecialFooCommand();
container.Resolve<ICommandHandler<FooCommand>>().Handle(fooCommand);
container.Resolve<ICommandHandler<FooCommand>>().Handle(specialCommand);
container.Resolve<ICommandHandler<SpecialFooCommand>>().Handle(specialCommand);

Por cierto: la forma en que está utilizando el contenedor, aplica el anti-patrón del localizador de servicios . Esto debe evitarse.

Answer 2

Me gusta agregar un enfoque alternativo, que también funciona sin el soporte de variación de C # 4.0.

Puede crear un decorador / envoltorio especial que permita ejecutar un comando como su tipo base:

public class VarianceHandler<TSubCommand, TBaseCommand>
: ICommandHandler<TSubCommand>
where TSubCommand : TBaseCommand
{
private readonly ICommandHandler<TBaseCommand> handler;
public VarianceHandler(ICommandHandler<TBaseCommand> handler)
{
this.handler = handler;
}
public void Handle(TSubCommand command)
{
this.handler.Handle(command);
}
}

Con esto en su lugar, la siguiente línea de código le permitiría manejar SpecialFooCommand como su tipo base:

builder.Register<FooCommandHandler>()
.As<ICommandHandler<FooCommand>>();
builder.Register<VarianceHandler<SpecialFooCommand, FooCommand>>()
.As<ICommandHandler<SpecialFooCommand>>();

Tenga en cuenta que el uso de dicho VarianceHandler funciona para la mayoría de los contenedores DI.

Answer 3

No es realmente una respuesta justa, ya que extendí Autofac desde que publicaste la pregunta ... :)

Según la respuesta de Daniel, deberá agregar el modificador in al parámetro TCommand de ICommandHandler :

interface ICommandHandler<in TCommand>
{
void Handle(TCommand command);
}

Autofac 2.5.2 ahora incluye un IRegistrationSource para habilitar operaciones contravariantes Resolve() :

using Autofac.Features.Variance;
var builder = new ContainerBuilder();
builder.RegisterSource(new ContravariantRegistrationSource());

Con esta fuente registrada, los servicios representados por una interfaz genérica con un único parámetro de entrada se buscarán teniendo en cuenta las implementaciones de variantes:

builder.RegisterType<FooCommandHandler>()
.As<ICommandHandler<FooCommand>>();
var container = builder.Build();
container.Resolve<ICommandHandler<FooCommand>>();
container.Resolve<ICommandHandler<SpecialFooCommand>>();

Ambas llamadas a Resolve() recuperarán con éxito el FooCommandHandler .

Si no puede actualizarse al último paquete de Autofac, obtenga el ContravariantRegistrationSource de http://code.google.com/p/autofac/source/browse/src/Source/Autofac/Features/Variance/ContravariantRegistrationSource.cs : debería compilar contra cualquier compilación reciente de Autofac.