¿Es redundante el patrón UnitOfWork y GenericRepository en el código EF 4.1 primero?

Question

Se pregunta si necesito utilizar el patrón Genericrepository y UnitOfWork para burlarse de los repository.I estoy usando MOQ.Is ahora redundante, ya que me he dado cuenta que EF tiene 4.1 IDBSet.

no he encontrado la manera de escribir algo genérico que usic IDBSet Si usted tiene un ejemplo donde se implementa IDBSet se puede mostrar que a mí?

¿Alguna sugerencia?

Answer 1

Ésta es duplicado de muchos temas ya discutidos en el SO pero estoy de acuerdo que algunos de ellos pueden ser difíciles de encontrar, ya que se anidan en otra pregunta

• What's the point of Generic repository in EF 4.1
• Challenges with testable and mockable code in EF
• Another question about challenges with mocking EF code
• Implementing custom IDbSet
• Another question resulting in discussion about repository and unit of work

espero que esto le dará algunas respuestas. De lo contrario, no dude en solicitar más información aquí o en una nueva pregunta.

Answer 2

public class MockDbSet<T> : IDbSet<T> where T : class, new() 
    { 
     private List<T> _entities; 

     public MockDbSet(List<T> entities) 
     { 
      _entities = entities; 
     } 

     public virtual T Add(T entity) 
     { 
      _entities.Add(entity); 
      return entity; 
     } 

     public virtual T Attach(T entity) 
     { 
      _entities.Add(entity); 
      return entity; 
     } 

     public TDerivedEntity Create<TDerivedEntity>() where TDerivedEntity : class, T 
     { 
      return new T() as TDerivedEntity; 
     } 

     public virtual T Create() 
     { 
      return new T(); 
     } 

     public virtual T Find(params object[] keyValues) 
     { 
      throw new NotImplementedException(); 
     } 

     public System.Collections.ObjectModel.ObservableCollection<T> Local 
     { 
      get 
      { 
       return new ObservableCollection<T>(_entities); 
      } 
     } 

     public virtual T Remove(T entity) 
     { 
      _entities.Remove(entity); 
      return entity; 
     } 

     public IEnumerator<T> GetEnumerator() 
     { 
      return _entities.GetEnumerator(); 
     } 

     System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() 
     { 
      return _entities.GetEnumerator(); 
     } 

     public Type ElementType 
     { 
      get { return _entities.AsQueryable().ElementType; } 
     } 

     public System.Linq.Expressions.Expression Expression 
     { 
      get { return _entities.AsQueryable().Expression; } 
     } 

     public IQueryProvider Provider 
     { 
      get { return _entities.AsQueryable().Provider; } 
     } 
    } 

Answer 3

Además, quiero añadir, que repositorio genérico y unidad de trabajo en el marco de la entidad es redundante, echa un vistazo a este enlace http://rob.conery.io/2014/03/04/repositories-and-unitofwork-are-not-a-good-idea/