Entity Framework 4.1

原文名称：Entity Framework 4.1: Optimistic Concurrency (6)

原文地址：http://vincentlauzon.wordpress.com/2011/04/17/entity-framework-4-1-optimistic-concurrency-6/

看到  Entity Framework 4.1 推荐英文教程，为了帮大家看起来方便一些，简单翻译一下。这是一个系列，共有 8 篇，这是第 8 篇。

1. Entity Framework 4.1 之一 : 基础
2. Entity Framework 4.1 之二 : 覆盖默认的约定
3. Entity Framework 4.1 之三 : 贪婪加载和延迟加载
4. Entity Framework 4.1 之四：复杂类型
5. Entity Framework 4.1 之五：多对多的关系
6. Entity Framework 4.1 之六：乐观并发
7. Entity Framework 4.1 之七：继承
8. Entity Framework 4.1 之八：绕过 EF 查询映射

这篇文章讨论乐观并发。

我们经常要面对多用户并发访问问题。这是因为人访问机器的速度无法与高速的机器匹配，典型情况下，人需要大约一分钟或者更多来填写数据，而机器的交易处理通常只需要不到一秒钟。

在用户编辑相应数据的时候，我们不能让数据库的事务处理保持打开，这有许多原因：连接问题，信任问题，技术原因等等。基于这些原因，我们需要并发管理。有两种管理方法：乐观和悲观。悲观方式更难处理，因为你需要实现基于记录的锁定机制，而且还随之而来带来一些问题，例如，在自动释放锁之前，系统应该锁定多长的时间。乐观并发要简单一些。

乐观并发基于的一个基本的假设是用户的修改很少冲突。对于很少用户同时编辑同样数据的应用来说，不管有很多用户还是很少的用户都是成立的。基本的考虑是为访问数据的用户提供一个数据的版本，当用户以后回来更新数据的时候，通过版本来确认原来的数据，如果数据已经在后台被其他操作更新，版本发生了变化，我们就可以通过版本检测到，然后拒绝更新。

可以有许多方式来实现版本，包括通过一个版本数字来关联到数据，可以是最后一次修改的日期时间字段，还可能是多于一个的字段。在 EF 中，这被称为并发标识 concurrenty token，在这篇文章中，我使用 SQL Server 的 time-stamp 特性，这需要在表中增加一个 time-stamp 类型的列，我们通过它来实现乐观并发。由 SQL Server 在每次记录被更新的时候维护这个列。

为了告诉 EF 在实体中有一个属性表示并发标识，你可以通过标签 [ConcurrencyCheck] 来标识这个属性，或者使用模型构建器。我认为并发标识定义了业务规则，应该是模型的一部分。所以这里使用标签。

   
     

    
      public
    
       
    
      class
    
       Order 
{ 
 
    
      public
    
       
    
      int
    
       OrderID { 
    
      get
    
      ; 
    
      set
    
      ; } 
 [Required] 
 [StringLength(
    
      32
    
      , MinimumLength 
    
      =
    
       
    
      2
    
      )] 
 
    
      public
    
       
    
      string
    
       OrderTitle { 
    
      get
    
      ; 
    
      set
    
      ; } 
 [Required] 
 [StringLength(
    
      64
    
      , MinimumLength
    
      =
    
      5
    
      )] 
 
    
      public
    
       
    
      string
    
       CustomerName { 
    
      get
    
      ; 
    
      set
    
      ; } 
 
    
      public
    
       DateTime TransactionDate { 
    
      get
    
      ; 
    
      set
    
      ; } 
 [ConcurrencyCheck] 
 [Timestamp] 
 
    
      public
    
       
    
      byte
    
      [] TimeStamp { 
    
      get
    
      ; 
    
      set
    
      ; } 

 
    
      public
    
       
    
      virtual
    
       List
    
      <
    
      OrderDetail
    
      >
    
       OrderDetails { 
    
      get
    
      ; 
    
      set
    
      ; } 
 
    
      public
    
       
    
      virtual
    
       List
    
      <
    
      Employee
    
      >
    
       InvolvedEmployees { 
    
      get
    
      ; 
    
      set
    
      ; } 
} 
   
     

在这段代码中，当我们通过 DbContext 调用 SaveChanges 的时候，将会使用乐观并发。

