c#-Castle-没有支持服务的组件-使用泛型参数流畅地注册和解析泛型

如果我使用一个接一个的组件注册，所有问题都可以解决。。我的问题是注册流畅，有什么想法吗

范例

public class MyFilter:Filter {}

public class MyEntity:Entity {}

public class ReadCommandHandler<TEntity,TFilter> : ICommandHandler<IReadCommand<TFilter>, IEnumerable<TEntity>> where TEntity : Entity where TFilter : Filter 

公共类MyFilter:Filter{}
公共类MyEntity:实体{}
公共类ReadCommandHandler:ICommandHandler where tenty:Entity where TFilter:Filter

安装工

container.Register(Types.FromThisAssembly().BasedOn(typeof(ICommandHandler<,>)).WithService.AllInterfaces());

container.Register（Types.fromthissembly（）.BasedOn（typeof（ICommandHandler））.WithService.AllInterfaces（））；

这将导致（调试器视图）

ReadCommandHandler/ICommandHandler

看来没问题。。但是如果我试过这个

var biz = container.Resolve(typeof(ICommandHandler<IReadCommand<MyFilter>,IEnumerable<MyEntity>>))

var biz=container.Resolve（typeof（ICommandHandler））

还是这个

var biz = container.Resolve(typeof(ICommandHandler<IReadCommand<Filter>,IEnumerable<Entity>>))

var biz=container.Resolve（typeof（ICommandHandler））

结果是“没有支持服务的组件”

---

这是怎么回事？

好的。。作为一种可能的方法，我用IGenericImplementationMatchingStrategy“解决”了这个问题

设置和解决：

var container = new WindsorContainer();

container.Register(
        Types.FromAssemblyContaining(typeof(ReadCommandHandler<,>)).BasedOn(typeof(ICommandHandler<,>))
        .If(p => !p.IsInterface)
        .WithServiceBase()
.Configure(
            c => c.ExtendedProperties(
                Property.ForKey(Castle.Core.Internal.Constants.GenericImplementationMatchingStrategy)
                    .Eq(new GenericImplementationMatchingStrategy()))));




var biz = container.Resolve(typeof(ICommandHandler<IReadCommand<MyFilter>, IEnumerable<MyEntity>>));

var容器=新的WindsorContainer（）；
集装箱。登记(
Types.FromAssemblyContaining（typeof（ReadCommandHandler））.BasedOn（typeof（ICommandHandler））
.If（p=>！p.IsInterface）
.WithServiceBase（）
.配置(
c=>c.ExtendedProperties(
ForKey（Castle.Core.Internal.Constants.GenericImplementationMatchingStrategy）
.Eq（新的通用实现匹配策略（））；
var biz=container.Resolve（typeof（ICommandHandler））；

通用战略实施

public class GenericImplementationMatchingStrategy : IGenericImplementationMatchingStrategy
{
    public static ConcurrentDictionary<string, Type[]> dicStrategyCommandHandler = new ConcurrentDictionary<string, Type[]>();
    public Type[] GetGenericArguments(ComponentModel model, CreationContext context)
    {
        return dicStrategyCommandHandler.GetOrAdd(context.RequestedType.FullName, (key) =>
            {

                if (context.RequestedType.GetGenericTypeDefinition() == typeof(ICommandHandler<,>))
                {
                    var service = model.Implementation.GetInterfaces().Where(p => { return p.Name == context.RequestedType.Name; }).FirstOrDefault(); //  model.Implementation.GetInterfaces()[0];
                    if (service != null)
                    {
                        List<Type> types = new List<Type>();
                        foreach (var item in model.Implementation.GetGenericArguments())
                        {
                            var name = item.Name;
                            var type = serviceGetType(name, service, context.RequestedType);
                            types.Add(type);

                        }
                        return types.ToArray();
                    }
                }
                return null;
            }
            );
    }

    private Type serviceGetType(string name, Type service, Type requestedType)
    {
        var args = service.GetGenericArguments().ToArray();
        var argsRequested = requestedType.GetGenericArguments().ToArray();
        for (int i=0;i<args.Count();i++ )
        {
            Type itemDecla = args[i];
            Type itemRequested = argsRequested[i];
            if (itemDecla.Name == name)
                return itemRequested;
            else
            {
                var recur = serviceGetType(name, itemDecla, itemRequested);
                if (recur != null) return recur;
            }
        }
        return null;
    }
}

公共类GenericImplementMatchingStrategy:IGenericImplementMatchingStrategy
{
公共静态ConcurrentDictionary dicStrategyCommandHandler=新ConcurrentDictionary（）；
公共类型[]GetGenericArguments（组件模型、CreationContext上下文）
{
返回dicStrategyCommandHandler.GetOrAdd（context.RequestedType.FullName，（key）=>
{
if（context.RequestedType.GetGenericTypeDefinition（）==typeof（ICommandHandler））
{
var service=model.Implementation.GetInterfaces（）.Where（p=>{return p.Name==context.RequestedType.Name；}）.FirstOrDefault（）；//model.Implementation.GetInterfaces（）[0]；
if（服务！=null）
{
列表类型=新列表（）；
foreach（model.Implementation.GetGenericArguments（）中的var项）
{
var name=item.name；
var type=serviceGetType（名称、服务、上下文.RequestedType）；
类型。添加（类型）；
}
返回类型。ToArray（）；
}
}
返回null；
}
);
}
私有类型serviceGetType（字符串名称、类型服务、类型requestedType）
{
var args=service.GetGenericArguments（）.ToArray（）；
var argsRequested=requestedType.GetGenericArguments（）.ToArray（）；
对于（int i=0；i