Fa Entity Framework ha un equivalente di DataContext.GetTable <TEntity> da Linq2Sql (ObjectContext.CreateQuery <T>?)

Question

Sto cercando un equivalente della DataContext.GetTable<TEntity> in Entity Framework. Ho trovato il metodo ObjectContext.CreateQuery<T> ma è diverso da DataContext.GetTable<TEntity> poiché ha bisogno di una querystring per funzionare.

C'è un modo per ottenere un oggetto IQueryable per una tabella utilizzando il tipo di entità senza specificare la stringa di query?

*EDIT: Added code snippet*
Questo è uno snippet di una classe di repository che ho implementato che funziona con linq2sql. Non posso usare ObjectContext.[TableName] perché non sarebbe più generico.

public class BaseRepository<TClass> : IDisposable 
     where TClass : class 
    { 
     protected BaseRepository(DataContext database) 
     { 
      _database = database; 
     } 
     ... 

     public IQueryable<TClass> GetAllEntities() 
     { 
      IQueryable<TClass> entities = _database.GetTable<TClass>(); 
      return entities; 
     } 

     public IQueryable<TClass> GetEntities(Expression<Func<TClass, bool>> condition) 
     { 
      IQueryable<TClass> table = _database.GetTable<TClass>(); 
      return table.Where(condition);  
     } 

*EDIT: Added my solution (so far..)*
questo è quello che sto usando:

public IQueryable<TClass> GetEntities(Expression<Func<TClass, bool>> condition) 
{ 
    IQueryable<TClass> table = _database.CreateQuery<TClass>(typeof(TClass).Name); 
    return table.Where(condition);  
} 

Questo funziona fino a quando il nome della classe è lo stesso del nome della tabella. Questo diventerà un problema per me quando inizierò a utilizzare oggetti diversi per lo stesso tavolo.

Spero di essere stato chiaro, grazie in anticipo,
Marco :)

Answer 1

In realtà, lo stesso progettista EF utilizza CreateQuery con stringhe hard-coded per i riferimenti statici. Se si scava nel file progettista vedrete qualcosa di simile:

public global::System.Data.Objects.ObjectQuery<Customers> Customers 
{ 
    get 
    { 
     if ((this._Customers == null)) 
     { 
      this._Customers = base.CreateQuery<Customers>("[Customers]"); 
     } 
     return this._Customers; 
    } 
} 

private global::System.Data.Objects.ObjectQuery<Customers> _Customers; 

Tecnicamente non c'è soluzione perfetta, perché si può usare lo stesso tipo di entità per i diversi insiemi di entità. Ma si può dare il vecchio collegio provare:

public IQueryable<TEntity> GetEntities<TEntity>() 
{ 
    Type t = typeof(TEntity); 
    var edmAttr = (EdmEntityTypeAttribute)Attribute.GetCustomAttribute(t, 
     typeof(EdmEntityTypeAttribute), false); 
    if (edmAttr == null) // Fall back to the naive way 
    { 
     return context.CreateQuery<TEntity>(t.Name); 
    } 
    var ec = context.MetadataWorkspace.GetEntityContainer(
     context.DefaultContainerName, DataSpace.CSpace); 
    var entityType = context.MetadataWorkspace.GetType(edmAttr.Name, 
     edmAttr.NamespaceName, DataSpace.CSpace); 
    var es = ec.BaseEntitySets.First(es => es.ElementType == entityType); 
    return context.CreateQuery<TEntity>(es.Name); 
} 

Answer 2

spero non mi manca il punto, ma non sarebbe:

ObjectContext.TableName 

Dove TableName è EntitySet del tipo con cui si desidera lavorare.

Answer 3

public IQueryable GetTable<T>(T entity) where T : class 
{ 
    return context.CreateObjectSet<T>(); 
}