MVC实用构架设计（三）——EF-Code First（6）：数据更新最佳实践

前言

　　最近在整理EntityFramework数据更新的代码，颇有体会，觉得有分享的价值，于是记录下来，让需要的人少走些弯路也是好的。

　　为方便起见，先创建一个控制台工程，使用using(var db = new DataContext)的形式来一步一步讲解EF数据更新的可能会遇到的问题及对应的解决方案。在获得最佳方案之后，再整合到本系列的代码中。

　　本示例中，用到的数据模型如下图所示：

　　

1. 部门：一个部门可有多个角色【1-N】
2. 角色：一个角色必有一个部门【N-1】，一个角色可有多个人员【N-N】
3. 人员：一个人员可有多个角色【N-N】

　　并且，我们通过数据迁移策略初始化了一些数据：

protected override void Seed(GmfEFUpdateDemo.Models.DataContext context)
{
    //部门
    var departments = new []
    {
        new Department {Name = "技术部"},
        new Department {Name = "财务部"}
    };
    context.Departments.AddOrUpdate(m => new {m.Name}, departments);
    context.SaveChanges();

    //角色
    var roles = new[]
    {
        new Role{Name = "技术部经理", Department = context.Departments.Single(m=>m.Name =="技术部")},
        new Role{Name = "技术总监", Department = context.Departments.Single(m=>m.Name =="技术部")},
        new Role{Name = "技术人员", Department = context.Departments.Single(m=>m.Name =="技术部")},
        new Role{Name = "财务部经理", Department = context.Departments.Single(m=>m.Name =="财务部")},
        new Role{Name = "会计", Department = context.Departments.Single(m=>m.Name =="财务部")}
    };
    context.Roles.AddOrUpdate(m=>new{m.Name}, roles);
    context.SaveChanges();

    //人员
    var members = new[]
    {
        new Member
        {
            UserName = "郭明锋",
            Password = "123456",
            Roles = new HashSet<Role>
            {
                context.Roles.Single(m => m.Name == "技术人员")
            }
        }
    };
    context.Members.AddOrUpdate(m => new {m.UserName}, members);
    context.SaveChanges();
}

 

整体更新（不考虑更新属性）

情景一：同一上下文中数据取出来更新后直接保存：

　　代码：

private static void Method01()
{
    using (var db = new DataContext())
    {
        const string userName = "郭明锋";
        Member oldMember = db.Members.Single(m => m.UserName == userName);
        Console.WriteLine("更新前：{0}。", oldMember.AddDate);

        oldMember.AddDate = oldMember.AddDate.AddMinutes(10);
        int count = db.SaveChanges();
        Console.WriteLine("操作结果：{0}", count > 0 ? "更新成功。" : "未更新。");

        Member newMember = db.Members.Single(m => m.UserName == userName);
        Console.WriteLine("更新后：{0}。", newMember.AddDate);
    }
}

　　代码解析：操作必然成功，执行的sql语句如下：　　

exec sp_executesql N'update [dbo].[Members]
set [AddDate] = @0
where ([Id] = @1)
',N'@0 datetime2(7),@1 int',@0='2013-08-31 13:17:33.1570000',@1=1

　　注意，这里并没有对更新实体的属性进行筛选，但EF还是聪明的生成了只更新AddDate属性的sql语句。

情景二：从上下文1中取出数据并修改，再在上下文2中进行保存：

 　　代码：

private static void Method02()
{
    const string userName = "郭明锋";

    Member updateMember;
    using (var db1 = new DataContext())
    {
        updateMember = db1.Members.Single(m => m.UserName == userName);
    }
    updateMember.AddDate = DateTime.Now;

    using (var db2 = new DataContext())
    {
        db2.Members.Attach(updateMember);
        DbEntityEntry<Member> entry = db2.Entry(updateMember);
        Console.WriteLine("Attach成功后的状态：{0}", entry.State); //附加成功之后，状态为EntityState.Unchanged
        entry.State = EntityState.Modified;
        int count = db2.SaveChanges();
        Console.WriteLine("操作结果：{0}", count > 0 ? "更新成功。" : "未更新。");

        Member newMember = db2.Members.Single(m => m.UserName == userName);
        Console.WriteLine("更新后：{0}。", newMember.AddDate);
    }
}

