EntityFramework 6 (EF6 DBcontext) 并发处理实战。EntityFramework 6 (EF6 DBcontext) 并发处理实战。

by admin on 2018年10月8日

学习:C#汇总揭秘——Entity Framework
并发处理详解

帖子笔记 ,该帖子使用的凡objectContext ,

学习:C#综合揭秘——Entity Framework
并发处理详解

帖子笔记 ,该帖子使用的凡objectContext ,

同样、并作相关概念

起的色:

率先种植模式称为悲观式并发,即当一个用户就以窜某修记下时,系统将不容其他用户同时修改是记录。
次种模式称为乐观式并发,即系统允许多独用户同时修改及同长记下,系统会先定义由数出现所引的起异常处理模式,去处理修改后可能发生的冲突。常用之乐观性并发处理方法来以下几种植:

    1、保留最后修改的价值。
    2、保留最初修改的值。
    3、合并往往修改的价。

同一、并作相关概念

出现的品种:

首先栽模式称为悲观式并发,即当一个用户既于改动某修记下时,系统以不容其他用户同时修改者记录。
仲栽模式称为乐观式并发,即系统允许多单用户同时修改和同长长的记下,系统会先定义由数量出现所引起的产出异常处理模式,去处理修改后恐怕有的冲突。常用的乐观性并发处理办法发生以下几种:

    1、保留最后修改的价值。
    2、保留最初修改的价。
    3、合并往往窜的价值。

其次、模型属性的出现处理选项

正如图模型设计器中TimeStamp字段为启用并发

图片 1

<EntityType Name="UserAccout">
          <Key>
            <PropertyRef Name="Id" />
          </Key>
          <Property Name="Id" Type="Int32" Nullable="false" annotation:StoreGeneratedPattern="Identity" />
          <Property Name="FirstName" Type="String" Nullable="false" />
          <Property Name="LastName" Type="String" Nullable="false" />
          <Property Name="AuditFileds" Type="OrderDB.AuditFields" Nullable="false" />
          <Property Name="Timestamp" Type="DateTime" Nullable="false" ConcurrencyMode="Fixed" annotation:StoreGeneratedPattern="Computed" />
        </EntityType>

起模式:ConcurencyMode 有星星点点单成员:

None : 在写入时并未验证此属性。 这是默认的面世模式。

Fixed: 在写入时直验证此属性。

当型属性也默认值 None
时,系统非见面指向这个模型属性进行检测,当同一个时光针对此属性进行修改时,系统会因数据统一方式处理输入的属于性值。

当型属性也Fixed
时,系统会指向斯模型属性进行检测,当同一个时刻对性进行改动时,系统就会激励OptimisticConcurrencyException
异常。

 

亚、模型属性的出现处理选项

正如图模型设计器中TimeStamp字段为启用并发

图片 2

<EntityType Name="UserAccout">
          <Key>
            <PropertyRef Name="Id" />
          </Key>
          <Property Name="Id" Type="Int32" Nullable="false" annotation:StoreGeneratedPattern="Identity" />
          <Property Name="FirstName" Type="String" Nullable="false" />
          <Property Name="LastName" Type="String" Nullable="false" />
          <Property Name="AuditFileds" Type="OrderDB.AuditFields" Nullable="false" />
          <Property Name="Timestamp" Type="DateTime" Nullable="false" ConcurrencyMode="Fixed" annotation:StoreGeneratedPattern="Computed" />
        </EntityType>

出现模式:ConcurencyMode 有一定量个分子:

None : 在写入时无验证此属性。 这是默认的产出模式。

Fixed: 在写入时一直验证此属性。

当型属性为默认值 None
时,系统不会见针对是模型属性进行检测,当同一个光阴对此属性进行改动时,系统会因为多少统一方式处理输入的属性值。

当型属性为Fixed
时,系统会对之模型属性进行检测,当同一个时空针对性能进行修改时,系统即会激励OptimisticConcurrencyException
异常。

 

其三、悲观并发

 