Timestamp 属性的类型是 byte[], 通过标签 Timestamp ，将这个属性映射到 SQL Server 的 time-stamp 类型的列。

现在，我们模拟并发，我们将执行下面的三个步骤：

1. 创建一个订单
2. 模拟用户 X 修改这个订单
3. 模拟用户 Y 修改这个订单，此时订单已经被修改，而用户 Y 不知道。

通过在另一个 DbContext 中连接实体来模拟修改的过程，当我们通过 DbContet 连接实体的时候，它会假设实体没有被修改，所以我们在它之后进行修改。

   
     

    
      private
    
       
    
      static
    
       
    
      void
    
       ConcurrencyCheck() 
{ 
 Order originalOrder; 

 
    
      //
    
       Create an order 
    
      

    
       
    
      using
    
       (var context1 
    
      =
    
       
    
      new
    
       MyDomainContext()) 
 { 
 originalOrder 
    
      =
    
       
    
      new
    
       Order 
 { 
 OrderTitle 
    
      =
    
       
    
      "
    
      Paper
    
      "
    
      , 
 CustomerName 
    
      =
    
       
    
      "
    
      *Bob*
    
      "
    
      , 
 TransactionDate 
    
      =
    
       DateTime.Now 
 }; 

 context1.Orders.Add(originalOrder); 
 context1.SaveChanges(); 
 } 
 
    
      //
    
       Simulate the modification of the created order by user X 
    
      

    
       
    
      using
    
       (var context2 
    
      =
    
       
    
      new
    
       MyDomainContext()) 
 { 
    
      //
    
       Recreate the order object in order to attach it 
    
      

    
       var order 
    
      =
    
       
    
      new
    
       Order 
 { 
 OrderID 
    
      =
    
       originalOrder.OrderID, 
 OrderTitle 
    
      =
    
       originalOrder.OrderTitle, 
 CustomerName 
    
      =
    
       originalOrder.CustomerName, 
 TransactionDate 
    
      =
    
       originalOrder.TransactionDate, 
 TimeStamp 
    
      =
    
       originalOrder.TimeStamp 
 }; 

 context2.Orders.Attach(order); 

 
    
      //
    
       Alter the order 
    
      

    
       order.CustomerName 
    
      =
    
       
    
      "
    
      Robert
    
      "
    
      ; 

 context2.SaveChanges(); 
 } 
 
    
      //
    
       Simulate the modification of the created order by user Y (after user X already modified it) 
    
      

    
       
    
      using
    
       (var context3 
    
      =
    
       
    
      new
    
       MyDomainContext()) 
 { 
    
      //
    
       Recreate the order in order to attach it 
    
      

    
       var order 
    
      =
    
       
    
      new
    
       Order 
 { 
 OrderID 
    
      =
    
       originalOrder.OrderID, 
 OrderTitle 
    
      =
    
       originalOrder.OrderTitle, 
 CustomerName 
    
      =
    
       originalOrder.CustomerName, 
 TransactionDate 
    
      =
    
       originalOrder.TransactionDate, 
 TimeStamp 
    
      =
    
       originalOrder.TimeStamp 
 }; 

 context3.Orders.Attach(order); 

 
    
      //
    
       Alter the order 
    
      

    
       order.CustomerName 
    
      =
    
       
    
      "
    
      Luke**
    
      "
    
      ; 

 
    
      try
    
       
 { 
 context3.SaveChanges(); 
 } 
 
    
      catch
    
       (DbUpdateConcurrencyException ex) 
 { 
 Console.WriteLine(
    
      "
    
      Concurrency exception on 
    
      "
    
       
    
      +
    
       ex.Entries.First().Entity.GetType().Name); 
 } 
 } 
} 
   
     

你也可以强制 EF 相信订单已经被修改了。

   
     

    
      context3.Entry(order).State 
    
      =
    
       EntityState.Modified; 
   
     

所以，EF 提供了开箱即用的乐观并发支持，这个窍门也可以用在 EF 状态的各个方面：当你连接实体的时候，确信它们处于正确的状态。

Detached

Unchanged

Added

Deleted

Modified

http://www.cnblogs.com/haogj/archive/2011/05/08/2040190.html