　　代码解析：对于db2而言，updateMemner是一个全新的外来的它不认识的对象，所以需要使用Attach方法把这个外来对象附加到它的上下文中，Attach之后，实体的对象为 EntityState.Unchanged，如果不改变状态，在SaveChanged的时候将什么也不做。因此还需要把状态更改为EntityState.Modified，而由Unchanged -> Modified的改变，是我们强制的，而不是由EF状态跟踪得到的结果，因而EF无法分辨出哪个属性变更了，因而将不分青红皂白地将所有属性都刷一遍，执行如下sql语句：

exec sp_executesql N'update [dbo].[Members]
set [UserName] = @0, [Password] = @1, [AddDate] = @2, [IsDeleted] = @3
where ([Id] = @4)
',N'@0 nvarchar(50),@1 nvarchar(50),@2 datetime2(7),@3 bit,@4 int',@0=N'郭明锋',@1=N'123456',@2='2013-08-31 13:28:01.9400328',@3=0,@4=1

 情景三：在情景二的基础上，上下文2中已存在与外来实体主键相同的数据了

　　代码：

private static void Method03()
{
    const string userName = "郭明锋";

    Member updateMember;
    using (var db1 = new DataContext())
    {
        updateMember = db1.Members.Single(m => m.UserName == userName);
    }
    updateMember.AddDate = DateTime.Now;

    using (var db2 = new DataContext())
    {
        //先查询一次，让上下文中存在相同主键的对象
        Member oldMember = db2.Members.Single(m => m.UserName == userName);
        Console.WriteLine("更新前：{0}。", oldMember.AddDate);

        db2.Members.Attach(updateMember);
        DbEntityEntry<Member> entry = db2.Entry(updateMember);
        Console.WriteLine("Attach成功后的状态：{0}", entry.State); //附加成功之后，状态为EntityState.Unchanged
        entry.State = EntityState.Modified;
        int count = db2.SaveChanges();
        Console.WriteLine("操作结果：{0}", count > 0 ? "更新成功。" : "未更新。");

        Member newMember = db2.Members.Single(m => m.UserName == userName);
        Console.WriteLine("更新后：{0}。", newMember.AddDate);
    }
}

 　　代码解析：此代码与情景二相比，就是多了14~16三行代码，目的是制造一个要更新的数据在上下文2中正在使用的场景，这时会发生什么情况呢？

　　当代码执行到18行的Attach的时候，将引发一个EF数据更新时非常常见的异常：

捕捉到 System.InvalidOperationException
  HResult=-2146233079
  Message=ObjectStateManager 中已存在具有同一键的对象。ObjectStateManager 无法跟踪具有相同键的多个对象。
  Source=System.Data.Entity
  StackTrace:
       在 System.Data.Objects.ObjectContext.VerifyRootForAdd(Boolean doAttach, String entitySetName, IEntityWrapper wrappedEntity, EntityEntry existingEntry, EntitySet& entitySet, Boolean& isNoOperation)
       在 System.Data.Objects.ObjectContext.AttachTo(String entitySetName, Object entity)
       在 System.Data.Entity.Internal.Linq.InternalSet`1.<>c__DisplayClass2.<Attach>b__1()
       在 System.Data.Entity.Internal.Linq.InternalSet`1.ActOnSet(Action action, EntityState newState, Object entity, String methodName)
       在 System.Data.Entity.Internal.Linq.InternalSet`1.Attach(Object entity)
       在 System.Data.Entity.DbSet`1.Attach(TEntity entity)
       在 GmfEFUpdateDemo.Program.Method03() 位置 d:\Documents\Visual Studio 2012\Projects\GmfEFUpdateDemo\GmfEFUpdateDemo\Program.cs:行号 148
       在 GmfEFUpdateDemo.Program.Main(String[] args) 位置 d:\Documents\Visual Studio 2012\Projects\GmfEFUpdateDemo\GmfEFUpdateDemo\Program.cs:行号 54
  InnerException: 

 　　原因正是上下文2中已经有了一个相同主键的对象，不能再附加了。

 　　这应该是一个非常常见的场景，也就是必须想办法解决的场景。其实只要获得现有实体数据的跟踪，再把新数据赋到现有实体上，就可以解决问题了，此方法唯一的缺点就是要获取到旧的实体数据。代码如下：