老三、悲观并发

 

季、乐观并发

为缓解悲观并发所带来的题材,ADO.NET Entity Framework
提供了进一步迅速的开朗并发处理方式。相对于LINT to SQL , ADO.NET Entity
Framework
简化了开展并发的处理方式,它可以灵活采用合并数据、保留初次输入数据、保留最新输入数据(3栽艺术)等办法处理并发冲突。

季、乐观并发

为了化解悲观并发所带来的问题,ADO.NET Entity Framework
提供了逾便捷之无忧无虑并发处理方式。相对于LINT to SQL , ADO.NET Entity
Framework
简化了有望并发的处理方式,它可以灵活使用合并数据、保留初次输入数据、保留最新输入数据(3栽艺术)等艺术处理并发冲突。

4.1 以联合方式处理并发数据

小结:当型属性的 ConcurencyMode 为默认值 None
,一旦和一个对象属性同时受改,系统以因为合数据的措施处理并发冲突,这吗是
Entity Framework 处理并发冲突之默认方式。

集合处理方式如下:

(1)当同一时间针对同一个对象属性作出修改,系统以保存时输入的属性值。

(2)当同一时间对同样对象的不同属性作出修改,系统以保存已被修改的属性值。下面用鲜独例证作出说明:

图片 3

运转结果:

图片 4

#region (4.1)测试不设置任何并发测试时,当产生并发EF的处理方法
        delegate void MyDelegate(Address addressValue);
        public  StringBuilder sb = new StringBuilder();
        public Address GetAddress(int id)
        {
            using (OrderDBContainer context = new OrderDBContainer())
            {
                IQueryable<Address> list = context.AddressSet.Where(x => x.Id == id);
                return list.First();
            }
        }
        /// <summary>
        /// 修改方法
        /// </summary>
        /// <param name="addressValue"></param>
        public void UpdateAddress(Address addressValue)
        {
            using (OrderDBContainer context = new OrderDBContainer())
            {
                //显示输入新数据的信息
                Display("Current", addressValue);
                var obj = context.AddressSet.Where(x => x.Id == addressValue.Id).First();
                if (obj != null)
                    context.Entry(obj).CurrentValues.SetValues(addressValue);
                //虚拟操作,保证数据能同时加入到上下文当中
                Thread.Sleep(100);
                context.SaveChanges();
            }
        }        
        /// <summary>
        /// 显示实体当前属性
        /// </summary>
        /// <param name="message"></param>
        /// <param name="addressValue"></param>
        public void Display(string message, Address addressValue)
        {
            String data = string.Format("{0}\n  Address Message:\n    Id:{1}  Address1:{2}  " +
                "address2:{3} \r\n ",
                message, addressValue.Id, addressValue.Address1, addressValue.Address2 );
            sb.AppendLine(data);
        }     

        /// <summary>
        /// (1)测试使用EF默认的机制,当配置并发控制时,系统是使用的合并的方式
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void button3_Click(object sender, EventArgs e)
        {
            //在更新数据前显示对象信息
            var beforeObj = GetAddress(1);
            Display("Before", beforeObj);

            //更新Person的SecondName,Age两个属性
            Address _address1 = new Address();
            _address1.Id = 1;
            _address1.Address1 = "古溪";
            _address1.Address2 = beforeObj.Address2;
            _address1.AuditFields.InsertDate = beforeObj.AuditFields.InsertDate;
            _address1.AuditFields.UpdateDate = beforeObj.AuditFields.UpdateDate;
            _address1.City = beforeObj.City;
            _address1.Zip = beforeObj.Zip;
            _address1.State = beforeObj.State;

            //更新Person的FirstName属性
            Address _address2 = new Address();
            _address2.Id = 1;
            _address2.Address1 = beforeObj.Address1;
            _address2.Address2 = "江苏";
            _address2.AuditFields.InsertDate = beforeObj.AuditFields.InsertDate;
            _address2.AuditFields.UpdateDate = beforeObj.AuditFields.UpdateDate;
            _address2.City = beforeObj.City;
            _address2.Zip = beforeObj.Zip;
            _address2.State = beforeObj.State;

            //使用异步方式同时更新数据
            MyDelegate myDelegate = new MyDelegate(UpdateAddress);
            myDelegate.BeginInvoke(_address1, null, null);
            myDelegate.BeginInvoke(_address2, null, null);

            Thread.Sleep(1000);
            //在更新数据后显示对象信息
            var afterObj = GetAddress(1);
            Display("After", afterObj);
            this.textBox1.Text = sb.ToString();
        }

        /// <summary>
        /// 先插入几条数据等着测试
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void BtnSaveAddress_Click(object sender, EventArgs e)
        {
            using (OrderDBContainer db = new OrderDBContainer())
            {
                Address address = new Address();
                address.Address1 = "古溪镇";
                address.Address2 = "安镇";
                address.State = "2";
                address.City = "无锡";
                address.AuditFields.InsertDate = DateTime.Now;
                address.AuditFields.UpdateDate = DateTime.Now;
                address.Zip = "21415";
                db.AddressSet.Add(address);
                db.SaveChanges();
            }
        }

        /// <summary>
        /// 还原成初始值,准备再次测试
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void button5_Click(object sender, EventArgs e)
        {
            using (OrderDBContainer db = new OrderDBContainer())
            {
                Address _address = db.AddressSet.Where(x => x.Id == 1).First();
                _address.Address1 = "aaa";
                _address.Address2 = "bbb";
                db.SaveChanges();
            }
        }
        #endregion

