【DryIOC】开放式泛型

1. 注册开放式泛型服务

注册开放式泛型服务于注册普通的泛型几乎相同。区别有以下两点：

• 不能指定静态类型
• 需要使用typeof

void Main()
{
	var container = new Container();
	container.Register(typeof(ICommand<>), typeof(DoSomethingCommand<>));

	var cmd = container.Resolve<ICommand<MyData>>();
	Console.WriteLine(cmd is DoSomethingCommand<MyData>); // True
}

interface ICommand<T> { }
class DoSomethingCommand<T> : ICommand<T> { }
struct MyData { }

其余API都是相同的。以下是一些变种。

void Main()
{
	var container = new Container();
	
	container.Register(typeof(Command<>));
	container.Register(typeof(Command<>), Reuse.Singleton);

	container.Register(typeof(ICommand<>), typeof(Command<>),
		ifAlreadyRegistered: IfAlreadyRegistered.AppendNewImplementation,
		serviceKey: "blah");

	container.Register(typeof(ICommand<>), typeof(LoggingCommand<>),
		setup: Setup.Decorator);
}

interface ICommand<T> { }
class Command<T> : ICommand<T> { }
class LoggingCommand<T> : ICommand<T> { }

对于同一个开放式泛型服务，类型确定的实现类型要优于开放式泛型类型。

void Main()
{
	var container = new Container();

	container.Register<A<int>, BInt>();
	container.Register(typeof(A<>), typeof(B<>));

	// 在解析服务实例时，注册时类型确定的实现类型要优于开放式泛型类型
	var a = container.Resolve<A<int>>();
	Console.WriteLine(a is BInt);      // True

	// 集合方式解析，将获取所有A<int>型的实现类型
	container.Resolve<A<int>[]>().Dump();
}

class A<T> { }
class BInt : A<int> { }
class B<T> : A<T> { }

2. 匹配泛型参数的约束

DryIOC在解析服务实例时将评估类型参数的约束。

2.1 通过约束过滤服务

void Main()
{
	var container = new Container();
	container.RegisterMany(new[] { typeof(A<>), typeof(B<>)}, nonPublicServiceTypes: true);

	// 由于A中指定了类型参数的约束为实现IDisposable接口
	// 下面的解析指定了类型参数为string，因此只能获取B<string>
	container.Resolve<I<string>[]>().Dump();
}

interface I<T> { }
class A<T> : I<T> where T : IDisposable { }
class B<T> : I<T> { }

2.2 通过约束填充类型参数

void Main()
{
	var container = new Container();
	container.Register(typeof(ICommandHandler<>), typeof(UpdateCommandHandler<,>));

	var handler = container.Resolve<ICommandHandler<UpdateCommand<MyEntity>>>();

	Console.WriteLine(handler is UpdateCommandHandler<MyEntity, UpdateCommand<MyEntity>>); // True
}

public interface ICommandHandler<TCommand> { }
public class SpecialEntity { }
public class UpdateCommand<TEntity> { }

public class UpdateCommandHandler<TEntity, TCommand> : ICommandHandler<TCommand>
	where TEntity : SpecialEntity
	where TCommand : UpdateCommand<TEntity>
{ }

public class MyEntity : SpecialEntity { }

3. 泛型协变

默认情况下，针对开放式泛型的获取，DryIOC支持泛型协变。

void Main()
{
	var container = new Container();
    container.Register<IHandler<A>, AHandler>();
    container.Register<IHandler<B>, BHandler>();

    container.ResolveMany<IHandler<A>>().Dump("IHandler<A>");
	container.ResolveMany<IHandler<B>>().Dump("IHandler<B>");
}

public interface IHandler<out TEvent> { }
public class A { }
public class B : A { }
public class AHandler : IHandler<A> { }
public class BHandler : IHandler<B> { }

如果取消默认行为？

void Main()
{
	var container = new Container(rules => rules.WithoutVariantGenericTypesInResolvedCollection());
	container.Register<IHandler<A>, AHandler>();
    container.Register<IHandler<B>, BHandler>();

    container.ResolveMany<IHandler<A>>().Dump("IHandler<A>");
	container.ResolveMany<IHandler<B>>().Dump("IHandler<B>");
}

public interface IHandler<out TEvent> { }
public class A { }
public class B : A { }
public class AHandler : IHandler<A> { }
public class BHandler : IHandler<B> { }