private static void Method04()
{
    const string userName = "郭明锋";

    Member updateMember;
    using (var db1 = new DataContext())
    {
        updateMember = db1.Members.Single(m => m.UserName == userName);
    }
    updateMember.AddDate = DateTime.Now;

    using (var db2 = new DataContext())
    {
        //先查询一次，让上下文中存在相同主键的对象
        Member oldMember = db2.Members.Single(m => m.UserName == userName);
        Console.WriteLine("更新前：{0}。", oldMember.AddDate);

        DbEntityEntry<Member> entry = db2.Entry(oldMember);
        entry.CurrentValues.SetValues(updateMember);
        int count = db2.SaveChanges();
        Console.WriteLine("操作结果：{0}", count > 0 ? "更新成功。" : "未更新。");

        Member newMember = db2.Members.Single(m => m.UserName == userName);
        Console.WriteLine("更新后：{0}。", newMember.AddDate);
    }
}

　　代码中的18~19行是核心代码，先从上下文中的旧实体获取跟踪，第19行的SetValues方法就是把新值设置到旧实体上（这一条很强大,支持任何类型，比如ViewObject,DTO与POCO可以直接映射传值）。由于值的更新是直接在上下文中的现有实体上进行的，EF会自己跟踪值的变化，因此这里并不需要我们来强制设置状态为Modified，执行的sql语句也足够简单：

exec sp_executesql N'update [dbo].[Members]
set [AddDate] = @0
where ([Id] = @1)
',N'@0 datetime2(7),@1 int',@0='2013-08-31 14:03:27.1425875',@1=1

整体更新的最佳实现

　　综合上面的几种情景，我们可以得到EF对实体整体更新的最佳方案，这里写成DbContext的扩展方法，代码如下：

public static void Update<TEntity>(this DbContext dbContext, params TEntity[] entities) where TEntity : EntityBase
{
    if (dbContext == null) throw new ArgumentNullException("dbContext");
    if (entities == null) throw new ArgumentNullException("entities");

    foreach (TEntity entity in entities)
    {
        DbSet<TEntity> dbSet = dbContext.Set<TEntity>();
        try
        {
            DbEntityEntry<TEntity> entry = dbContext.Entry(entity);
            if (entry.State == EntityState.Detached)
            {
                dbSet.Attach(entity);
                entry.State = EntityState.Modified;
            }
        }
        catch (InvalidOperationException)
        {
            TEntity oldEntity = dbSet.Find(entity.Id);
            dbContext.Entry(oldEntity).CurrentValues.SetValues(entity);
        } 
    }
}

　　调用代码如下：

db.Update<Member>(member);
int count = db.SaveChanges();

　　 针对不同的情景，将执行不同的行为：

• 情景一：上面代码第11行执行后entry.State将为EntityState.Modified，会直接退出此Update方法直接进入SaveChanges的执行。此情景执行的sql语句为只更新变更的实体属性。
• 情景二：将正确执行 try 代码块。此情景执行的sql语句为更新全部实体属性。
• 情景三：在代码执行到第12行的Attach方法时将抛出 InvalidOperationException 异常，接着执行 catch 代码块。此情景执行的sql语句为只更新变更的实体属性。 

按需更新（更新指定实体属性）

需求分析

　　前面已经有整体更新了，很多时候也都能做到只更新变化的实体属性，为什么还要来个“按需更新”的需求呢？主要基于以下几点理由：