备考:实践过程中遇见的问题

在多线程中EF修改事件之化解方案,使用attach不得以:

图片 5

使用Entry也报错

图片 6

末尾参考如下帖子

图片 7

/// <summary>
        /// 修改方法
        /// </summary>
        /// <param name="addressValue"></param>
        public void UpdateAddress(Address addressValue)
        {
            using (OrderDBContainer context = new OrderDBContainer())
            {
                //显示输入新数据的信息
                Display("Current", addressValue);
                var obj = context.AddressSet.Where(x => x.Id == addressValue.Id).First();
                if (obj != null)
                    context.Entry(obj).CurrentValues.SetValues(addressValue);
                //虚拟操作,保证数据能同时加入到上下文当中
                Thread.Sleep(100);
                context.SaveChanges();
            }
        }

引用:“因为统一数据的章程处理并发冲突固然好快节,但当业务逻辑较为复杂的体系下并无符合采取是处理方式。比如当广大的Order、OrderItem的报表中,OrderItem
的单价,数量会直接影响Order的整体价格,这样以合并数据的不二法门处理并发,有或引起逻辑性的荒唐。此时,应该考虑因其它艺术处理并发冲突。”。

任何什么法也?【待上】

 

4.1 以联合方式处理并发数据

总结:当型属性的 ConcurencyMode 为默认值 None
,一旦跟一个靶属性同时给改,系统以坐统一数据的计处理并发冲突,这也是
Entity Framework 处理并发冲突之默认方式。

联合处理方式如下:

(1)当同一时间针对同一个对象属性作出修改,系统以保存时输入的属性值。

(2)当同一时间对同一对象的差性质作出修改,系统以保存已受改动的属性值。下面用少独例作出说明:

图片 8

运行结果:

图片 9

