EF Core 原理从源码出发(二)

紧接着我的上一篇博客，可以点击这里回到上一篇博客，上回分析到ef 两个重要的对象，StateManager和ChangeTracker这个对象，当我们向DbContext添加对象的时候我们会调用如下代码。

        private EntityEntry<TEntity> SetEntityState<TEntity>(
            TEntity entity,
            EntityState entityState)
            where TEntity : class
        {
            var entry = EntryWithoutDetectChanges(entity);

            SetEntityState(entry.GetInfrastructure(), entityState);

            return entry;
        }

在第6行的时候我们会得到一个entity,如上一篇博客所说，这个entity 会被记录detach状态（因为是new的状态）并记录在detachReferenceMap中，在第七行的代码会将这个实体对象标记为add方法，但是需要考虑的情况有很多，比如是否被修改，是否添加完再修改，主键生成，外键联系，导航属性处理等等，这些都是一些棘手的操作，让我们看一下第七行的代码具体逻辑吧。

    if (entry.EntityState == EntityState.Detached)
            {
                DbContextDependencies.EntityGraphAttacher.AttachGraph(
                    entry,
                    entityState,
                    entityState,
                    forceStateWhenUnknownKey: true);
            }
            else
            {
                entry.SetEntityState(
                    entityState,
                    acceptChanges: true,
                    forceStateWhenUnknownKey: entityState);
            }
        }

首先我们先看到如果这个对象原先是detach的状态，会由EntityGraph来进行处理，也就是一个图的数据结构，因为这不仅仅是点对点的数据结构，导航属性的存在会让其变成复杂的多对多的有可能的闭环图，我们在进去看一下这里面的操作。

     public virtual void AttachGraph(
            InternalEntityEntry rootEntry,
            EntityState targetState,
            EntityState storeGeneratedWithKeySetTargetState,
            bool forceStateWhenUnknownKey)
            => _graphIterator.TraverseGraph(
                new EntityEntryGraphNode<(EntityState TargetState, EntityState StoreGenTargetState, bool Force)>(
                    rootEntry,
                    (targetState, storeGeneratedWithKeySetTargetState, forceStateWhenUnknownKey),
                    null,
                    null),
                PaintAction);

正如其名所言我们需要遍历这个图，得到所有的导航属性并继续遍历，而遍历的时候的操作我们会给PaintAction 方法去操作，微软正规军写的代码取名非常有意思并且精确，PaintAction告诉我们在遍历的时候做的绘画操作。

那我们先看一下这个PaintAction 所做的操作，

   private static bool PaintAction(
            EntityEntryGraphNode<(EntityState TargetState, EntityState StoreGenTargetState, bool Force)> node)
        {
            SetReferenceLoaded(node);

            var internalEntityEntry = node.GetInfrastructure();
            if (internalEntityEntry.EntityState != EntityState.Detached)
            {
                return false;
            }

            var (targetState, storeGenTargetState, force) = node.NodeState;

            var (isGenerated, isSet) = internalEntityEntry.IsKeySet;

            internalEntityEntry.SetEntityState(
                isSet
                    ? (isGenerated ? storeGenTargetState : targetState)
                    : EntityState.Added, // Key can only be not-set if it is store-generated
                acceptChanges: true,
                forceStateWhenUnknownKey: force ? (EntityState?)targetState : null);

            return true;
        }

非常精确的说明了到一个新的node会设置其中的状态，并且我们看到EF的一些tips，就是当你add一个root entity的时候，导航属性是否设置主键来判断这个导航属性是add 的还是modify的状态。现在我们要去看一下这个SetEntityState的这个方法，现在事情变得有趣起来，因为这个entity会有新旧状态之分，要从detach状态变成add的状态，并且主键的值应该如何设定，我们先看一下状态的变化会导致哪些东西产生变化。

  private void SetEntityState(EntityState oldState, EntityState newState, bool acceptChanges, bool modifyProperties)
        {
            var entityType = EntityType;

            StateManager.StateChanging(this, newState);

            if (newState == EntityState.Unchanged
                && oldState == EntityState.Modified)
            {
                if (acceptChanges)
                {
                    _originalValues.AcceptChanges(this);
                }
                else
                {
                    _originalValues.RejectChanges(this);
                }
            }

            SetServiceProperties(oldState, newState);

            _stateData.EntityState = newState;

            if (oldState == EntityState.Detached)
            {
                StateManager.StartTracking(this);
            }
            else if (newState == EntityState.Detached)
            {
                StateManager.StopTracking(this, oldState);
            }

            FireStateChanged(oldState);

            if (newState == EntityState.Unchanged)
            {
                SharedIdentityEntry?.SetEntityState(EntityState.Detached);
            }

            if ((newState == EntityState.Deleted
                    || newState == EntityState.Detached)
                && StateManager.CascadeDeleteTiming == CascadeTiming.Immediate)
            {
                StateManager.CascadeDelete(this, force: false);
            }
        }

