Castle Windsor enregistrement des types de décorateurs génériques ouverts

Question

J'essaie de comprendre comment enregistrer les décorateurs pour les types génériques avec 2 paramètres génériques. Le premier cas de test ci-dessous est juste une vérification de santé pour un cas de paramètre générique que j'ai ajouté lorsque le cas à deux paramètres ne fonctionnait pas comme prévu. Le troisième cas (défaillant) avec un paramètre 1-générique (contravariant cette fois) semble indiquer que Windsor traite différemment les paramètres génériques co- et contravariants, alors ma question est: Qu'est-ce que je fais de mal ici? J'utilise .NET 4.0.

[Test] 
    public void RepoSingleGenericTest() 
    { 
     var windsorContainer = new Castle.Windsor.WindsorContainer(); 

     windsorContainer 
      .Register(AllTypes.Of(typeof(IRepoSingle<>)) 
      .FromAssembly(typeof(StringRepoSingle).Assembly) 
      .If(t => typeof(CachingRepoSingle<>).IsAssignableFrom(t)) 
      .WithService.FromInterface(typeof(IRepoSingle<>))); 

     windsorContainer 
      .Register(AllTypes.Of(typeof(IRepoSingle<>)) 
      .FromAssembly(typeof(BoolRepoSingle).Assembly) 
      .Unless(t => typeof(CachingRepoSingle<>).IsAssignableFrom(t)) 
      .WithService.FromInterface(typeof(IRepoSingle<>))); 

     var stringRepo = windsorContainer.Resolve<IRepoSingle<string>>(); 
     Assert.IsInstanceOf<StringRepoSingle>(stringRepo); 

     var boolRepo = windsorContainer.Resolve<IRepoSingle<bool>>(); 
     Assert.IsInstanceOf<BoolRepoSingle>(boolRepo); 
    } 

    [Test] 
    public void RepoDoublyGenericTest() 
    { 
     var windsorContainer = new Castle.Windsor.WindsorContainer(); 

     windsorContainer 
      .Register(AllTypes.Of(typeof(IRepoDoublyGeneric<,>)) 
      .FromAssembly(typeof(StringRepoDoublyGeneric).Assembly) 
      .If(t => typeof(CachingRepoDoublyGeneric<,>).IsAssignableFrom(t)) 
      .WithService.FromInterface(typeof(IRepoDoublyGeneric<,>))); 

     windsorContainer 
      .Register(AllTypes.Of(typeof(IRepoDoublyGeneric<,>)) 
      .FromAssembly(typeof(DateTimeRepoDoublyGeneric).Assembly) 
      .Unless(t => typeof(CachingRepoDoublyGeneric<,>).IsAssignableFrom(t)) 
      .WithService.FromInterface(typeof(IRepoDoublyGeneric<,>))); 

     var stringRepo = windsorContainer.Resolve<IRepoDoublyGeneric<Guid, string>>(); 
     Assert.IsInstanceOf<CachingRepoDoublyGeneric<Guid, string>>(stringRepo); 

     var dateTimeRepo = windsorContainer.Resolve<IRepoDoublyGeneric<Guid, DateTime>>(); 
     Assert.IsInstanceOf<CachingRepoDoublyGeneric<Guid, DateTime>>(dateTimeRepo); 
    } 

    [Test] 
    public void CommandTest() 
    { 
     var windsorContainer = new Castle.Windsor.WindsorContainer(); 

     windsorContainer 
      .Register(AllTypes.Of(typeof(ICommand<>)) 
      .FromAssembly(typeof(GuidCommand).Assembly) 
      .If(t => typeof(DecoratorCommand<>).IsAssignableFrom(t)) 
      .WithService.FromInterface(typeof(ICommand<>))); 

     windsorContainer 
      .Register(AllTypes.Of(typeof(ICommand<>)) 
      .FromAssembly(typeof(StringCommand).Assembly) 
      .Unless(t => typeof(DecoratorCommand<>).IsAssignableFrom(t)) 
      .WithService.FromInterface(typeof(ICommand<>))); 

     var stringComand = windsorContainer.Resolve<ICommand<string>>(); 
     Assert.IsInstanceOf<DecoratorCommand<string>>(stringComand); 

     var guidCommand = windsorContainer.Resolve<ICommand<Guid>>(); 
     Assert.IsInstanceOf<DecoratorCommand<Guid>>(guidCommand); 
    } 

    public interface IRepoSingle<out TValue> 
    { 
     TValue Get(); 
    } 

    public class StringRepoSingle : IRepoSingle<string> 
    { 
     public string Get() 
     { 
      throw new NotImplementedException(); 
     } 
    } 

    public class BoolRepoSingle : IRepoSingle<bool> 
    { 
     public bool Get() 
     { 
      throw new NotImplementedException(); 
     } 
    } 

    public class CachingRepoSingle<T> : IRepoSingle<T> 
    { 
     private readonly IRepoSingle<T> realRepo; 

     public CachingRepoSingle(IRepoSingle<T> realRepo) 
     { 
      if (realRepo == null) throw new ArgumentNullException("realRepo"); 

      this.realRepo = realRepo; 
     } 

     public T Get() 
     { 
      throw new NotImplementedException(); 
     } 
    } 

    public interface IRepoDoublyGeneric<in TKey, out TValue> 
    { 
     TValue Get(TKey key); 
    } 

    public class StringRepoDoublyGeneric : IRepoDoublyGeneric<Guid, string> 
    { 
     public string Get(Guid key) 
     { 
      throw new NotImplementedException(); 
     } 
    } 

    public class DateTimeRepoDoublyGeneric : IRepoDoublyGeneric<Guid, DateTime> 
    { 
     public DateTime Get(Guid key) 
     { 
      throw new NotImplementedException(); 
     } 
    } 

    public class CachingRepoDoublyGeneric<TKey, TValue> : IRepoDoublyGeneric<TKey, TValue> 
    { 
     private readonly IRepoDoublyGeneric<TKey, TValue> realRepo; 

     public CachingRepoDoublyGeneric(IRepoDoublyGeneric<TKey, TValue> realRepo) 
     { 
      if (realRepo == null) throw new ArgumentNullException("realRepo"); 

      this.realRepo = realRepo; 
     } 

     public TValue Get(TKey key) 
     { 
      throw new NotImplementedException(); 
     } 
    } 

    public interface ICommand<in T> 
    { 
     void Do(T t); 
    } 

    public class StringCommand : ICommand<string> 
    { 
     public void Do(string t) 
     { 
      throw new NotImplementedException(); 
     } 
    } 

    public class GuidCommand : ICommand<Guid> 
    { 
     public void Do(Guid t) 
     { 
      throw new NotImplementedException(); 
     } 
    } 

    public class DecoratorCommand<T> : ICommand<T> 
    { 
     private readonly ICommand<T> realComamnd; 

     public DecoratorCommand(ICommand<T> realComamnd) 
     { 
      if (realComamnd == null) throw new ArgumentNullException("realComamnd"); 

      this.realComamnd = realComamnd; 
     } 

     public void Do(T t) 
     { 
      throw new NotImplementedException(); 
     } 
    } 

