unit-testing - unit - repositorio generico entity framework 6

¿El patrón UnitOfWork y GenericRepository es redundante en EF 4.1 primero?

Question

Me pregunto si necesito usar el patrón Genericrepository y UnitOfWork para simular el repositorio. Estoy usando MOQ. Ahora es redundante, ya que he notado que EF 4.1 tiene IDBSet.

No he descubierto cómo escribir algo genérico con el IDBSet. Si tienes un ejemplo donde implementas IDBSet, ¿me lo puedes mostrar?

¿Alguna sugerencia?

Answer 1

Además, quiero agregar que ese repositorio genérico y unidad de trabajo en Entity Framework es redundante, revisa este enlace http://rob.conery.io/2014/03/04/repositories-and-unitofwork-are-not-a-good-idea/

Answer 2

Este es un duplicado de muchos temas ya discutidos en SO, pero estoy de acuerdo en que algunos de ellos pueden ser difíciles de encontrar porque están anidados en otra pregunta

• Cuál es el punto del repositorio genérico en EF 4.1
• Desafíos con código comprobable y modificable en EF
• Otra pregunta sobre los desafíos con burlarse del código EF
• Implementación de IDbSet personalizado
• Otra pregunta que resulta en discusión sobre repositorio y unidad de trabajo

Espero que esto te dé algunas respuestas. De lo contrario, no dude en solicitar más información aquí o en una nueva pregunta.

Answer 3

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; }
        }
    }