Возвращаемые типы классов, реализующие общий интерфейс

Question

SomeRepository тип не возвращается GetPublicClassesFromApplicationAssembly. Я хочу, чтобы все типы классов расширяли IRepository. Может ли кто-нибудь увидеть проблему?

private Type[] GetPublicClassesFromApplicationAssembly() 
    { 
     return typeof (SomeRepository).Assembly.GetExportedTypes() 
      .Where(t => t.IsClass) 
      .Where(t => t.IsAbstract == false) 
      .Where(r => r.IsAssignableFrom(typeof(IRepository<>))) 
      .OrderBy(t => t.Name) 
      .ToArray(); 
    } 

    public class SomeRepository : IRepository<SomeDomainClass> {} 

    public interface IRepository<T> where T : PrimaryKeyBase {} 

    public class SomeDomainClass: PrimaryKeyBase {} 

Answer 1

SomeRepository не назначаемый из IRepository<>, который не является "реальным" тип; он присваивается от IRepository<SomeDomainClass>. Вы должны использовать GetInterface вместо IsAssignableFrom:

 .Where(r => r.GetInterface("IRepository`1") != null 

Answer 2

В случае его полезно, вот рутина, я написал для той же цели:

использовать его как это

.Where(r => r.IsDerivedFrom(typeof(IRepository<>))) 

А вот это is

public static bool IsDerivedFrom(this Type type, Type inter) 
    { 
     if (type.IsSubclassOf(inter)) 
      return true; 
     if (IsDerivedFromImp(type, inter)) 
      return true; 
     foreach (var i in type.GetInterfaces()) 
     { 
      if (IsDerivedFromImp(i, inter)) 
       return true; 
     } 
     return false; 
    } 

    /// <summary> 
    /// type A is equivalent to B if 
    /// 1. They are they same type, AND 
    /// 2. Their generic arguments match 
    /// </summary> 
    /// <param name="iLhs"></param> 
    /// <param name="iRhs"></param> 
    /// <returns></returns> 
    private static bool IsDerivedFromImp(Type iLhs, Type iRhs) 
    { 
     if (iLhs == iRhs) 
     { 
      return true; 
     } 
     if (iLhs.IsGenericType && iRhs.IsGenericType) 
     { 
      iRhs.GetGenericArguments(); 
      if (iLhs.GetGenericTypeDefinition() != iRhs.GetGenericTypeDefinition()) 
      { 
       return false; 
      } 
      // Generic arguments must be match 
      var lhsArgs = iLhs.GetGenericArguments(); 
      var rhsArgs = iRhs.GetGenericArguments(); 
      for (int x = 0; x < rhsArgs.Length; x++) 
      { 
       // ie IList<> is derived from IList<>, is true 
       if (lhsArgs[x].IsGenericParameter && rhsArgs[x].IsGenericParameter) 
       { 
        continue; 
       } 
       // ie IList<string> is derived from IList<>, is true 
       if (!lhsArgs[x].IsGenericParameter && rhsArgs[x].IsGenericParameter) 
       { 
        continue; 
       } 
       // ie IList<> is derived from IList<string>, is false 
       if (lhsArgs[x].IsGenericParameter && !rhsArgs[x].IsGenericParameter) 
       { 
        return false; 
       } 
       // ie IDo<string> is derived from IDo<int>, is false 
       if (lhsArgs[x] != rhsArgs[x]) 
       { 
        return false; 
       } 
      } 
      return true; 
     } 
     return false; 
    }