#region (4.1)测试不设置任何并发测试时,当产生并发EF的处理方法
        delegate void MyDelegate(Address addressValue);
        public  StringBuilder sb = new StringBuilder();
        public Address GetAddress(int id)
        {
            using (OrderDBContainer context = new OrderDBContainer())
            {
                IQueryable<Address> list = context.AddressSet.Where(x => x.Id == id);
                return list.First();
            }
        }
        /// <summary>
        /// 修改方法
        /// </summary>
        /// <param name="addressValue"></param>
        public void UpdateAddress(Address addressValue)
        {
            using (OrderDBContainer context = new OrderDBContainer())
            {
                //显示输入新数据的信息
                Display("Current", addressValue);
                var obj = context.AddressSet.Where(x => x.Id == addressValue.Id).First();
                if (obj != null)
                    context.Entry(obj).CurrentValues.SetValues(addressValue);
                //虚拟操作,保证数据能同时加入到上下文当中
                Thread.Sleep(100);
                context.SaveChanges();
            }
        }        
        /// <summary>
        /// 显示实体当前属性
        /// </summary>
        /// <param name="message"></param>
        /// <param name="addressValue"></param>
        public void Display(string message, Address addressValue)
        {
            String data = string.Format("{0}\n  Address Message:\n    Id:{1}  Address1:{2}  " +
                "address2:{3} \r\n ",
                message, addressValue.Id, addressValue.Address1, addressValue.Address2 );
            sb.AppendLine(data);
        }     

        /// <summary>
        /// (1)测试使用EF默认的机制,当配置并发控制时,系统是使用的合并的方式
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void button3_Click(object sender, EventArgs e)
        {
            //在更新数据前显示对象信息
            var beforeObj = GetAddress(1);
            Display("Before", beforeObj);

            //更新Person的SecondName,Age两个属性
            Address _address1 = new Address();
            _address1.Id = 1;
            _address1.Address1 = "古溪";
            _address1.Address2 = beforeObj.Address2;
            _address1.AuditFields.InsertDate = beforeObj.AuditFields.InsertDate;
            _address1.AuditFields.UpdateDate = beforeObj.AuditFields.UpdateDate;
            _address1.City = beforeObj.City;
            _address1.Zip = beforeObj.Zip;
            _address1.State = beforeObj.State;

            //更新Person的FirstName属性
            Address _address2 = new Address();
            _address2.Id = 1;
            _address2.Address1 = beforeObj.Address1;
            _address2.Address2 = "江苏";
            _address2.AuditFields.InsertDate = beforeObj.AuditFields.InsertDate;
            _address2.AuditFields.UpdateDate = beforeObj.AuditFields.UpdateDate;
            _address2.City = beforeObj.City;
            _address2.Zip = beforeObj.Zip;
            _address2.State = beforeObj.State;

            //使用异步方式同时更新数据
            MyDelegate myDelegate = new MyDelegate(UpdateAddress);
            myDelegate.BeginInvoke(_address1, null, null);
            myDelegate.BeginInvoke(_address2, null, null);

            Thread.Sleep(1000);
            //在更新数据后显示对象信息
            var afterObj = GetAddress(1);
            Display("After", afterObj);
            this.textBox1.Text = sb.ToString();
        }

        /// <summary>
        /// 先插入几条数据等着测试
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void BtnSaveAddress_Click(object sender, EventArgs e)
        {
            using (OrderDBContainer db = new OrderDBContainer())
            {
                Address address = new Address();
                address.Address1 = "古溪镇";
                address.Address2 = "安镇";
                address.State = "2";
                address.City = "无锡";
                address.AuditFields.InsertDate = DateTime.Now;
                address.AuditFields.UpdateDate = DateTime.Now;
                address.Zip = "21415";
                db.AddressSet.Add(address);
                db.SaveChanges();
            }
        }

        /// <summary>
        /// 还原成初始值,准备再次测试
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void button5_Click(object sender, EventArgs e)
        {
            using (OrderDBContainer db = new OrderDBContainer())
            {
                Address _address = db.AddressSet.Where(x => x.Id == 1).First();
                _address.Address1 = "aaa";
                _address.Address2 = "bbb";
                db.SaveChanges();
            }
        }
        #endregion

备考:实践过程遭到碰到的题材

在多线程中EF修改事件之缓解方案,使用attach不可以:

图片 10

使用Entry也报错

图片 11

末尾参考如下帖子

图片 12

