Entity Framework ont ​​un équivalent de DataContext.GetTable <TEntity> de Linq2Sql (ObjectContext.CreateQuery <T>?)

Question

Je suis à la recherche d'un équivalent du DataContext.GetTable<TEntity> dans Entity Framework. J'ai trouvé la méthode ObjectContext.CreateQuery<T> mais elle est différente de DataContext.GetTable<TEntity> puisqu'elle a besoin d'une chaîne de requête pour fonctionner.

Existe-t-il un moyen d'obtenir un objet IQueryable pour une table en utilisant le type d'entité sans spécifier la chaîne de requête?

*EDIT: Added code snippet*
Ceci est un extrait d'une classe Repository que j'ai implémentée qui fonctionne avec linq2sql. Je ne peux pas utiliser ObjectContext.[TableName] car ce ne serait plus générique.

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..)*
C'est ce que j'utilise:

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

Cela fonctionne aussi longtemps que le nom de classe est le même du nom de la table. Cela deviendra un problème pour moi lorsque je commencerai à utiliser différents objets pour la même table.

J'espère que je suis clair, merci à l'avance,
Marco :)

Answer 1

En fait, le concepteur EF utilise lui-même CreateQuery avec des chaînes codées en dur pour les références statiques. Si vous creusez dans le fichier de concepteur, vous verrez quelque chose comme ceci:

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; 

Techniquement, il n'y a pas de solution parfaite, car vous pouvez utiliser le même type d'entité pour les jeux d'entités différentes. Mais vous pouvez lui donner l'ancien essai de collège:

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

J'espère que je ne manque point, mais serait-il pas:

ObjectContext.TableName 

Où TableName est l'EntitySet du type avec lequel vous voulez travailler.

Answer 3

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