• 整体更新中获取数据的变更是要把新值与原始值的属性一一对比的，因而整体更新要从数据库中获取完整的实体数据，以保证被更新的只有我们想要改变的实体属性，这样进行整体更新时至少要从数据库中查询一次数据。
• 执行的更新语句有可能是更新所有实体属性的（如上的情景三），如果实体属性很多，就容易造成计算资源的浪费（因为我们只需要更新其中的某几个属性值）。
• 不能只更新指定的实体属性，有了按需更新，我们可以非常方便的只更新指定的属性，没有指定的属性即使值变化了也不更新

需求实现

　　按需更新，也就是知道要更新的实体属性，比如用户要修改密码，就只是要把Password这个属性的值变更为指定的新值，其他的最好是尽量不惊动。当然，至少还是要知道要更新数据的主键的，否则，更新对象就不明了。下面就以设置密码为例来说明问题。

　　要设置密码，我构造了一个空的Member类来装载新密码：

Member member = new Member {Id = 1, Password = "NewPassword" + DateTime.Now.Second};

　　然后，我们想当然的写出了如下实现代码：

private static void Method06()
{
    Member member = new Member {Id = 1, Password = "NewPassword" + DateTime.Now.Second};
    using (var db = new DataContext())
    {
        DbEntityEntry<Member> entry = db.Entry(member);
        entry.State = EntityState.Unchanged;
        entry.Property("Password").IsModified = true;
        int count = db.SaveChanges();
        Console.WriteLine("操作结果：{0}", count > 0 ? "更新成功。" : "未更新。");

        Member newMember = db.Members.Single(m => m.Id == 1);
        Console.WriteLine("更新后：{0}。", newMember.Password);
    }
}

　　 然后，在执行第9行SaveChanges的时候引发了如下异常：

捕捉到 System.Data.Entity.Validation.DbEntityValidationException
  HResult=-2146232032
  Message=对一个或多个实体的验证失败。有关详细信息，请参见“EntityValidationErrors”属性。
  Source=EntityFramework
  StackTrace:
       在 System.Data.Entity.Internal.InternalContext.SaveChanges()
       在 System.Data.Entity.Internal.LazyInternalContext.SaveChanges()
       在 System.Data.Entity.DbContext.SaveChanges()
       在 GmfEFUpdateDemo.Program.Method06() 位置 d:\Documents\Visual Studio 2012\Projects\GmfEFUpdateDemo\GmfEFUpdateDemo\Program.cs:行号 224
       在 GmfEFUpdateDemo.Program.Main(String[] args) 位置 d:\Documents\Visual Studio 2012\Projects\GmfEFUpdateDemo\GmfEFUpdateDemo\Program.cs:行号 63
  InnerException: 

 　　为什么出现此异常？因为前面我们创建的Member对象只包含一个Id，一个Password属性，其他的属性并没有赋值，也不考虑是否规范，这样就定义出了一个不符合实体类验证定义的对象了（Member类要求UserName属性是不可为空的）。幸好，DbContext.Configuration中给我们定义了是否在保存时验证实体有效性（ValidateOnSaveEnabled）这个开关，我们只要在执行按需更新的保存时把验证闭，在保存成功后再开启即可，更改代码如下：

