Marco de la entidad y Unidad de trabajo

Question

Estoy usando EF/Repositorio/Unidad de trabajo, pero estoy teniendo dificultades para entender algunos detalles. Dentro de UnitOfWork, creo un EF DbContext nuevo (EmmaContext), pero miro dentro del repositorio, lo echo, que sé que está mal, ¿cómo obtengo el contexto dentro del repositorio correctamente? Tal vez estoy totalmente en el camino equivocado?

Aquí es mi UnitOfWork:

//Interface 
public interface IUnitOfWork : IDisposable 
{ 
    void Commit(); 
} 

//Implementation 
public class UnitOfWork : IUnitOfWork 
{ 
    #region Fields/Properties 
    private bool isDisposed = false; 
    public EmmaContext Context { get; set; } 
    #endregion 

    #region Constructor(s) 
    public UnitOfWork() 
    { 
     this.Context = new EmmaContext(); 
    } 
    #endregion 

    #region Methods 
    public void Commit() 
    { 
     this.Context.SaveChanges(); 
    } 

    public void Dispose() 
    { 
     if (!isDisposed) 
      Dispose(true); 
     GC.SuppressFinalize(this); 
    } 

    private void Dispose(bool disposing) 
    { 
     isDisposed = true; 
     if (disposing) 
     { 
      if (this.Context != null) 
       this.Context.Dispose(); 
     } 
    } 
    #endregion 
} 

Aquí es el repositorio:

//Interface 
public interface IRepository<TEntity> where TEntity : class 
{ 
    IQueryable<TEntity> Query(); 
    void Add(TEntity entity); 
    void Attach(TEntity entity); 
    void Delete(TEntity entity); 
    void Save(TEntity entity); 
} 

//Implementation 
public abstract class RepositoryBase<TEntity> : IRepository<TEntity> where TEntity : class 
{ 
    #region Fields/Properties 
    protected EmmaContext context; 
    protected DbSet<TEntity> dbSet; 
    #endregion 

    #region Constructor(s) 
    public RepositoryBase(IUnitOfWork unitOfWork) 
    { 
     this.context = ((UnitOfWork)unitOfWork).Context; 
     this.dbSet = context.Set<TEntity>(); 
    } 
    #endregion 

    #region Methods 
    public void Add(TEntity entity) 
    { 
     dbSet.Add(entity); 
    } 

    public void Attach(TEntity entity) 
    { 
     dbSet.Attach(entity); 
    } 

    public void Delete(TEntity entity) 
    { 
     dbSet.Remove(entity); 
    } 

    public IQueryable<TEntity> Query() 
    { 
     return dbSet.AsQueryable(); 
    } 

    public void Save(TEntity entity) 
    { 
     Attach(entity); 
     context.MarkModified(entity); 
    } 
    #endregion 
} 

Answer 1

Sam: por lo general se sienten cómodos con un depósito de hormigón de tomar una UnitOfWork concreta en el ctor:

public RepositoryBase(UnitOfWork unitOfWork) 
    { 
     this.context = unitOfWork.Context; 
     this.dbSet = context.Set<TEntity>(); 
    } 

El repositorio y UoW suelen trabajar en concierto y necesita saber un poco acerca de uno al otro.

Por supuesto, el código que consume estas clases solo conoce las definiciones de interfaz y no los tipos concretos.

Answer 2

En este dice que usted tiene que implementar la interfaz IUnitOfWork en su base de repositorio.

Espero que esto ayude. Saludos

Answer 3

Este es el best article I've read.

En su ejemplo, que gestionan los repositorios de la siguiente manera:

private SchoolContext context = new SchoolContext(); 
    private GenericRepository<Department> departmentRepository; 
    private GenericRepository<Course> courseRepository; 

    public GenericRepository<Department> DepartmentRepository 
    { 
     get 
     { 

      if (this.departmentRepository == null) 
      { 
       this.departmentRepository = new GenericRepository<Department>(context); 
      } 
      return departmentRepository; 
     } 
    } 

su unidad de trabajo mantiene el contexto, y si necesita hacer referencia a un repositorio, lo crea si no se ha creado, y pasa en el contexto que está sosteniendo.

El artículo también repasa cómo convirtieron una implementación regular de controlador MVC en el uso del patrón de unidad de trabajo.

Answer 4

Unit of Work
Repository

UnitOfWork es para la gestión de operaciones atómicas.

El depósito encapsula el conjunto de objetos persistidos en un almacén de datos y las operaciones realizadas sobre ellos.

Si pasa el contexto o UnitOfWork, que no implementa el patrón UnitOfWork + Repository, hace que usted se retire de UnitOfWork su responsabilidad. Aka no lo necesitas.

Implementación correcta si solo pasa DbSet. En realidad, no necesitas más.