¿Tiene el marco de la entidad tiene un equivalente de DataContext.GetTable <TEntity> de Linq2Sql (ObjectContext.CreateQuery <T>?)

Question

Busco un equivalente de la DataContext.GetTable<TEntity> en Entity Framework. He encontrado el método ObjectContext.CreateQuery<T> pero es diferente de DataContext.GetTable<TEntity> ya que necesita una cadena de consulta para funcionar.

¿Hay alguna forma de obtener un objeto IQueryable para una tabla utilizando el tipo de entidad sin especificar la cadena de consulta?

*EDIT: Added code snippet*
Este es un fragmento de una clase repositorio he aplicado que trabaja con linq2sql. No puedo usar ObjectContext.[TableName] porque ya no sería genérico.

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..)*
Esto es lo que estoy usando:

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

Esto funciona siempre y cuando el nombre de la clase es el mismo del nombre de la tabla. Esto se convertirá en un problema para mí cuando empiece a usar diferentes objetos para la misma tabla.

espero haber sido claro, gracias de antemano,
Marco :)

Answer 1

En realidad, el propio diseñador de EF usa CreateQuery con cadenas codificadas para las referencias estáticas. Si se mira en el archivo del diseñador verá algo como esto:

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; 

Técnicamente no hay una solución perfecta porque se puede utilizar el mismo tipo de entidad para diferentes conjuntos de entidades. Sin embargo, se puede dar el viejo intento de la universidad:

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

espero que no me falta el punto, pero ¿no sería:

ObjectContext.TableName 

Dónde TableName es EntitySet del tipo con el que desea trabajar.

Answer 3

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