"modèle de conception" pour CRUD dans ADO.NET Entity Framework 4.1

Question

Je voudrais vous demander s'il existe un "modèle de conception" pour CRUD dans ADO.NET Entity Framework 4.1.

Par exemple cette méthode charge l'objet à partir de DB.

private static Project GetObjects(int id) 
{ 
    var connSetting = ConfigurationManager.ConnectionStrings["ProjectEntities"]; 
    var conn = new EntityConnection(connSetting.ConnectionString); 
    conn.Open(); 

    using(var contex= new ProjectEntities(conn)) 
    { 
     var project = (from p in contex.Projects 
         where p.ProjectId == id 
         select p).FirstOrDefault(); 

     contex.Detach(project); 

     return project; 
    } 
} 

cette méthode faire la mise à jour:

private static void UpdateObject(Project obj) 
{ 
    var connSetting = ConfigurationManager.ConnectionStrings["ProjectEntities"]; 
    var conn = new EntityConnection(connSetting.ConnectionString); 
    conn.Open(); 

    using (var contex = new ProjectEntities(conn)) 
    { 
     var entity = (Project)contex.GetObjectByKey(obj.EntityKey); 
     contex.ApplyCurrentValues(entity.EntityKey.EntitySetName, obj); 
     contex.SaveChanges(); 
    } 

} 

et cette méthode supprimer objet

private static void DeleteObject(Project obj) 
{ 
    var connSettings = ConfigurationManager.ConnectionStrings["ProjectEntities"]; 
    var conn = new EntityConnection(connSettings.ConnectionString); 
    conn.Open(); 
    using(var ctx = new ProjectEntities()) 
    { 
     var entity = (Project)ctx.GetObjectByKey(obj.EntityKey); 
     ctx.DeleteObject(entity); 
     ctx.SaveChanges(); 
    } 
} 

Je voudrais avoir une belle classe universelle pour CRUD avec ADO.NET EF DB .. .Pouvez-vous m'aider? Obtenir un lien avec un bon échantillon?

Answer 1

Et quel est le problème avec vos méthodes si vous les rendez génériques?

La réponse à votre question est subjective car le premier problème est de savoir si vos méthodes sont vraiment utiles? Le CRUD simple n'est généralement pas utilisé avec EF. EF fournit plus et CRUD va à l'encontre de ses fonctionnalités supplémentaires. L'autre problème est le type d'entités que vous utilisez. EntityKey est une caractéristique des entités basées sur EntityObject - ces entités sont actuellement définitivement considérées comme obsolètes car l'EF entier se déplace vers l'API DbContext et les POCO. Alors, comment faire des méthodes CRUD réutilisables pour les POCOs?

Définissons interface pour vos entités:

public interface IEntity 
{ 
    int Id { get; set; } 
} 

implémentent cette interface dans vos entités et maintenant vous pouvez définir des méthodes réutilisables simples:

private static T GetObject<T>(int id) where T : class, IEntity  
{ 
    using(var context = GetContext()) 
    { 
     // What if you want to load relations as well? 
     var entity = (from x in context.CreateObjectSet<T>() 
         where x.Id == id 
         select p).FirstOrDefault(); 

     // Typical issue - you cannot use neither eager, explicit or lazy 
     // loading 
     context.Detach(entity); 

     return entity; 
    } 
} 

private static void UpdateObject<T>(T entity) where T : class, IEntity 
{ 
    using (var contex = GetContext()) 
    { 
     // This works for POCOs but for EntityObject based entities you will have 
     // to use your approach (combine it with GetObject method to load entity) 
     context.Attach(entity); 
     context.ObjectStateManager.ChangeObjectState(entity, EntityState.Modified); 
     context.SaveChanges(); 
    } 

} 

private static void DeleteObject<T>(int id) where T : class, IEntity, new() 
{ 
    using(var context = GetContext()) 
    { 
     // You need only dummy entity with key to perform delete 
     T entity = new T { Id = id }; 
     context.Attach(entity); 
     context.DeleteObject(entity); 
     context.SaveChanges(); 
    } 
} 

Avis GetContext - vous recherchez réutilisabilité si départ refactoring de vos méthodes réutilisables. Si vous devez utiliser des entités basées EntityObject, ajoutez EntityObject aux contraintes de type générique T au lieu de class.