/// <summary>
        /// 修改方法
        /// </summary>
        /// <param name="addressValue"></param>
        public void UpdateAddress(Address addressValue)
        {
            using (OrderDBContainer context = new OrderDBContainer())
            {
                //显示输入新数据的信息
                Display("Current", addressValue);
                var obj = context.AddressSet.Where(x => x.Id == addressValue.Id).First();
                if (obj != null)
                    context.Entry(obj).CurrentValues.SetValues(addressValue);
                //虚拟操作,保证数据能同时加入到上下文当中
                Thread.Sleep(100);
                context.SaveChanges();
            }
        }

引用:“坐联合数据的办法处理并发冲突固然好快节,但以业务逻辑较为复杂的网下并无相符利用这个处理方式。比如以大规模的Order、OrderItem的表中,OrderItem
的单价,数量会直接影响Order的一体化价格,这样使合并数据的道处理并发,有或勾逻辑性的荒唐。此时,应该考虑以另外方处理并发冲突。”。

别什么点子为?【待上】

 

4.1 除去与更新操作而运转(非框架自动处理能力,开发电动修改状态手动增加的)**

Entity Framework
能坐完美的编制灵活处理同时创新同一对象的操作,但如果删除操作和更新操作以运行时,就可能在逻辑性的异常。

如:两单客户端同时加载了同一个靶,第一独客户端更新了数后,把多少再次提交。但每当付给前,第二单客户端就把数据库中之既产生多少删除。

这时候,上下文中的对象处于不同之状态下,将会掀起
OptimisticConcurrencyException 异常(ObjectContext
和DBContext两种植方式下,异常不均等,具体要根据测试结果好看清)。
相遇是充分时,可以用 try(OptimisticConcurrencyException){…} catch
{…} 方式一网打尽异常,然后转对象的State 属性。把EntityState 更改为 Added
,被删去的数量就是会被另行加载。若将 EntityState 更改为 Detached
时,数据就会让顺利删除。下面将目标的 EntityState 属性更改为 Added
作为例子。

图片 13

