내 엔티티 클래스의 일부 인터페이스를 구현 한

Question

인터페이스를 구현하는 모든 테이블을 조회하는 방법 :

public partial class Order : IReportable 
{ 
    public string TableName { get { return "Order"; } } 
} 

public partial class Client: IReportable 
{ 
public string TableName { get { return "Client"; } } 
} 


public interface IReportable 
{ 
    string TableName { get; } 
} 

그런 다음 나는 DbContext이 추가 :

public virtual DbSet<IReportable> IReportable { get; set; } 

I가 때를 여기에 표시된대로이 인터페이스를 구현하는 모든 테이블을 쿼리하십시오.

var result = from reportabletable in db.IReportable 
      where reportabletable.TableName == table_name 
      select reportabletable 

다음 예외가 발생합니다.

'Report.DataAccess.IReportable'유형이 매핑되지 않았습니다. 또는 NoMappedAttribute 데이터 주석 무시 방법을 사용하여 형식을 명시 적으로 제외하지 않았는지 확인하십시오. 형식이 이 클래스로 정의되었는지, 프리미티브가 아니거나 generic인지, 그리고 EntityObject에서 을 상속받지 않았는지 확인하십시오.

Answer 1

:

이 확장 방법

public static class DbContextExtensions 
{ 
    public static IEnumerable<T> SetOf<T>(this DbContext dbContext) where T : class 
    { 
     return dbContext.GetType().Assembly.GetTypes() 
      .Where(type => typeof(T).IsAssignableFrom(type) && !type.IsInterface) 
      .SelectMany(t => Enumerable.Cast<T>(dbContext.Set(t))); 
    } 
} 

를 작성하고 다음과 같이 사용 : 모든

using (var db = new dbEntities()) 
{ 
var result = from reportabletable in db.SetOf<IReportable>() 
     where reportabletable.TableName == table_name 
     select reportabletable 
} 

Answer 2

EF는 인터페이스를 테이블에 직접 매핑하는 것을 좋아하지 않습니다. Here!

그런 다음 리포지토리 방법을 사용하고 쿼리 할 테이블의 형식을 제공하면 일반 리포지토리를 사용하여이 문제를 해결할 수 있습니다. 같은 뭔가 : myRepo.GetAll<myClient.GetType()>();

해당 인터페이스를 상속하는 클래스를 얻고 그들 모두에 대한 쿼리를 실행 :

var types = System.Reflection.Assembly.GetExecutingAssembly().GetTypes().Where(mytype => mytype .GetInterfaces().Contains(typeof(myInterface))); 
foreach (var mytype in types) 
{ // aggregate query results } 

희망이 도움이! 더 우아한 해결책은 아마이

이 같은 뭔가를 갈 것

Answer 3

우선 MarcGravell 코멘트는 돈에있다. 쿼리 할 테이블을 아는 것이 좋습니다. 개인적으로 나는 인터페이스를 구현하거나 사용자 정의 속성이있는 poco 유형 목록을 살펴 봅니다. 그러나 DBContext를 통해서만 이동하고자하는 경우, 여기에 "이름"에 대한 액세스를 제공하는 확장이 있습니다. 나중에 한 번에 하나씩 컨텍스트의 해당 부분에 액세스해야합니다.

다시 한 번 제네릭을 사용하여 수행 할 수 있지만 직접 제안하면됩니다.
형식 목록을 반복해야합니다. 예 :

ReportRespository : t BaseRespository : iReport로

확인 특정 유형의 조립 및 예를 들어

 /// <summary> 
    /// POCOs that have XYZ Attribute of Type and NOT abstract and not complex 
    /// </summary> 
    /// <returns></returns> 
    public static List<Type> GetBosDirDBPocoList() { 
     var result = new List<Type>(); 
     // so get all the Class from teh assembly that public non abstract and not complex 
     foreach (var t in Assembly.GetExecutingAssembly().GetTypes() 
            .Where(t => t.BaseType != null 
               && t.IsClass 
               && t.IsPublic 
               && !t.IsAbstract 
               && !t.IsComplexType() 
               && t.GetMyAttribute() != null)) { 


       result.Add(t); 
      } 
     } 
     return result; 
    } 

    public static GetMyAttribute(this Type T) { 
     var myAttr= T.GetCustomAttributes(true) 
         .Where(attribute => attribute.GetType() 
         .Name == "XYZAttr").Cast<BosDir>().FirstOrDefault(); 

     return myAttr; 
    } 

확장 속성

public static class DalExtensions { 
    // DbSet Names is the plural property name in the context 
    public static List<string> GetModelNames(this DbContext context) { 
     var propList = context.GetType().GetProperties(); 
     return GetDbSetNames(propList); 
    } 

    // DbSet Names is the plural property name in the context 
    public static List<string> GetDbSetTypeNames<T>() where T : DbContext { 
     var propList = typeof (T).GetProperties(); 
     return GetDbSetNames(propList); 
    } 

    // DBSet Types is the Generic Types POCO name used for a DBSet 
    public static List<string> GetModelTypes(this DbContext context) { 
     var propList = context.GetType().GetProperties(); 
     return GetDbSetTypes(propList); 
    } 

    // DBSet Types POCO types as IEnumerable List 
    public static IEnumerable<Type> GetDbSetPropertyList<T>() where T : DbContext { 
     return typeof (T).GetProperties().Where(p => p.PropertyType.GetTypeInfo() 
                 .Name.StartsWith("DbSet")) 
         .Select(propertyInfo => propertyInfo.PropertyType.GetGenericArguments()[0]).ToList(); 
    } 

    // DBSet Types is the Generic Types POCO name used for a DBSet 
    public static List<string> GetDbSetTypes<T>() where T : DbContext { 
     var propList = typeof (T).GetProperties(); 
     return GetDbSetTypes(propList); 
    } 


    private static List<string> GetDbSetTypes(IEnumerable<PropertyInfo> propList) { 
     var modelTypeNames = propList.Where(p => p.PropertyType.GetTypeInfo().Name.StartsWith("DbSet")) 
            .Select(p => p.PropertyType.GenericTypeArguments[0].Name) 
            .ToList(); 
     return modelTypeNames; 
    } 

    private static List<string> GetDbSetNames(IEnumerable<PropertyInfo> propList) { 
     var modelNames = propList.Where(p => p.PropertyType.GetTypeInfo().Name.StartsWith("DbSet")) 
           .Select(p => p.Name) 
           .ToList(); 

     return modelNames; 
    } 
} 

,

}