截取一些核心代码如上，在第五行的代码中，会将这个entity状态从detach状态变为add状态，也就是将StateManager的五个reference map进行处理，并且触发了这个entity的StateChanging方法，然后在26行代码中如果这个entity的old状态是detach，则需要StateManager去开始追踪他 StateManager.StartTracking(this);，追踪的概念是为这个实体生成唯一的Identity,并为这个实体生成一系列的快照，以后这个实体的所有的变化会与快照进行对比，这个快照会有origin values 和导航属性的快照，这些做完之后这个node就是已经是一个状态成add 的entity并且已经是追踪的状态。

     public virtual void TraverseGraph<TState>(
            EntityEntryGraphNode<TState> node,
            Func<EntityEntryGraphNode<TState>, bool> handleNode)
        {
            if (!handleNode(node))
            {
                return;
            }

            var internalEntityEntry = node.GetInfrastructure();
            var navigations = internalEntityEntry.EntityType.GetNavigations()
                .Concat<INavigationBase>(internalEntityEntry.EntityType.GetSkipNavigations());

            var stateManager = internalEntityEntry.StateManager;

            foreach (var navigation in navigations)
            {
                var navigationValue = internalEntityEntry[navigation];

                if (navigationValue != null)
                {
                    var targetEntityType = navigation.TargetEntityType;
                    if (navigation.IsCollection)
                    {
                        foreach (var relatedEntity in ((IEnumerable)navigationValue).Cast<object>().ToList())
                        {
                            var targetEntry = stateManager.GetOrCreateEntry(relatedEntity, targetEntityType);
                            TraverseGraph(
                                (EntityEntryGraphNode<TState>)node.CreateNode(node, targetEntry, navigation),
                                handleNode);
                        }
                    }
                    else
                    {
                        var targetEntry = stateManager.GetOrCreateEntry(navigationValue, targetEntityType);
                        TraverseGraph(
                            (EntityEntryGraphNode<TState>)node.CreateNode(node, targetEntry, navigation),
                            handleNode);
                    }
                }
            }
        }

接下来就是递归去遍历图的方法，对每一个节点都执行paintaction 的方法，改变状态并跟踪他，有兴趣的小伙伴可以去看一下图的遍历，这个时候所有entity的状态已经更新，现在已经到savechang这个操作了。

     public virtual int SaveChanges(bool acceptAllChangesOnSuccess)
        {
            CheckDisposed();

            SavingChanges?.Invoke(this, new SavingChangesEventArgs(acceptAllChangesOnSuccess));

            var interceptionResult = DbContextDependencies.UpdateLogger.SaveChangesStarting(this);

            TryDetectChanges();

            try
            {
                var entitiesSaved = interceptionResult.HasResult
                    ? interceptionResult.Result
                    : DbContextDependencies.StateManager.SaveChanges(acceptAllChangesOnSuccess);

                var result = DbContextDependencies.UpdateLogger.SaveChangesCompleted(this, entitiesSaved);

                SavedChanges?.Invoke(this, new SavedChangesEventArgs(acceptAllChangesOnSuccess, result));

                return result;
            }
            catch (DbUpdateConcurrencyException exception)
            {
                EntityFrameworkEventSource.Log.OptimisticConcurrencyFailure();

                DbContextDependencies.UpdateLogger.OptimisticConcurrencyException(this, exception);

                SaveChangesFailed?.Invoke(this, new SaveChangesFailedEventArgs(acceptAllChangesOnSuccess, exception));

                throw;
            }
            catch (Exception exception)
            {
                DbContextDependencies.UpdateLogger.SaveChangesFailed(this, exception);

                SaveChangesFailed?.Invoke(this, new SaveChangesFailedEventArgs(acceptAllChangesOnSuccess, exception));

                throw;
            }
        }

在第9行的代码会显示出追踪的功能，一些实体会因为add完之后继续修改状态，这时我们会根据快照进行相应的修改，这个就是changetracker 这个对象去实现的，然后我们就会根据statemanager的五个referencemap去得到需要保存的对象，然后我们将这些entity与相应的状态给到dayabase组件。

     protected virtual int SaveChanges([NotNull] IList<IUpdateEntry> entriesToSave)
        {
            _concurrencyDetector?.EnterCriticalSection();

            try
            {
                EntityFrameworkEventSource.Log.SavingChanges();

                return _database.SaveChanges(entriesToSave);
            }
            finally
            {
                _concurrencyDetector?.ExitCriticalSection();
            }
        }

而这个database不管是什么sql server 还是pgsql 等等，这些都是在之前配置文件配置的扩展组件中，因为本例子中使用memory database进行测试，而memory database 就是用内存的字典对象存储的。有兴趣的小伙伴可以自己去看一下实现的原理。

好了，现在EF core 的代码原理已经结束了，因为这几遍博客完全从代码出发写的比较生硬，希望建议小伙伴自己去clone代码对照这边博客去学习ef 的内部实现方式，图的数据结构确实适合解析导航属性的问题给人一亮的感觉，最后谢谢大家了。如果有任何不解的问题或者指正欢迎留言额。再次谢谢大家的阅读。