代码如下:处理结果前后ID变化了(或许就即是发头架构师使用手动创建的GUID的道,而不使用自增的故有吧,因为数量删除后更创就回不到之前的ID了,不是最最巧,使用GUID再成数据版本(dataVison)字段,timeStamp基本上控制数据的产出已经足足啊。

//更新对象
        public int UpdateWithConcurrent(int num, Address addressValue)
        {
            int returnValue = -1;
            using (OrderDBContainer context = new OrderDBContainer())
            {
                var obj = context.AddressSet.Where(x => x.Id == addressValue.Id).First();
                //显示对象所处状态
                DisplayState("Before Update", obj);
                try
                {
                    if (obj != null)
                        context.Entry(obj).CurrentValues.SetValues(addressValue);
                    //虚拟操作,保证数据已经在数据库中被异步删除
                    Thread.Sleep(300);
                    context.SaveChanges();
                    returnValue = obj.Id;
                }
                catch (Exception)
                {
                    //针对异常要做相应的判断,因为我只测试了删除的情况,就写死直接修改成Added 了
                    //正确的是要区分到底是修改还是删除  OptimisticConcurrencyException ex
                    //把对象的状态更改为 Added
                    context.Entry(obj).State = System.Data.Entity.EntityState.Added;
                    context.SaveChanges();
                    returnValue = obj.Id;
                }
            }
            return returnValue;
        }

连发时的老大类型:

图片 14

ID发生了转移

图片 15

 

4.1 除去与更新操作以运行(非框架自动处理能力,开发活动修改状态手动增加的)**

Entity Framework
能坐完善之机制灵活处理同时创新同一对象的操作,但如果删除操作与创新操作以运行时,就可能有逻辑性的生。

如:两只客户端同时加载了同一个对象,第一独客户端更新了数后,把多少再度提交。但当交付前,第二只客户端就把数据库中的既发出多少删除。

这时,上下文中的目标处于不同之状态下,将会掀起
OptimisticConcurrencyException 异常(ObjectContext
以及DBContext两种植方式下,异常不相同,具体要根据测试结果自己看清)。
碰到是充分时,可以据此 try(OptimisticConcurrencyException){…} catch
{…} 方式一网打尽异常,然后转对象的State 属性。把EntityState 更改为 Added
,被删的数量就是会叫另行加载。若将 EntityState 更改为 Detached
时,数据就会为顺利删除。下面将目标的 EntityState 属性更改为 Added
作为例子。

图片 16

代码如下:处理结果前后ID变化了(或许就就是发生来架构师使用手动创建的GUID的章程,而非使自增的缘故之一吧,因为数量删除后重新创就回不到之前的ID了,不是最好灵活,使用GUID再成数据版本(dataVison)字段,timeStamp基本上控制数据的面世已经足足啊。

//更新对象
        public int UpdateWithConcurrent(int num, Address addressValue)
        {
            int returnValue = -1;
            using (OrderDBContainer context = new OrderDBContainer())
            {
                var obj = context.AddressSet.Where(x => x.Id == addressValue.Id).First();
                //显示对象所处状态
                DisplayState("Before Update", obj);
                try
                {
                    if (obj != null)
                        context.Entry(obj).CurrentValues.SetValues(addressValue);
                    //虚拟操作,保证数据已经在数据库中被异步删除
                    Thread.Sleep(300);
                    context.SaveChanges();
                    returnValue = obj.Id;
                }
                catch (Exception)
                {
                    //针对异常要做相应的判断,因为我只测试了删除的情况,就写死直接修改成Added 了
                    //正确的是要区分到底是修改还是删除  OptimisticConcurrencyException ex
                    //把对象的状态更改为 Added
                    context.Entry(obj).State = System.Data.Entity.EntityState.Added;
                    context.SaveChanges();
                    returnValue = obj.Id;
                }
            }
            return returnValue;
        }

并发时的充分类型:

图片 17

ID发生了别

图片 18

 

4.3 当有数出现时,保留最后(最新:最后一次等)输入的多少

如证明输入对象的性,必须先行管欠属性之 ConcurencyMode 设置也
Fixed,这样系统就是见面实时检测对象属性的输入值 。
当该属性被以创新,系统便会激发 OptimisticConcurrencyException
异常。捕获该特别后,可以行使 ObjectContext.Refresh (RefreshMode,object)
刷新及下文中该对象的状态,当 RefreshMode 为 ClientWins
时,系统以见面保持内外文中的今天有数量,即保留最新输入的目标值。此时再度运ObjectContext.SaveChanges,
系统便会拿最新输入的对象值在数据库中。

每当底下的例子当,系统启动前先把 Person 的 FirstName、SecondName
两单属性之 ConcurencyMode
属性设置也Fixed,使系统能监视这简单独特性之变动。所输入的数据就在FirstName、SecondName
两单价值备受作出修改。在数交到前先行坐 DisplayProperty
方法显示数据库最初的数目性,在数额初次更新后再行调用 DisplayProperty
显示更新后的数额性。在次坏创新数据经常,由调用ObjectContext.SaveChanges时,数据库被的数据就让涂改,与当前达成产卵文ObjectContext
的数量是冲突,系统将激起OptimisticConcurrencyException
异常,此时把吸引那个的目标属性再次展示出来。对老进行处理后,显示数据库被最后的对象值。

 

 

观测测试结果,可见当RefreshMode状态为ClientWins时,系统以见面保留上下文当中的目标属性,使用这方式可于出起异常时保持最新输入的目标属性。

 

4.3 当起数出现时,保留最后(最新:最后一不成)输入的多寡

倘证明输入对象的性质,必须先行将该属性之 ConcurencyMode 设置为
Fixed,这样系统就见面实时检测对象属性之输入值 。
当该属性为同时更新,系统即会激起 OptimisticConcurrencyException
异常。捕获该生后,可以下 ObjectContext.Refresh (RefreshMode,object)
刷新高达下文中该目标的状态,当 RefreshMode 为 ClientWins
时,系统将会见维持内外文中的现发数据,即保留最新输入的对象值。此时再使用ObjectContext.SaveChanges,
系统就是会见将最新输入的靶子值在数据库中。

以下面的事例当,系统启动前先行将 Person 的 FirstName、SecondName
两独特性的 ConcurencyMode
属性设置为Fixed,使系统能够监视这有限单特性的变更。所输入的多少只有于FirstName、SecondName
两独价值备受作出修改。在数量交到前先行盖 DisplayProperty
方法显示数据库最初的数量性,在数码初次更新后重新调用 DisplayProperty
显示更新后的数目性。在亚涂鸦创新数据时,由调用ObjectContext.SaveChanges时,数据库被的数额已经被改动,与眼前及产文ObjectContext
的多寡是冲突,系统以激励OptimisticConcurrencyException
异常,此时把吸引那个的目标属性再次显示出。对好进行处理后,显示数据库中最后的对象值。

 

 

考察测试结果,可见当RefreshMode状态为ClientWins时,系统将会见保留上下文当中的目标属性,使用是方式可以产生起异常时保持最新输入的对象属性。

 

4.4 当发生数出现时,保留最早(最初:最早同糟糕)输入的数额

拿目标属性之 ConcurencyMode 设置也 Fixed 后,同时更新该属性,将见面激起
OptimisticConcurrencyException 异常。此时动 ObjectContext.Refresh
(RefreshMode,object) 刷新及下文中该目标的状态,当 RefreshMode 为
StoreWins 时,系统就是见面把数据源中之多少代表上下文中的多少。
坐长调用 SaveChanges,数据足以成功保存及数据库。但是于 ObjectContext
并未释放时,再次使用 SaveChanges
异步更新数据,就会见引发OptimisticConcurrencyException 并发异常。当
RefreshMode 为 StoreWins 时,系统即见面保留初次输入的多寡性。
这例子与方的例子十分相似,只是把 RefreshMode 改吧 StoreWins
而已。在事情逻辑较为复杂的的系统中,建议采用这个措施处理并发异常。在保留最初输入的多寡修改属性后,把属性返还深受客户,让客户开展对比后再也决定下一致步之处理方式。

图片 19

图片 20

 

相测试结果,可见当 RefreshMode 状态呢 StoreWins
时,系统将会见因数据源中之多少代表上下文当中的靶子属性。在事情逻辑较为复杂的的系统中,建议使用这个措施处理并发异常。


链接: https://pan.baidu.com/s/1gfu6fZl 密码: fyb3

勤学苦练的源码,有正的荒唐的爱人记得分享

4.4 当发生多少出现时,保留最早(最初:最早同次于)输入的数据

将目标属性的 ConcurencyMode 设置为 Fixed 后,同时创新该属性,将会晤刺激
OptimisticConcurrencyException 异常。此时使 ObjectContext.Refresh
(RefreshMode,object) 刷新上下文中该目标的状态,当 RefreshMode 为
StoreWins 时,系统便会见拿数据源中之数据代表上下文中的数量。
盖正调用 SaveChanges,数据可以成功保存到数据库。但是于 ObjectContext
并未释放时,再次用 SaveChanges
异步更新数据,就会掀起OptimisticConcurrencyException 并发异常。当
RefreshMode 为 StoreWins 时,系统就是会见保留初次输入的数性。
本条例子与地方的事例十分相似,只是将 RefreshMode 改呢 StoreWins
而已。在业务逻辑较为复杂的底网当中,建议用这个方法处理并发异常。在保留最初输入的数修改属性后,把属性返还让客户,让客户进行自查自纠后重新决定下一样步的处理方式。

图片 21

图片 22

 

察测试结果,可见当 RefreshMode 状态呢 StoreWins
时,系统以见面以数据源中之数代表上下文当中的目标属性。在业务逻辑较为复杂的底网中,建议采用这个方法处理并发异常。


链接: https://pan.baidu.com/s/1gfu6fZl 密码: fyb3

练的源码,有正的缪的爱侣记得分享

相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图