0

Following is my code. I want to know it is true or not.

public interface IRepository<T> : IDisposable
{
    IQueryable<T> GetAll();
    T Update(T entity);
    T Insert(T entity);
    T GetById(T entity);
    void Delete(T entity);
    void Save();
}

public class Repository<T> : IRepository<T> where T : class
{
    private readonly SchoolDBEntities _context;

    public Repository(SchoolDBEntities context)
    {
        _context = context;
    }

    public IQueryable<T> GetAll()
    {
        return _context.Set<T>();
    }

    public T Update(T entity)
    {
        var result = _context.Set<T>().Attach(entity);
        _context.Entry(entity).State = EntityState.Modified;
        return result;
    }

    public T Insert(T entity)
    {
        return _context.Set<T>().Add(entity);
    }

    public T GetById(T entity)
    {
        return _context.Set<T>().Find(entity);
    }

    public void Delete(T entity)
    {
        _context.Set<T>().Remove(entity);
    }

    public void Save()
    {
        _context.SaveChanges();
    }

    public void Dispose()
    {
        _context.Dispose();
    }
}

The problem is, I don't know when and where to call the Save and Dispose methods.

4

3 回答 3

2

不要丢弃在IRepository<T>

像这样尝试 UnitOfWork 模式

public interface IUnitOfWork : IDisposable
{
    IRepository<Cart> CartRepository { get; }
    IRepository<Product> ProductRepository { get; }
    void Save();
}

public class UnitOfWork : IUnitOfWork
{
    readonly SqlDbContext _context;
    public UnitOfWork()
    {
        _context = new SqlDbContext();
    }

    private bool _disposed;
    protected virtual void Dispose(bool disposing)
    {
        if (!_disposed)
        {
            if (disposing)
            {
                _context.Dispose();
            }
        }
        _disposed = true;
    }
    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    public void Save()
    {
        _context.SaveChanges();
    }

    public IGenericRepository<Cart> CartRepository
    {
        get { return new Repository<Cart>(_context); }
    }

    public IGenericRepository<User> UserRepository
    {
        get { return new Repository<User>(_context); }
    }
}

你可以这样称呼它

using (_unitOfWork) 
{ 
   var p = _unitOfWork.ProductRepository.SingleOrDefault(p => p.Id == productId); 
   _cartRepository.Add(p);
   _unitOfWork.Save(); 
}
于 2013-10-23T16:46:23.627 回答
0

我认为这取决于你使用这个 repo 的方式。因此，当您想保存时保存并在您想要完成工作时进行处理......在应用程序关闭等时......

于 2013-10-23T12:57:20.720 回答
0

当您在这里使用工作单元模式时，显然如果用户（存储库的）发送保存更改命令，您应该调用 Save 方法。它可能是一个人在您的编辑表单之一或您的应用程序的其他部分上单击应用更改按钮，它处理一些事务逻辑并基于它保存/丢弃更改。所以基本上，当逻辑更改集准备好保存时，存储库会处理它。

于 2013-10-23T14:46:10.723 回答