根据您的用例，以上所有解决方案都适用。我通常是这样做的:

For server side code (e.g. a batch process) I usually load the entities and work with dynamic proxies. Usually in batch processes you need to load the data anyways at the time the service runs. I try to batch load the data instead of using the find method to save some time. Depending on the process I use optimistic or pessimistic concurrency control (I always use optimistic except for parallel execution scenarios where I need to lock some records with plain sql statements, this is rare though). Depending on the code and scenario the impact can be reduced to almost zero.

对于客户端场景，您有几个选项

Use view models. The models should have a property UpdateStatus(unmodified-inserted-updated-deleted). It is the responsibility of the client to set the correct value to this column depending on the user actions (insert-update-delete). The server can either query the db for the original values or the client should send the original values to the server along with the changed rows. The server should attach the original values and use the UpdateStatus column for each row to decide how to handle the new values. In this scenario I always use optimistic concurrency. This will only do the insert - update - delete statements and not any selects, but it might need some clever code to walk the graph and update the entities (depends on your scenario - application). A mapper can help but does not handle the CRUD logic Use a library like breeze.js that hides most of this complexity (as described in 1) and try to fit it to your use case.

希望能有所帮助

public interface IRepository
{
    void Update<T>(T obj, params Expression<Func<T, object>>[] propertiesToUpdate) where T : class;
}

public class Repository : DbContext, IRepository
{
    public void Update<T>(T obj, params Expression<Func<T, object>>[] propertiesToUpdate) where T : class
    {
        Set<T>().Attach(obj);
        propertiesToUpdate.ToList().ForEach(p => Entry(obj).Property(p).IsModified = true);
        SaveChanges();
    }
}

根据您的用例，以上所有解决方案都适用。我通常是这样做的:

For server side code (e.g. a batch process) I usually load the entities and work with dynamic proxies. Usually in batch processes you need to load the data anyways at the time the service runs. I try to batch load the data instead of using the find method to save some time. Depending on the process I use optimistic or pessimistic concurrency control (I always use optimistic except for parallel execution scenarios where I need to lock some records with plain sql statements, this is rare though). Depending on the code and scenario the impact can be reduced to almost zero.

对于客户端场景，您有几个选项

Use view models. The models should have a property UpdateStatus(unmodified-inserted-updated-deleted). It is the responsibility of the client to set the correct value to this column depending on the user actions (insert-update-delete). The server can either query the db for the original values or the client should send the original values to the server along with the changed rows. The server should attach the original values and use the UpdateStatus column for each row to decide how to handle the new values. In this scenario I always use optimistic concurrency. This will only do the insert - update - delete statements and not any selects, but it might need some clever code to walk the graph and update the entities (depends on your scenario - application). A mapper can help but does not handle the CRUD logic Use a library like breeze.js that hides most of this complexity (as described in 1) and try to fit it to your use case.

希望能有所帮助

已经有一些非常好的答案，但我想发表我的意见。下面是一个将视图对象转换为实体的非常简单的方法。简单的想法是，只有存在于视图模型中的属性才会被写入实体。这类似于@Anik Islam Abhi的回答，但具有零传播。

public static T MapVMUpdate<T>(object updatedVM, T original)
{
    PropertyInfo[] originalProps = original.GetType().GetProperties();
    PropertyInfo[] vmProps = updatedVM.GetType().GetProperties();
    foreach (PropertyInfo prop in vmProps)
    {
        PropertyInfo projectProp = originalProps.FirstOrDefault(x => x.Name == prop.Name);
        if (projectProp != null)
        {
            projectProp.SetValue(original, prop.GetValue(updatedVM));
        }
    }
    return original;
}

Pros

视图不需要拥有实体的所有属性。 当您向视图添加删除属性时，您不必更新代码。 完全通用的

Cons

对数据库进行2次点击，一次加载原始实体，一次保存它。

对我来说，这种方法的简单性和低维护需求超过了增加的数据库调用。

只是为了增加更多的选择。您还可以从数据库中获取对象，并使用像auto Mapper这样的自动映射工具来更新您想要更改的记录部分。

我已经在我的存储库基类中添加了一个额外的更新方法，它类似于脚手架生成的更新方法。它不是将整个对象设置为“modified”，而是设置一组单独的属性。(T是类的泛型参数。)

public void Update(T obj, params Expression<Func<T, object>>[] propertiesToUpdate)
{
    Context.Set<T>().Attach(obj);

    foreach (var p in propertiesToUpdate)
    {
        Context.Entry(obj).Property(p).IsModified = true;
    }
}

然后调用，例如:

public void UpdatePasswordAndEmail(long userId, string password, string email)
{
    var user = new User {UserId = userId, Password = password, Email = email};

    Update(user, u => u.Password, u => u.Email);

    Save();
}

我喜欢去数据库一趟。不过，为了避免重复属性集，最好在视图模型中这样做。我还没有这样做，因为我不知道如何避免将视图模型验证器上的验证消息带入域项目。