EF Core 三 、 EF Core CRUD

EF Core CRUD

上篇文章中，我们已经基本入门了EFCore，搭建了一个简单的EFCore项目，本文开始简单使用下EF，做增删改查的相关操作；

一、数据新增操作（C）

        public static async void Insert_测试新增数据1()
        {
            var myDbContext = new MyDbContext();
            if (myDbContext.TestTables.Any(p => p.Id == 1)) return;
            var newEntity = new TestTable
            {
                Id = 1,
                Name = "主表数据1"
            };

            await myDbContext.TestTables.AddAsync(newEntity);
            myDbContext.SaveChanges();

            Console.WriteLine($"TestTable Insert Success");
            Console.WriteLine($"------------------------");
        }

是不是很简单的代码？so eays ...

我们还是来分析下整体代码的运行；

1.首先我们自己在代码段中新增了一个实体对象，并对其字段做赋值，然后通过Add方法加入到DbSet中

2.通过DbContext.SaveChanges提交数据到数据库保存

那EF是如何偷偷的在背后帮我们完成这一切的呢？

EFCore实体四状态， 如下四种状态；

 public enum EntityState
    {
        /// <summary>
        ///     The entity is not being tracked by the context.
        /// </summary>
        Detached = 0,
        /// <summary>
        ///     The entity is being tracked by the context and exists in the database. Its property
        ///     values have not changed from the values in the database.
        /// </summary>
        Unchanged = 1,
        /// <summary>
        ///     The entity is being tracked by the context and exists in the database. It has been marked
        ///     for deletion from the database.
        /// </summary>
        Deleted = 2,
        /// <summary>
        ///     The entity is being tracked by the context and exists in the database. Some or all of its
        ///     property values have been modified.
        /// </summary>
        Modified = 3,
        /// <summary>
        ///     The entity is being tracked by the context but does not yet exist in the database.
        /// </summary>
        Added = 4
    }

Detached : 实体未被跟踪

Unchanged：未修改

Deleted : 删除状态

Modified：修改状态

Added：新增状态

Detached 未被跟踪状态，很多同学可能无法理解了，EFCore会默认自动跟踪实体信息，用来维护实体状态，也是方便后续提交时的处理；EFCore提供两种查询方法，跟踪查/非跟踪查，跟踪查得到的数据是Unchanged，而非跟踪查的到的数据是Detached，这两种方式我们后面详细说明，这里先简单描述下；

EFCore管理内存实体

查看DbContext源码中的Add方法，跟踪方法，发现Add方法会调用到 EntityReferenceMap.cs 类中的Update方法 （下面的源码内容），此方法中EFCore会在内存中维护我们操作的实体信息，将我们操作的实体信息管理到内存中（我们的增删改查操作，EFCore都会再内存维护，方法中只是对实体状态维护，SaveChanges才会提交）；

 public virtual void Update(
            [NotNull] InternalEntityEntry entry,
            EntityState state,
            EntityState? oldState)
        {
            var mapKey = entry.Entity ?? entry;
            var entityType = entry.EntityType;
            if (_hasSubMap && entityType.HasDefiningNavigation())
            {
                if (_dependentTypeReferenceMap == null)
                {
                    _dependentTypeReferenceMap = new Dictionary<IEntityType, EntityReferenceMap>();
                }
                if (!_dependentTypeReferenceMap.TryGetValue(entityType, out var dependentMap))
                {
                    dependentMap = new EntityReferenceMap(hasSubMap: false);
                    _dependentTypeReferenceMap[entityType] = dependentMap;
                }
                dependentMap.Update(entry, state, oldState);
            }
            else
            {
                if (oldState.HasValue)
                {
                    Remove(mapKey, entityType, oldState.Value);
                }
                if (!oldState.HasValue || state != EntityState.Detached)
                {
                    switch (state)
                    {
                        case EntityState.Detached:
                            if (_detachedReferenceMap == null)
                            {
                                _detachedReferenceMap = new Dictionary<object, InternalEntityEntry>(ReferenceEqualityComparer.Instance);
                            }
                            _detachedReferenceMap[mapKey] = entry;
                            break;
                        case EntityState.Unchanged:
                            if (_unchangedReferenceMap == null)
                            {
                                _unchangedReferenceMap = new Dictionary<object, InternalEntityEntry>(ReferenceEqualityComparer.Instance);
                            }
                            _unchangedReferenceMap[mapKey] = entry;
                            break;
                        case EntityState.Deleted:
                            if (_deletedReferenceMap == null)
                            {
                                _deletedReferenceMap = new Dictionary<object, InternalEntityEntry>(ReferenceEqualityComparer.Instance);
                            }
                            _deletedReferenceMap[mapKey] = entry;
                            break;
                        case EntityState.Modified:
                            if (_modifiedReferenceMap == null)
                            {
                                _modifiedReferenceMap = new Dictionary<object, InternalEntityEntry>(ReferenceEqualityComparer.Instance);
                            }
                            _modifiedReferenceMap[mapKey] = entry;
                            break;
                        case EntityState.Added:
                            if (_addedReferenceMap == null)
                            {
                                _addedReferenceMap = new Dictionary<object, InternalEntityEntry>(ReferenceEqualityComparer.Instance);
                            }
                            _addedReferenceMap[mapKey] = entry;
                            break;
                    }
                }
            }
        }