MISE À JOUR: Voici le tour est joué, mais je ne peux pas dire que je pense qu'il est la solution la plus élégante ...:

 [Test] 
    public void RepoDoublyGenericWithReflection() 
    { 
     var windsorContainer = new Castle.Windsor.WindsorContainer(); 

     // Register components for a caching decorator for all types implementing IRepoDoublyGeneric<,> - except for the generic cache itself 
     (from t in typeof (DateTimeRepoDoublyGeneric).Assembly.GetTypes() 
      let iRepo = t.GetInterfaces().SingleOrDefault(i => i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IRepoDoublyGeneric<,>)) 
      where 
       t.IsClass && !t.IsAbstract && !typeof(CachingRepoDoublyGeneric<,>).IsAssignableFrom(t) 
       && iRepo != null 
      select iRepo) 
     .ForEach(rt => 
      windsorContainer.Register(Component.For(rt).ImplementedBy((typeof(CachingRepoDoublyGeneric<,>)).MakeGenericType(rt.GetGenericArguments()))) 
     ); 

     // Real repositories 
     windsorContainer.Register(
      AllTypes.Of(typeof(IRepoDoublyGeneric<,>)) 
      .FromAssembly(typeof(DateTimeRepoDoublyGeneric).Assembly) 
      .Unless(t => typeof(CachingRepoDoublyGeneric<,>).IsAssignableFrom(t)) 
      .WithService.FromInterface(typeof(IRepoDoublyGeneric<,>)) 
     ); 

     var stringRepo = windsorContainer.Resolve<IRepoDoublyGeneric<Guid, string>>(); 
     Assert.IsInstanceOf<CachingRepoDoublyGeneric<Guid, string>>(stringRepo); 

     var dateTimeRepo = windsorContainer.Resolve<IRepoDoublyGeneric<Guid, DateTime>>(); 
     Assert.IsInstanceOf<CachingRepoDoublyGeneric<Guid, DateTime>>(dateTimeRepo); 
    } 

Selon les suggestions de Krzysztof, j'ai aussi essayé:

 [Test] 
    public void CommandTestUsingBasedOn() 
    { 
     var windsorContainer = new Castle.Windsor.WindsorContainer(); 

     windsorContainer 
      .Register(AllTypes.Of(typeof(ICommand<>)) 
      .FromAssembly(typeof(GuidCommand).Assembly) 
      .If(t => typeof(DecoratorCommand<>).IsAssignableFrom(t)) 
      .BasedOn(typeof(ICommand<>)) 
      .WithService.Base()); 

     windsorContainer 
      .Register(AllTypes.Of(typeof(ICommand<>)) 
      .FromAssembly(typeof(StringCommand).Assembly) 
      .Unless(t => typeof(DecoratorCommand<>).IsAssignableFrom(t)) 
      .BasedOn(typeof(ICommand<>)) 
      .WithService.Base()); 

     var stringComand = windsorContainer.Resolve<ICommand<string>>(); 
     Assert.IsInstanceOf<DecoratorCommand<string>>(stringComand); 

     var guidCommand = windsorContainer.Resolve<ICommand<Guid>>(); 
     Assert.IsInstanceOf<DecoratorCommand<Guid>>(guidCommand); 
    } 

• mais cela ne change pas le comportement.

Answer 1

Fonctionne-t-il lorsque vous l'enregistrez en tant que AllTypes.BasedOn(typeof(typeof(ICommand<>)) et WithService.Base()?