如何在数据层编写Linq方法？

Question

我正在考虑如何在.net项目的经典三层架构中使用Linq。显然，Linq to SQL 应该出现在数据层中。我选择 Linq 的原因是因为它比使用存储过程节省更多的代码时间。我在线搜索了有关 Linq 的插入/更新/删除方法，但没有找到使用实体进行记录更新的合适方法。通常，人们会使用这种方式进行更新：

    public void UpdateUser(String username, String password, int userId) 
    {      
          using (var db = new UserDataContext()){
             var user = db.user.Single(p => p.Id = userId);
             user.Username = username;          
             user.Password = password;          
             db.SubmitChanges();      
           } 
    } 

为什么我们不使用实体来像这样传递记录：

public void Update(Application info)
{
    VettingDataContext dc = new VettingDataContext(_connString);
    var query = (from a in dc.Applications
                 where a.Id==info.Id
                 select a).First();
    query = info;
    try{
        dc.SubmitChanges();
        }
    catch(Exception e){
       //...
        }
 }

但不幸的是，上面的代码是错误的，因为“query=info”，但是如果我从“info”分配每个值到“查询”，它工作正常。如果

query.firstName=info.firstName;
query.lastName=info.lastName;

这个表有 40 个字段，我必须编写 40 行代码。有没有更简单的方法来进行更新？希望我能清楚地描述这个问题。

Answer 1

添加另一个答案作为评论不足以扩展我之前的答案。

让我们退后一步，从逻辑角度看看您想要在这里做什么。您想告诉数据访问层如何更新数据库，以及需要写入的所有新的/更改的值。

执行此操作的一种非常常见的方法是传递具有这些更改的实体（这就是您在示例中所做的）。正如您所看到的，这可能会变得很棘手，因为如果您只是用更改的实体覆盖实体变量，Linq2Sql 将失去更改跟踪...仅仅因为新实体被分配给相同的变量，并不意味着 Linq2Sql 自动从新对象中获取更改...事实上 Linq2Sql 根本不知道新对象...

示例：

// In domain layer:
MyEntity entity = new MyEntity();
entity.PrimaryKey = 10;
entity.Name = "Toby Larone";
entity.Age = 27;

myDataRepository.Update(entity);

// In data layer:
void Update(MyEntity changedEntity)
{
    using (var db = new DataContext())
    {
        var entity = (from e in db.MyEntities
                      where e.PrimaryKey == changedEntity.PrimaryKey
                      select e).First();

        // Linq2Sql now has change tracking of "entity"... any changes made will be persisted when SubmitChanges is called...

        entity = changedEntity;

        // Linq2Sql does **not** have change tracking of changedEntity - the fact that it has been assigned to the same variable that once stored a tracked entity does not mean that Linq2Sql will magically pick up the changes...

        db.SubmitChanges(); // Nothing happens - as far as Linq2Sql is concerned, the entity that was selected in the first query has not been changed (only the variable in this scope has been changed to reference a different entity).
    }
}

现在您已经看到将每个字段分配给实体而不是按预期替换它 - 这是因为更改是对原始实体进行的，而原始实体仍在 Linq2Sql 更改跟踪系统内。

此问题的一种可能的解决方案是编写一种方法，将另一个实体的更改“应用”到现有实体，即：

partial class MyEntity
{
    void ApplyChanges(MyEntity changedEntity)
    {
        this.PrimaryKey = changeEntity.PrimaryKey;
        this.Name = changedEntity.Name;
        this.Age = changedEntity.Age;
    }
}

然后您的数据访问将如下所示：

// In data layer:
void Update(MyEntity changedEntity)
{
    using (var db = new DataContext())
    {
        var entity = (from e in db.MyEntities
                      where e.PrimaryKey == changedEntity.PrimaryKey
                      select e).First();

        // Linq2Sql now has change tracking of "entity"... any changes made will be persisted when SubmitChanges is called...

        entity.ApplyChanges(changedEntity);

        db.SubmitChanges(); // Works OK...
    }
}

但我确定您不喜欢这个解决方案 - 因为您所做的只是有效地将重复的字段分配从存储库移出并移入实体类本身...

回到逻辑角度 - 您真正需要做的就是告诉数据访问存储库 2 件事 - 1) 您想要更新哪些记录，2) 更改是什么。发送一个封装这两个要求的全新实体对于实现该目标来说并不是必要的，事实上我认为这是非常低效的。

在以下示例中，您仅向数据存储库发送更改，而不是整个实体。由于没有实体，因此没有需要解决的更改跟踪问题

示例：

// In domain layer:
myDataRepository.Update(10, entity =>
{
    entity.Name = "Toby Larone";
    entity.Age = 27;
});

// In data layer:
void Update(int primaryKey, Action<MyEntity> callback)
{
    using (var db = new DataContext())
    {
        var entity = (from e in db.MyEntities
                      where e.PrimaryKey == primaryKey
                      select e).First();

        // Linq2Sql now has change tracking of "entity"... any changes made will be persisted when SubmitChanges is called...

        // The changes that were sent are being applied directly to the Linq2Sql entity, which is already under change tracking...
        callback(entity);

        db.SubmitChanges();
    }
}

在前面的示例中，字段分配发生了两次 - 一次是在您描述想要进行的更改时，另一次是在数据存储库中当您需要时将这些更改应用到 Linq2Sql 更改跟踪实体。

使用回调，字段分配仅发生一次 - 更改本身的描述就是更新跟踪实体的内容。

我希望我解释得足够好:)

Answer 2

考虑一下数据存储库实际需要什么才能执行更新。它不需要包含这些更改的对象，而是需要进行哪些更改的描述。这可以很容易地封装到回调委托中......

public void UpdateUser(int userId, Action<User> callback)
{
    using (var db = new DataContext())
    {
        User entity = db.Users.Where(u => u.Id == userId).Single();

        callback(entity);

        db.SubmitChanges();
    }
}

myrepository.UpdateUser(userId, user =>
{
    user.Username = username;
    user.Password = password;
    // etc...
});

Answer 3

query 与 info 的类型不同。它们可能具有与您相同的属性，但代码不知道这一点。

现在，如果您想避免编写一堆不必要的代码，您可以使用第三方库，例如 AutoMapper可以为你做到这一点。