private static void Method06()
{
    Member member = new Member {Id = 1, Password = "NewPassword" + DateTime.Now.Second};
    using (var db = new DataContext())
    {
        DbEntityEntry<Member> entry = db.Entry(member);
        entry.State = EntityState.Unchanged;
        entry.Property("Password").IsModified = true;
        db.Configuration.ValidateOnSaveEnabled = false;
        int count = db.SaveChanges();
        db.Configuration.ValidateOnSaveEnabled = true;
        Console.WriteLine("操作结果：{0}", count > 0 ? "更新成功。" : "未更新。");

        Member newMember = db.Members.Single(m => m.Id == 1);
        Console.WriteLine("更新后：{0}。", newMember.Password);
    }
}

 　　与整体更新一样，理所当然的会出现当前上下文已经存在了相同主键的实体数据的情况，当然，根据之前的经验，也很容易的进行处理了：

    private static void Method07()
    {
        Member member = new Member { Id = 1, Password = "NewPassword" + DateTime.Now.Second };
        using (var db = new DataContext())
        {
            //先查询一次，让上下文中存在相同主键的对象
            Member oldMember = db.Members.Single(m => m.Id == 1);
            Console.WriteLine("更新前：{0}。", oldMember.AddDate);

            try
            {
                DbEntityEntry<Member> entry = db.Entry(member);
                entry.State = EntityState.Unchanged;
                entry.Property("Password").IsModified = true;
            }
            catch (InvalidOperationException)
            {
                DbEntityEntry<Member> entry = db.Entry(oldMember);
                entry.CurrentValues.SetValues(member);
                entry.State = EntityState.Unchanged;
                entry.Property("Password").IsModified = true;
            }
            db.Configuration.ValidateOnSaveEnabled = false;
            int count = db.SaveChanges();
            db.Configuration.ValidateOnSaveEnabled = true;
            Console.WriteLine("操作结果：{0}", count > 0 ? "更新成功。" : "未更新。");

            Member newMember = db.Members.Single(m => m.Id == 1);
            Console.WriteLine("更新后：{0}。", newMember.Password);
        }
    }

 　　但是，上面的代码却无法正常工作，经过调试发现，当执行到第20行的时候，entry中跟踪的数据又变回oldMember了，经过一番EntityFramework源码搜索，终于找到了问题的出处（System.Data.Entity.Internal.InternalEntityEntry类中）：

    public EntityState State
    {
      get
      {
        if (!this.IsDetached)
          return this._stateEntry.State;
        else
          return EntityState.Detached;
      }
      set
      {
        if (!this.IsDetached)
        {
          if (this._stateEntry.State == EntityState.Modified && value == EntityState.Unchanged)
            this.CurrentValues.SetValues(this.OriginalValues);
          this._stateEntry.ChangeState(value);
        }
        else
        {
          switch (value)
          {
            case EntityState.Unchanged:
              this._internalContext.Set(this._entityType).InternalSet.Attach(this._entity);
              break;
            case EntityState.Added:
              this._internalContext.Set(this._entityType).InternalSet.Add(this._entity);
              break;
            case EntityState.Deleted:
            case EntityState.Modified:
              this._internalContext.Set(this._entityType).InternalSet.Attach(this._entity);
              this._stateEntry = this._internalContext.GetStateEntry(this._entity);
              this._stateEntry.ChangeState(value);
              break;
          }
        }
      }
    }

　　第14、15行，当状态由Modified更改为Unchanged的时候，又把数据重新设置为旧的数据OriginalValues了。真吭！

　　好吧，看来在DbContext中折腾已经没戏了，只要去它老祖宗ObjectContext中找找出路，更改实现如下：

    private static void Method08()
    {
        Member member = new Member { Id = 1, Password = "NewPassword" + DateTime.Now.Second };
        using (var db = new DataContext())
        {
            //先查询一次，让上下文中存在相同主键的对象
            Member oldMember = db.Members.Single(m => m.Id == 1);
            Console.WriteLine("更新前：{0}。", oldMember.AddDate);

            try
            {
                DbEntityEntry<Member> entry = db.Entry(member);
                entry.State = EntityState.Unchanged;
                entry.Property("Password").IsModified = true;
            }
            catch (InvalidOperationException)
            {
                ObjectContext objectContext = ((IObjectContextAdapter)db).ObjectContext;
                ObjectStateEntry objectEntry = objectContext.ObjectStateManager.GetObjectStateEntry(oldMember);
                objectEntry.ApplyCurrentValues(member);
                objectEntry.ChangeState(EntityState.Unchanged);
                objectEntry.SetModifiedProperty("Password");
            }
            db.Configuration.ValidateOnSaveEnabled = false;
            int count = db.SaveChanges();
            db.Configuration.ValidateOnSaveEnabled = true;
            Console.WriteLine("操作结果：{0}", count > 0 ? "更新成功。" : "未更新。");

            Member newMember = db.Members.Single(m => m.Id == 1);
            Console.WriteLine("更新后：{0}。", newMember.Password);
        }
    }

 　　catch代码块使用了EF4.0时代使用的ObjectContext来实现，很好的达到了我们的目的，执行的sql语句如下：

