Comment écrire un référentiel avec Dispose() dans EF 3.5 -4.0?

Question

J'essaie d'écrire une sorte de référentiel pour ajouter, mettre à jour, supprimer etc. efficace mais je suis tellement confus comment puis-je disposer de mes 2 classes (ErpEntities et DataRepository) il y a plus de conseils mais aussi plus de conflits sur google. je veux faire disposer après valeur de retour. Shorthly et effectivelly :( Cordialement ...

namespace WinApp.EF 
{ 
    public partial class Form1 : Form 
    { 
     public Form1() 
     { 
      InitializeComponent(); 
     } 

     private void btnSave_Click(object sender, EventArgs e) 
     { 
      using (ErpEntities erp = new ErpEntities()) 
      { 
       erp.SaveCustomer(textBox1.Text, textBox2.Text); 
      } 
     } 
    } 

    public class ErpEntities : IDisposable 
    { 

     public int SaveCustomer(string Name, string SurName) 
     { 
      using (DataRepository<Customer> repository = new DataRepository<Customer>(new TestErpEntities())) 
      { 
       return repository.Add(new Customer() { Name = Name, SurName = SurName }); 
      } 
     } 

     public void Dispose() 
     { 
      GC.SuppressFinalize(this); 
     } 

    } 


    public interface IRepository<T> : IDisposable where T : class 
    { 
     int Add(T entity); 
    } 

    public class DataRepository<T> : IRepository<T> where T : class 
    { 

     private TestErpEntities _context; 

     public DataRepository() 
     { 
     } 

     public DataRepository(TestErpEntities context) 
     { 
      _context = context; 
     } 

     public int Add(T entity) 
     { 
      _context.AddObject(typeof(T).Name, entity); 
      int saveValue = _context.SaveChanges(); 
      return saveValue; 
     } 

     public void Dispose() 
     { 
      if (_context != null) 
       _context.Dispose(); 
     } 

    } 
} 

Answer 1

Je pense que c'est ce que vous voulez:

public class ErpEntities : IDisposable 
{ 

    public int SaveCustomer(string Name, string SurName) 
    { 
     using(DataRepository repository = new DataRepository<Customer>(new TestErpEntities())) 
     { 
      return repository.Add(new Customer() { Name = Name, SurName = SurName }); 
     } // This using statment ensures that the DataRepository is Dispose()'d when the method exits 
    } 


    #region IDisposable Members 

    public void Dispose() 
    { 
     // You could eliminate this as there's nothing in your 
     // ErpEntities class that needs disposing 
    } 

    #endregion 
} 

public class DataRepository<T> : IRepository<T> where T : class  
{  

    private TestErpEntities _context;  

    public DataRepository()  
    {  
    }  

    public DataRepository(TestErpEntities context)  
    {  
     _context = context;  
    }  

    public int Add(T entity)  
    {  
     _context.AddObject(typeof(T).Name, entity);  
     int saveValue = _context.SaveChanges();  
     return saveValue;  
    }  


    public void Dispose()  
    {  
     if (_context != null)  
      _context.Dispose();  
    } 
} 

La classe destructor (~DataRepository()) et GC.SupressFinalizer() ne sont pas nécessaires car vous n'avez aucune ressource non gérée à libérer. Beaucoup diraient que cela fait partie du modèle IDisposable, mais OMI c'est inutile.

En outre, ceci:

new DataRepository<Customer>().Dispose(); 

est complètement redondant et inutile. Ce que vous faites ici est de créer cet objet seulement pour le détruire. Il n'a pas d'autre fonction et est juste un gaspillage de cycles de mémoire/cpu.

Answer 2

D'après ce que vous avez publié, ErpEntities n'a pas besoin de mettre en œuvre IDisposable. Il ne

quoi que ce soit pas 'propre'. Si elle l'a fait, new ErpEntities().SaveCustomer(...) serait la mauvaise façon de l'utiliser.

la classe DataRepository n'a pas besoin du destructor (~DataRepository()) et l'appel (s) à GC.SuppressFinalize(this) peuvent tous être enlevés aussi.

Ce que vous devez être laissé avec:

• si une classe contient (propriétaire) d'une classe IDisposable devrait mettre en œuvre IDisposable aussi bien et transférer les appels Evacuer()

• le code appelant doit utiliser Classes IDisposable dans un bloc using(...) { }.

• ne plaisante pas avec Destructeurs sauf si vous avez une ressource unmamaged (et même alors il y a de meilleures options)