제네릭에 인터페이스를 동적으로 배치하는 방법은 무엇입니까?

Question

나는 다음과 같은 테스트 클래스가 있습니다

public class OutsideClass 
{ 
    private List<Type> _interfaces = null; 

    public void InjectInterfaces(Type[] types) 
    { 
     if(_interfaces == null) 
     { 
      _interfaces = new List<Type>(); 
     } 

     foreach (var type in types) 
     { 
      if(type.IsInterface) 
      { 
       _interfaces.Add(type); 
      } 
     } 
    } 

    public void PerformSomethingWithTheInterfaces() 
    { 
     foreach (var i in _interfaces) 
     { 
      new Test<i>().PerformSomething(); // On this line the error occurs 
     } 
    } 
} 

internal class Test<T> 
{ 
    internal void PerformSomething() 
    { 

    } 
} 

이 그러나 메시지 Type or namespace name expected 날에 제공합니다. 어떻게 작동하도록이 코드를 조정할 수 있습니까?

내가 뭘하려는 건 클래스 라이브러리에 인터페이스의 무리를 통과하고 거기에 유니티을 사용하여 인터페이스를 기반으로 해결합니다. Resolve Extension 메서드를 사용합니다.

Answer 1

일반 인수로 값을 전달할 수 없습니다. 유형 만. 명확하게하려면 :

typeof (string)! = string.

Answer 2

나는 이것이 작동하지 않는다고 생각합니다. 유형 이름에 제네릭을 정적으로 적용 할 수 있습니다. Type 개체에 대한 참조를 전달할 수 없습니다.

원하는 작업을 수행 할 수있는 방법이 있지만 C# 4 및 DynamicObject이 있습니다.

Answer 3

당신은 반사를 사용해야 할 것 ... 이런 일이 :

foreach (Type type in _interfaces) 
{ 
    Type concreteType = typeof(Test<>).MakeGenericType(new Type[] { type }); 
    MethodInfo method = concreteType.GetMethod("PerformSomething", 
     BindingFlags.Instance | BindingFlags.NonPublic); 
    object instance = Activator.CreateInstance(concreteType); 
    method.Invoke(instance, null); 
} 

(당신은 사소한 변경해야 할 수도 있습니다 - 위의 테스트 또는 컴파일되지 않습니다.)

으로 C# 4 및 동적 입력, 당신은 다소 간단하게 만들 수 있습니다

foreach (Type type in _interfaces) 
{ 
    Type concreteType = typeof(Test<>).MakeGenericType(new Type[] { type }); 
    dynamic d = Activator.CreateInstance(concreteType); 
    d.PerformSomething(); 
} 

Answer 4

당신은 정말 그냥 유니티 교체로 생각 나는 그것이 정말 잘 자신과 simplif 버틴다 생각하는 C# 4의 MEF에서 볼 수도 있습니다 해결 방법이 많아서 더 간단하게하려는 작업을 완료 할 수있는 기능을 제공 할 수 있습니다.

namespace MEF_Interface 
{ 
    // Interface to recognize the concrete implementation as 
    public interface IMessageWriter 
    { 
     void WriteMessage(); 
    } 

} 

namespace MEF_HelloMessageWriter 
{ 
    // Concrete implementation in another assembly 
    [Export(typeof(IMessageWriter))] 
    public class HelloMessageWriter : IMessageWriter 
    { 
     public void WriteMessage() { Console.WriteLine("Hello!"); } 
    } 
} 

namespace MEF_GoodbyeMessageWriter 
{ 
    // Concrete implementation in another assembly 
    [Export(typeof(IMessageWriter))] 
    public class GoodbyeMessageWriter : IMessageWriter 
    { 
     public void WriteMessage() { Console.WriteLine("Goodbye!"); } 
    } 
} 

namespace MEF_Example 
{ 
    class DIContainer 
    { 
     [Import] 
     public IMessageWriter MessageWriter { get; set; } 

     public DIContainer(string directory) 
     { 
      // No more messy XML DI definition, just a catalog that loads 
      // all exports in a specified directory. Filtering is also available. 
      DirectoryCatalog catalog = new DirectoryCatalog(directory); 
      catalog.Refresh(); 
      var container = new CompositionContainer(catalog); 
      container.ComposeParts(this); 
     } 
    } 

    class Program 
    { 

     static void Main(string[] args) 
     { 
      string helloMessageWriterPath = 
       @"C:\shared\Projects\MEF_Example\MEF_HelloMessageWriter\bin\Debug"; 

      string goodbyeMessageWriterPath = 
       @"C:\shared\Projects\MEF_Example\MEF_GoodbyeMessageWriter\bin\Debug"; 

      DIContainer diHelloContainer = new DIContainer(helloMessageWriterPath); 
      diHelloContainer.MessageWriter.WriteMessage(); 

      DIContainer diGoodbyeContainer = new DIContainer(goodbyeMessageWriterPath); 
      diGoodbyeContainer.MessageWriter.WriteMessage(); 

      Console.ReadLine(); 
     } 
    } 
}