exec sp_executesql N'update [dbo].[Members]
set [Password] = @0
where ([Id] = @1)
',N'@0 nvarchar(50),@1 int',@0=N'NewPassword2',@1=1

 封装重构的分析

　　以上的实现中，属性名都是以硬编码的形式直接写到实现类中，作为底层的封闭，这是肯定不行的，至少也要作为参数传递到一个通用的更新方法中。参照整体更新的扩展方法定义，我们很容易的就能定义出如下签名的扩展方法：

public static void Update<TEntity>(this DbContext dbContext, string[] propertyNames, params TEntity[] entities) where TEntity : EntityBase
方法调用方式：
dbContext.Update<Member>(new[] {"Password"}, member);

 　　调用中属性名依然要使用字符串的方式，写起来麻烦，还容易出错。看来，强类型才是最好的选择。

　　写到这，突然想起了做数据迁移的时候使用到的System.Data.Entity.Migrations.IDbSetExtensions 类中的扩展方法

public static void AddOrUpdate<TEntity>(this IDbSet<TEntity> set, Expression<Func<TEntity, object>> identifierExpression, params TEntity[] entities) where TEntity : class

 　　其中的参数Expression<Func<TEntity, object>> identifierExpression就是用于传送实体属性名的，于是，我们参照着，可以定义出如下签名的更新方法：

public static void Update<TEntity>(this DbContext dbContext, Expression<Func<TEntity, object>> propertyExpression, params TEntity[] entities) where TEntity : EntityBase

方法调用方式：
db.Update<Member>(m => new { m.Password }, member);

　　到这里，如何从Expression<Func<TEntity, object>>获得属性名成为了完成封闭的关键。还是经过调试，有了如下发现：

　　

　　运行时的Expression表达式中，Body属性中有个类型为ReadOnlyCollection<MemberInfo> 的 Members集合属性，我们需要的属性正以MemberInfo的形式存在其中，因此，我们借助一下 dynamic 类型，将Members属性解析出来，即可轻松得到我们想的数据。

ReadOnlyCollection<MemberInfo> memberInfos = ((dynamic)propertyExpression.Body).Members;

按需更新的最佳实现

　　经过上面的分析，难点已逐个击破，很轻松的就得到了如下扩展方法的实现：

    public static void Update<TEntity>(this DbContext dbContext, Expression<Func<TEntity, object>> propertyExpression, params TEntity[] entities)
        where TEntity : EntityBase
    {
        if (propertyExpression == null) throw new ArgumentNullException("propertyExpression");
        if (entities == null) throw new ArgumentNullException("entities");
        ReadOnlyCollection<MemberInfo> memberInfos = ((dynamic)propertyExpression.Body).Members;
        foreach (TEntity entity in entities)
        {
            try
            {
                DbEntityEntry<TEntity> entry = dbContext.Entry(entity);
                entry.State = EntityState.Unchanged;
                foreach (var memberInfo in memberInfos)
                {
                    entry.Property(memberInfo.Name).IsModified = true;
                }
            }
            catch (InvalidOperationException)
            {
                TEntity originalEntity = dbContext.Set<TEntity>().Local.Single(m => m.Id == entity.Id);
                ObjectContext objectContext = ((IObjectContextAdapter)dbContext).ObjectContext;
                ObjectStateEntry objectEntry = objectContext.ObjectStateManager.GetObjectStateEntry(originalEntity);
                objectEntry.ApplyCurrentValues(entity);
                objectEntry.ChangeState(EntityState.Unchanged);
                foreach (var memberInfo in memberInfos)
                {
                    objectEntry.SetModifiedProperty(memberInfo.Name);
                }
            }
        }
    }

 

　　注意，这里的第20行虽然进行了原始数据的查询，但是从DbSet<T>.Local中进行的查询，而且前面的异常，也确定了Local中一定存在一个主键相同的原始数据，所以敢用Single直接获取。可以放心的是，这里并不会走数据库查询。