代码中就是针对不同状态的实体，EF采用不同的集合进行维护，按照我们的测试代码，会将新增实体放入上面的_addedReferenceMap 集合中，方便EFCore做提交时的操作；

EFCore SaveChanges

然后来看下将实体加入到内存集合后，提交操作到底做了什么

首先跟踪到 DbContext的 SaveChanges方法，其内部会调用StateManger.SaveChanges方法，代码如下：

        public virtual int SaveChanges(bool acceptAllChangesOnSuccess)
        {
            if (ChangedCount == 0)
            {
                return 0;
            }
            var entriesToSave = GetEntriesToSave(cascadeChanges: true);
            if (entriesToSave.Count == 0)
            {
                return 0;
            }
            try
            {
                var result = SaveChanges(entriesToSave);
                if (acceptAllChangesOnSuccess)
                {
                    AcceptAllChanges((IReadOnlyList<IUpdateEntry>)entriesToSave);
                }
                return result;
            }
            catch
            {
                foreach (var entry in entriesToSave)
                {
                    ((InternalEntityEntry)entry).DiscardStoreGeneratedValues();
                }
                throw;
            }
        }

首先 GetEntriesToSave 方法，这个方法就是和上面的Add呼应，将EFCore加入到内存集合中管理的实体再次读取出来，得到一个entriesToSave集合，也就是需要保存的实体集合，看下其中的部分代码就是将内存集合中的数据得到

            if (!hasDependentTypes)
            {
                var numberOfStates
                    = (returnAdded ? 1 : 0)
                      + (returnModified ? 1 : 0)
                      + (returnDeleted ? 1 : 0)
                      + (returnUnchanged ? 1 : 0);

                if (numberOfStates == 1)
                {
                    if (returnUnchanged)
                    {
                        return _unchangedReferenceMap.Values;
                    }
                    if (returnAdded)
                    {
                        return _addedReferenceMap.Values;
                    }
                    if (returnModified)
                    {
                        return _modifiedReferenceMap.Values;
                    }
                    if (returnDeleted)
                    {
                        return _deletedReferenceMap.Values;
                    }
                }
                if (numberOfStates == 0)
                {
                    return Enumerable.Empty<InternalEntityEntry>();
                }
            }

可以看到将不同状态的实体集合返回，得到了一个需要保存的实体集合数据，那得到需要保存的实体之后，就需要执行数据库命令了；

整体的保存入口方法还是由 DbContext 提供，DbContext.SaveChanges 方法会调用到 BatchExecutor.cs类中的Execute方法

private int Execute(DbContext _, (IEnumerable<ModificationCommandBatch>, IRelationalConnection) parameters)
        {
            var commandBatches = parameters.Item1;
            var connection = parameters.Item2;
            var rowsAffected = 0;
            IDbContextTransaction startedTransaction = null;
            try
            {
                if (connection.CurrentTransaction == null
                    && (connection as ITransactionEnlistmentManager)?.EnlistedTransaction == null
                    && Transaction.Current == null
                    && CurrentContext.Context.Database.AutoTransactionsEnabled)
                {
                    startedTransaction = connection.BeginTransaction();
                }
                else
                {
                    connection.Open();
                }
                foreach (var batch in commandBatches)
                {
                    batch.Execute(connection);
                    rowsAffected += batch.ModificationCommands.Count;
                }
                startedTransaction?.Commit();
            }
            finally
            {
                if (startedTransaction != null)
                {
                    startedTransaction.Dispose();
                }
                else
                {
                    connection.Close();
                }
            }
            return rowsAffected;
        }

