EntityFramework Obtenez de l'objet par ID?

Vous pouvez définir l'interface implémentée par tous vos entités:

public interface IEntity
{
    int Id { get; }
}

et la méthode pour récupérer votre entité:

public T GetObjectById<T>(int id) where T : class, IEntity
{
    return context.CreateObjectSet<T>().SingleOrDefault(e => e.Id == id);
}

Vous pouvez également utiliser démarche similaire à celui fourni dans le lié à la question. Vous avez juste à utiliser une autre méthode pour obtenir votre entité:

public virtual T GetByKey<T>(int id) where T : class, IEntity
{
     string containerName = context.DefaultContainerName;
     string setName = context.CreateObjectSet<T>().EntitySet.Name;
     //Build entity key
     var entityKey = new EntityKey(containerName + "." + setName, "Id", id);
     return (TEntity)Context.GetObjectByKey(entityKey);         
}

La différence est que la première méthode de toujours interroger la base de données, même si vous avez déjà chargé l'instance du contexte alors que la deuxième approche vérifie d'abord si l'instance est déjà chargé. La méthode n'est pas efficace, parce qu'il construit ces noms de plus de et plus. Ici est l'approche plus générale qui peut fonctionner avec n'importe quel type de clé et le nom et ici est une approche complexe clés.

Ni de cette méthode directement travaille avec l'héritage - vous devez indiquer le type de base pour le faire fonctionner.

Il est difficile d'avoir une solution générique, car elles peuvent avoir des clés composites, mais cela fonctionne pour une simple et unique-clés.

La clé est de restreindre T pour être de type System.Data.Objects.DataClasses.EntityObject, qui a alors que EntityKey de la propriété (ce qui représente la clé primaire).

static T GetById<T>(object id) where T : EntityObject
{
    using (var context = new MyEntities())
    {
        return context.CreateObjectSet<T>()
            .SingleOrDefault(t => t.EntityKey.EntityKeyValues[0].Value == id);
    }
}

Une autre façon d'obtenir de l'entité à partir de l'id sur entitiy cadre

public T Get<T>(int id) where T : EntityObject;
{
var ObjectSet = _context.CreateObjectSet<T>();
var PropName = ObjectSet.EntitySet.ElementType.KeyMembers[0].ToString();
return  ObjectSet.Where("it." + PropName + "=" + id).FirstOrDefault();
}

Résultat

SELECT TOP (1) 
[Extent1].[CatId] AS [CatId], 
[Extent1].[CatName] AS [CatName], 
[Extent1].[CatType] AS [CatType],  
FROM [dbo].[Categories] AS [Extent1]
WHERE [Extent1].[CatId] = 1

Une chose que j'ai fait qui a travaillé à définir un "KeyComparator" interface:

public interface IHasKeyComparator<TObject> {
   Expression<Func<TObject, bool>> KeyComparator { get; } 
}

Et puis vous pouvez l'appliquer sur un objet, même avec un multi-valeurs clés:

public sealed class MultiKeyedObject : IHasKeyComparator<MultiKeyedObject> {
   public int ID1 { get; set; }
   public string ID2 { get; set; }       

   readonly Expression<Func<MultiKeyedObject, bool>> mKeyComparator;

   public Expression<Func<MultiKeyedObject, bool>> KeyComparator {
      get { return mKeyComparator; }
   }

   public MultiKeyedObject() {
      mKeyComparator = other => other.ID1 == ID1 && other.ID2 == ID2;
   }
}

Et vous pouvez l'utiliser de façon générique si vous fournissez la contrainte:

public TObject Refresh<TObject>(TObject pObject)
where TObject : IHasKeyComparator<TObject> {
   return this.Set<TObject>().Single(pObject.KeyComparator);
}

Le faisant de cette manière vous oblige à avoir une instance de l'objet, même si, bien que vous pouvez remplir vide avec des valeurs de clé et ensuite l'utiliser pour tirer à partir de la DB.