　　除此之外，还有一个可以封闭的地方就是关闭了ValidateOnSaveEnabled属性的SaveChanges方法，可封闭为如下：

    public static int SaveChanges(this DbContext dbContext, bool validateOnSaveEnabled)
    {
        bool isReturn = dbContext.Configuration.ValidateOnSaveEnabled != validateOnSaveEnabled;
        try
        {
            dbContext.Configuration.ValidateOnSaveEnabled = validateOnSaveEnabled;
            return dbContext.SaveChanges();
        }
        finally
        {
            if (isReturn)
            {
                dbContext.Configuration.ValidateOnSaveEnabled = !validateOnSaveEnabled;
            }
        }
    }

 　　辛苦不是白费的，经过一番折腾，我们的按需更新实现起来就非常简单了：

    private static void Method09()
    {
        Member member = new Member { Id = 1, Password = "NewPassword" + DateTime.Now.Second };
        using (var db = new DataContext())
        {
            //先查询一次，让上下文中存在相同主键的对象
            Member oldMember = db.Members.Single(m => m.Id == 1);
            Console.WriteLine("更新前：{0}。", oldMember.AddDate);

            db.Update<Member>(m => new { m.Password }, member);
            int count = db.SaveChanges(false);
            Console.WriteLine("操作结果：{0}", count > 0 ? "更新成功。" : "未更新。");

            Member newMember = db.Members.Single(m => m.Id == 1);
            Console.WriteLine("更新后：{0}。", newMember.Password);
        }
    }

 　　只需要第10，11行两行代码，即可完成完美的按需更新功能。

　　这里需要特别注意的是，此按需更新的方法只适用于使用新建上下文的环境中，即using(var db = DataContext()){ }，因为我们往上下文中附加了一个非法的实体类（比如上面的member），当提交更改之后，这个非法的实体类依然会存在于上下文中，如果使用这个上下文进行后续的其他操作，将有可能出现异常。尝试过在SaveChanges之后将该实体从上下文中移除，跟踪系统会将该实体变更为删除状态，在下次SaveChanges的时候将之删除，这个问题本人暂时还没有好的解决方案，在此特别说明。

源码获取

　　本文示例源码下载：GmfEFUpdateDemo.zip

　　为了让大家能第一时间获取到本架构的最新代码，也为了方便我对代码的管理，本系列的源码已加入微软的开源项目网站 http://www.codeplex.com，地址为：

　　https://gmframework.codeplex.com/

　　可以通过下列途径获取到最新代码：

• 如果你是本项目的参与者，可以通过VS自带的团队TFS直接连接到 https://tfs.codeplex.com:443/tfs/TFS17 获取最新代码
• 如果你安装有SVN客户端（亲测TortoiseSVN 1.6.7可用），可以连接到 https://gmframework.svn.codeplex.com/svn 获取最新代码
• 如果以上条件都不满足，你可以进入页面 https://gmframework.codeplex.com/SourceControl/latest 查看最新代码，也可以点击页面上的 Download 链接进行压缩包的下载，你还可以点击页面上的 History 链接获取到历史版本的源代码

• 如果你想和大家一起学习MVC，学习EF，欢迎加入群：5008599（群发言仅限技术讨论，拒绝闲聊，拒绝酱油，拒绝广告）
• 如果你想与我共同来完成这个开源项目，可以随时联系我。

系列导航

1. MVC实用架构设计（〇）——总体设计
2. MVC实用架构设计（一）——项目结构搭建
3. MVC实用架构设计（二）——使用MEF实用IOC
4. MVC实用架构设计（三）——EF-Code First(1)：Repository，UnitOfWork，DbContext
5. MVC实用架构设计（三）——EF-Code First(2)：实体映射、数据迁移，重构
6. MVC实用架构设计（三）——EF-Code First(3)：使用T4模板生成相似代码
7. MVC实用架构设计（三）——EF-Code First(4)：数据查询
8. MVC实用架构设计（三）——EF-Code First(5)：二级缓存
9. MVC实体架构设计（三）——EF-COde First(6)：数据更新
10. 未完待续。。。