上诉代码中，根据得到的命令集合，循环执行命令来执行命令，最后通过事务统一来提交操作，也是确保DbContext内的事务一致性；

至此，我们EfCore的新增操作就简单分析完了，通过EFCore的DbContext来添加实体对象，通过Add方法，此时对象会加入到EFCore的内存管理集合中，不同状态对象不同的管理集合，调用SaveChanges方法保存，此时EFCore会将内存的实体对象读取出来，然后通过数据库事务统一提交；EFCore在整个操作中给我们加入了一层数据缓存层，也就是内存管理（后面会慢慢交流这一层的内容）；

二、数据查询 （R）

数据查询的内容上一篇入门文章中我已经说了相关方法，这里再把调用方式同步下

EF 的数据查询分为两种，跟踪查询和非跟踪查询；

1.跟踪查询是默认方式，默认EF查询出来的数据是跟踪模式（也可以手动调整），用于对数据做更新等数据库操作；

2.非跟踪查询模式，此模式用于单纯的数据查询，后续不需要对数据做相关修改，因为不需要对实体做调整的监测，所以会比跟踪查询相对快一些；

两种方式各有利弊，需要根据自己的业务实际需要来选择；

两种模式的文档说明（https://docs.microsoft.com/zh-cn/ef/core/querying/tracking）

var myDbContext = new MyDbContext();
            var list = myDbContext.TestTables.ToList();
            Console.WriteLine($"TestTable Count: {list.Count}");
            if (!list.Any()) return;
            Console.WriteLine($"TestTable Detail ----------------  ");
            foreach (var item in list)
            {
                Console.WriteLine($"ID : {item.Id} , Name : {item.Name}");
            }
            Console.WriteLine($"------------------------");

三、数据更新 （U）

数据更新操作，必须使用跟踪查询得到数据，然后修改得到的实体信息，再通过DbContext的SaveChanges提交数据即可；

三部曲：

1.跟踪查询得到数据

2.修改实体数据

3.DbContext.SaveChanges保存数据

            var myDbContext = new MyDbContext();
            var list = myDbContext.TestTables.AsTracking().ToList();
            var firstEntity = list.FirstOrDefault(p => p.Id == 1);
            if (firstEntity != null) firstEntity.Name = $"{firstEntity.Name} Query_跟踪查询";
            myDbContext.SaveChanges();
            Console.WriteLine($"------------------------");

四、数据删除 （D）

1.使用跟踪查询，将数据查询出来

2.通过DbSet将其Remove（也是再内存集合中做了标记，将其放入了remove集合中）

3.SaveChanges提交保存

            var myDbContext = new MyDbContext();
            var entity = myDbContext.TestTables.FirstOrDefault(p => p.Id == 1);
            if (entity != null)
                myDbContext.TestTables.Remove(entity);
            myDbContext.SaveChanges();

有没有发现问题，(⊙o⊙)？ 删除个数据还要查询出来？业务场景中，很多都是前端传入主键ID，执行执行相关表的数据删除，那是否可以使用非跟踪查询模式呢？

验证下 .....

            var myDbContext = new MyDbContext();
            var entity = myDbContext.TestTables.AsNoTracking().FirstOrDefault(p => p.Id == 1);
            if (entity != null)
                myDbContext.TestTables.Remove(entity);
            myDbContext.SaveChanges();

结果当然是可以删除啦，

那既然是非跟踪可以删除，也意味着自己构建的实体可以删除，那是否只需要主键就可以删除了 ？

            var myDbContext = new MyDbContext();
            var entity = new TestTable()
            {
                Id = 1
            };
            myDbContext.TestTables.Remove(entity);
            myDbContext.SaveChanges();

如上的代码，确实也是可以的，删除成功 ！！！

至此我们完成了EFCore的入门简单操作，基本都是简单的单表操作，只是为了演示整个EFCore的代码结构，大家可以自己上手尝试下，后续我们将开始EFCore相关的骚操作以及一些进阶操作