C# 使用UnitOfWork模式自动保存DBContext

因此，使用MVC中的UnitOfWork模式，我不希望每次修改对象时都必须调用UnitOfWork保存方法。通常使用UnitOfWork，您可以执行以下操作：

    if (ModelState.IsValid)
    {
        var user = new User()
        {
            Id = Guid.NewGuid(),
            Username = model.Username,
            Email = model.Email,
            Password = model.HashedPassword()
        };
        unitOfWork.UserRepository.Insert(user);
        unitOfWork.Save();
    }

我想删除“unitOfWork.Save（）；”行，只知道每次操作完成时它都会保存。因此，我在UnitOfWork的Dispose方法中添加了一个save子句：

    protected virtual void Dispose(bool disposing)
    {
        if (context.ChangeTracker.HasChanges())
        {
            context.SaveChangesAsync();
        }
        if (!this.isDisposed)
        {
            if (disposing)
            {
                context.Dispose();
            }
        }
        this.isDisposed = true;
    }

当然，我的控制器调用dispose：

    protected override void Dispose(bool disposing)
    {
        unitOfWork.Dispose();
        base.Dispose(disposing);
    }

我确信HasChanges（）方法可以按预期工作，并且会调用saveChangesSync（），但这不起作用。我认为这可能与saveChangesSync创建的线程没有完成有关，因为它所依赖的对象被释放了

但如果是这种情况，那么savechangessync肯定是危险的，因为即使在控制器操作中使用它，它也可能会将事务锁定几秒钟，并发现上下文在有机会保存之前已被释放

那么我做错了什么？我似乎找不到一种既定的方法来实现这一点，但我无法想象，使用工作单元模式的每个人都必须记住，每次修改任何对象时都要手动调用Save方法。

同时调用SaveChanges（）进行多个操作（意味着只调用一次）具有许多优点，但并非所有应用程序都需要这些优势。如果您在某个地方有一个基本的存储库类，为什么不使用Add/Remove/Update操作来定义它，在这些操作的末尾，每个操作都会调用SaveChanges（）

比如：

public abstract RepositoryBase<T>
{
    public void Add(T entity)
    {
        context.Add(entity);
        context.SaveChanges();
    }

    public void Remove(T entity)
    {
        context.Remove(entity);
        context.SaveChanges();
    }

    etc...
}

公共抽象存储库
{
公共无效添加（T实体）
{
添加（实体）；
SaveChanges（）；
}
公共无效删除（T实体）
{
上下文。删除（实体）；
SaveChanges（）；
}
等
}

使用Dispose保存更改时，我发现非常糟糕

变更后工作单位的作用说明： 它唯一的作用是作为上下文的包装器，确保所有存储库共享相同的上下文，但它最初的主要职责将不复存在。

为多个操作同时调用SaveChanges（）（意味着只调用一次）具有许多优点，但并非所有应用程序都需要这些优势。如果您在某个地方有一个基本的存储库类，为什么不使用Add/Remove/Update操作来定义它，在这些操作的末尾，每个操作都会调用SaveChanges（）

比如：

public abstract RepositoryBase<T>
{
    public void Add(T entity)
    {
        context.Add(entity);
        context.SaveChanges();
    }

    public void Remove(T entity)
    {
        context.Remove(entity);
        context.SaveChanges();
    }

    etc...
}

公共抽象存储库
{
公共无效添加（T实体）
{
添加（实体）；
SaveChanges（）；
}
公共无效删除（T实体）
{
上下文。删除（实体）；
SaveChanges（）；
}
等
}

使用Dispose保存更改时，我发现非常糟糕

变更后工作单位的作用说明： 它唯一的作用是作为上下文的包装器，确保所有存储库共享相同的上下文，但它最初的主要职责将不复存在。

为多个操作同时调用SaveChanges（）（意味着只调用一次）具有许多优点，但并非所有应用程序都需要这些优势。如果您在某个地方有一个基本的存储库类，为什么不使用Add/Remove/Update操作来定义它，在这些操作的末尾，每个操作都会调用SaveChanges（）

比如：

public abstract RepositoryBase<T>
{
    public void Add(T entity)
    {
        context.Add(entity);
        context.SaveChanges();
    }

    public void Remove(T entity)
    {
        context.Remove(entity);
        context.SaveChanges();
    }

    etc...
}

公共抽象存储库
{
公共无效添加（T实体）
{
添加（实体）；
SaveChanges（）；
}
公共无效删除（T实体）
{
上下文。删除（实体）；
SaveChanges（）；
}
等
}

使用Dispose保存更改时，我发现非常糟糕

变更后工作单位的作用说明： 它唯一的作用是作为上下文的包装器，确保所有存储库共享相同的上下文，但它最初的主要职责将不复存在。

为多个操作同时调用SaveChanges（）（意味着只调用一次）具有许多优点，但并非所有应用程序都需要这些优势。如果您在某个地方有一个基本的存储库类，为什么不使用Add/Remove/Update操作来定义它，在这些操作的末尾，每个操作都会调用SaveChanges（）

比如：

public abstract RepositoryBase<T>
{
    public void Add(T entity)
    {
        context.Add(entity);
        context.SaveChanges();
    }

    public void Remove(T entity)
    {
        context.Remove(entity);
        context.SaveChanges();
    }

    etc...
}

公共抽象存储库
{
公共无效添加（T实体）
{
添加（实体）；
SaveChanges（）；
}
公共无效删除（T实体）
{
上下文。删除（实体）；
SaveChanges（）；
}
等
}

使用Dispose保存更改时，我发现非常糟糕

变更后工作单位的作用说明：

---

它唯一的作用是作为上下文的包装器，确保所有存储库共享相同的上下文，但它最初的主要职责将不复存在。

虽然我同意使用

Dispose（）

保存更改是一个坏主意，但事情不起作用的原因是

Dispose（）

不是一个异步方法。因此，调用

context.savechangesync（）

，然后直接调用

context.Dispose（）

，可能会在异步处理仍在进行或尚未在后台启动时处理上下文

---

您至少应该切换到

SaveChanges（）

虽然我同意使用

Dispose（）

保存更改是个坏主意，但事情不起作用的原因是

Dispose（）

不是异步方法。因此，调用

context.savechangesync（）

，然后直接调用

context.Dispose（）

，可能会在异步处理仍在进行或尚未在后台启动时处理上下文

---

您至少应该切换到

SaveChanges（）

，尽管我同意使用

Dispose（）

来