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

最近在接触DDD+micro service来开发项目，因为EF Core太适合DDD模式需要的ORM设计，所以这篇博客是从代码角度去理解EF core的内部实现，希望大家能从其中学到一些心得体会去更好的写出高质量的代码。

 从github 上去下载ef core仓库， 本篇代码的版本是基于tag v5.0.3的，如果大家在以后看见这篇博客，可以在分支上reset 到这个tag对照这边博客，下载完成之后，配置根目录下的global.json成本机已经安装的sdk, runtime 的版本，直接build通过就可以了。下面是代码的目录。

 简单的说一下，benchmark 是用来性能测试的，solution是一些自动化部署的配置文件，src是ef core 的核心代码，test 是此项目的单元测试目录，如果你想更深入了解每个模块的实现逻辑，从单元测试出发是一个非常不错的选择。

在用户阶段我们需要做的如下，代码来自 ef 官方文档

using System;
using System.Linq;

namespace EFGetStarted
{
    internal class Program
    {
        private static void Main()
        {
            using (var db = new BloggingContext())
            {
                // Note: This sample requires the database to be created before running.

                // Create
                Console.WriteLine("Inserting a new blog");
                db.Add(new Blog { Url = "http://blogs.msdn.com/adonet" });
                db.SaveChanges();

                // Read
                Console.WriteLine("Querying for a blog");
                var blog = db.Blogs
                    .OrderBy(b => b.BlogId)
                    .First();

                // Update
                Console.WriteLine("Updating the blog and adding a post");
                blog.Url = "https://devblogs.microsoft.com/dotnet";
                blog.Posts.Add(
                    new Post { Title = "Hello World", Content = "I wrote an app using EF Core!" });
                db.SaveChanges();

                // Delete
                Console.WriteLine("Delete the blog");
                db.Remove(blog);
                db.SaveChanges();
            }
        }
    }
}

首先我们先看在new DbContext的时候做了哪些的初始化的动作

        protected DbContext()
            : this(new DbContextOptions<DbContext>())
        {
        }

这个Context创建了了自己的DbContextOptions,很明显我们需要的一些配置像数据库组件等信息都是需要在DbContextOptions里配置的，我们继续看下去会发现在初始化的时候会创建一个字典对象，正如其名所说的一样这是在维护一些扩展组件。当你想使用不同类型的数据库是引用的library 就是在动态注册这些组件。在本例中，我们使用InMemoryDatabse来测试。　　

     protected DbContextOptions(
            [NotNull] IReadOnlyDictionary<Type, IDbContextOptionsExtension> extensions)
        {
            Check.NotNull(extensions, nameof(extensions));

            _extensions = extensions;
        }

 在相应的DbContext的继承子类重写OnConfiguring方法就可以使用memory database，配置如下

        protected internal override void OnConfiguring(DbContextOptionsBuilder options)
        {
            options.UseInMemoryDatabase(nameof(BloggingContext));
        }

初始化新的option好的时候，这是一个空的配置文件，后面就是对option做的初始化的动作。

  public DbContext([NotNull] DbContextOptions options)
        {
            Check.NotNull(options, nameof(options));

            if (!options.ContextType.IsAssignableFrom(GetType()))
            {
                throw new InvalidOperationException(CoreStrings.NonGenericOptions(GetType().ShortDisplayName()));
            }

            _options = options;

            ServiceProviderCache.Instance.GetOrAdd(options, providerRequired: false)
                .GetRequiredService<IDbSetInitializer>()
                .InitializeSets(this);

            EntityFrameworkEventSource.Log.DbContextInitializing();
        }

check完之后，ServiceProviderCache的单例模式去获取内部的service provide，这个很明显是对需要的组件进行依赖注入。我们截取了一些核心代码如下。

        public virtual IServiceProvider GetOrAdd([NotNull] IDbContextOptions options, bool providerRequired)
        {
            var key = options.Extensions
                .OrderBy(e => e.GetType().Name)
                .Aggregate(0L, (t, e) => (t * 397) ^ ((long)e.GetType().GetHashCode() * 397) ^ e.Info.GetServiceProviderHashCode());

            return _configurations.GetOrAdd(key, k => BuildServiceProvider()).ServiceProvider;

            (IServiceProvider ServiceProvider, IDictionary<string, string> DebugInfo) BuildServiceProvider()
            {

                var services = new ServiceCollection();
                var hasProvider = ApplyServices(options, services);

                var serviceProvider = services.BuildServiceProvider();

                if (hasProvider)
                {
                    serviceProvider
                        .GetRequiredService<ISingletonOptionsInitializer>()
                        .EnsureInitialized(serviceProvider, options);
                }

                return (serviceProvider, debugInfo);
            }
        }

从上面可以看出，option 的注册扩展组件不一样会创建不一样的service provide，在第13行代码会进行依赖注入，我们点进去之后会看到如下代码。

        private static bool ApplyServices(IDbContextOptions options, ServiceCollection services)
        {
            var coreServicesAdded = false;

            foreach (var extension in options.Extensions)
            {
                extension.ApplyServices(services);

                if (extension.Info.IsDatabaseProvider)
                {
                    coreServicesAdded = true;
                }
            }

            if (coreServicesAdded)
            {
                return true;
            }

            new EntityFrameworkServicesBuilder(services).TryAddCoreServices();

            return false;
        }

循环option获取其中的扩展组件，每个组件会有自己的依赖对象注入，如果没找到database provider，再注入当前的context的核心依赖对象注入，注入的逻辑不用看了，后面去查接口的实现对象参考这个就行了。代码到现在我们能看到已经获取service provider了，接下来继续看InitializeSets的方法。

   public virtual void InitializeSets(DbContext context)
        {
            foreach (var setInfo in _setFinder.FindSets(context.GetType()).Where(p => p.Setter != null))
            {
                setInfo.Setter.SetClrValue(
                    context,
                    ((IDbSetCache)context).GetOrAddSet(_setSource, setInfo.Type));
            }
        }

我们记得之前声明dbcontext 的时候我们会写dbset 属性，但是并没有对其进行赋值，并且所有对表的操作仿佛都是通过这个对象来完成的，是因为dbcontext 帮我们自动做了赋值的操作，我们找到findSets的实现逻辑。

 public virtual IReadOnlyList<DbSetProperty> FindSets(Type contextType)
            => _cache.GetOrAdd(contextType, FindSetsNonCached);

        private static DbSetProperty[] FindSetsNonCached(Type contextType)
        {
            var factory = new ClrPropertySetterFactory();

            return contextType.GetRuntimeProperties()
                .Where(
                    p => !p.IsStatic()
                        && !p.GetIndexParameters().Any()
                        && p.DeclaringType != typeof(DbContext)
                        && p.PropertyType.GetTypeInfo().IsGenericType
                        && p.PropertyType.GetGenericTypeDefinition() == typeof(DbSet<>))
                .OrderBy(p => p.Name)
                .Select(
                    p => new DbSetProperty(
                        p.Name,
                        p.PropertyType.GenericTypeArguments.Single(),
                        p.SetMethod == null ? null : factory.Create(p)))
                .ToArray();
        }

上面的代码会显示不是静态的，不是索引，type不是dbcontext的，是泛型的，是dbset泛型的属性会当做dbcontext 的set来处理，然后map成DbSetProperty对象进行维护，值得注意的一点是SetMethod为factory.Create(p)返回的Func类型，这个时候对象并没有赋值，指到在上面代码setInfo.Setter.SetClrValue调用完这个set才是真正的进行赋值，而其中的逻辑是如下所示。

     [UsedImplicitly]
        private static Func<DbContext, string, object> CreateSetFactory<TEntity>()
            where TEntity : class
            => (c, name) => new InternalDbSet<TEntity>(c, name);

其中的dbset 属性就是一个个的InternalDbSet对象，初始化set之后dbcontext就是日志记录一下,这个不是我的研究重点对象，到此为止一个dbcontext对象创建成功，这个时候我们的疑问就来了，我们的数据库配置的组件等配置是什么时候初始化的呢，明显现在的option 是非常干净的。

不用急我们现在来看一下第一个代码片段中的db.Add方法吧，看一下这个里面做了啥。

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

            SetEntityState(entry.GetInfrastructure(), entityState);

            return entry;
        }

我们会传入一个entity对象，并且将entityState 置为add 的状态，这个时候我们会涉及到一个重要的对象，就是DbContextDependencies.StateManager，这个就是内部的entity的状态管理对象，我们稍后会讨论这个对象。

   private EntityEntry<TEntity> EntryWithoutDetectChanges<TEntity>(TEntity entity)
            where TEntity : class
            => new(DbContextDependencies.StateManager.GetOrCreateEntry(entity));

这个时候我们需要重视DbContextDependencies这个对象，也就是dbcontext的依赖对象，它会通过InternalServiceProvider对象来获得，但是其中会有一些初始化的逻辑

       private IServiceProvider InternalServiceProvider
        {
            get
            {
                CheckDisposed();

                if (_contextServices != null)
                {
                    return _contextServices.InternalServiceProvider;
                }

                if (_initializing)
                {
                    throw new InvalidOperationException(CoreStrings.RecursiveOnConfiguring);
                }

                try
                {
                    _initializing = true;

                    var optionsBuilder = new DbContextOptionsBuilder(_options);

                    OnConfiguring(optionsBuilder);

                    if (_options.IsFrozen
                        && !ReferenceEquals(_options, optionsBuilder.Options))
                    {
                        throw new InvalidOperationException(CoreStrings.PoolingOptionsModified);
                    }

                    var options = optionsBuilder.Options;

                    _serviceScope = ServiceProviderCache.Instance.GetOrAdd(options, providerRequired: true)
                        .GetRequiredService<IServiceScopeFactory>()
                        .CreateScope();

                    var scopedServiceProvider = _serviceScope.ServiceProvider;

                    var contextServices = scopedServiceProvider.GetService<IDbContextServices>();

                    contextServices.Initialize(scopedServiceProvider, options, this);

                    _contextServices = contextServices;

                    DbContextDependencies.InfrastructureLogger.ContextInitialized(this, options);
                }
                finally
                {
                    _initializing = false;
                }

                return _contextServices.InternalServiceProvider;
            }
        }

在23行的OnConfiguring方法就是会调用我们配置的数据库组件，本例中我们用的就是inmemorydatabase,我们现在撇一下这个组件中间做了啥。很简单的就是在option中注册了扩展组件InMemoryOptionsExtension，之前说过注册了组件之后会重新生成新的server provider, 在新的server collection 重新注入memory database 组件所需要的依赖对象。在扩展组件的InMemoryOptionsExtension.ApplyServices 方法。这是每个扩展组件必须要实现的方法。现在我们知道database组件现在已经注册进来了。继续查看contetx.add 方法的逻辑。

     private IServiceProvider InternalServiceProvider
        {
            get
            {
                CheckDisposed();

                if (_contextServices != null)
                {
                    return _contextServices.InternalServiceProvider;
                }

                if (_initializing)
                {
                    throw new InvalidOperationException(CoreStrings.RecursiveOnConfiguring);
                }

                try
                {
                    _initializing = true;

                    var optionsBuilder = new DbContextOptionsBuilder(_options);

                    OnConfiguring(optionsBuilder);

                    if (_options.IsFrozen
                        && !ReferenceEquals(_options, optionsBuilder.Options))
                    {
                        throw new InvalidOperationException(CoreStrings.PoolingOptionsModified);
                    }

                    var options = optionsBuilder.Options;

                    _serviceScope = ServiceProviderCache.Instance.GetOrAdd(options, providerRequired: true)
                        .GetRequiredService<IServiceScopeFactory>()
                        .CreateScope();

                    var scopedServiceProvider = _serviceScope.ServiceProvider;

                    var contextServices = scopedServiceProvider.GetService<IDbContextServices>();

                    contextServices.Initialize(scopedServiceProvider, options, this);

                    _contextServices = contextServices;

                    DbContextDependencies.InfrastructureLogger.ContextInitialized(this, options);
                }
                finally
                {
                    _initializing = false;
                }

                return _contextServices.InternalServiceProvider;
            }
        }

现在转到上上上个代码片段，statemanager 需要创建一个entity，这时候会判断这个entity存在不存在，如果不存在会在facyor 方法创建一个statemanager管理的entity，然后在statemanager更新这个entity的状态。

    public virtual InternalEntityEntry GetOrCreateEntry(object entity)
        {
            var entry = TryGetEntry(entity);
            if (entry == null)
            {
                var entityType = _model.FindRuntimeEntityType(entity.GetType());
                if (entityType == null)
                {
                    if (_model.IsShared(entity.GetType()))
                    {
                        throw new InvalidOperationException(
                            CoreStrings.UntrackedDependentEntity(
                                entity.GetType().ShortDisplayName(),
                                "." + nameof(EntityEntry.Reference) + "()." + nameof(ReferenceEntry.TargetEntry),
                                "." + nameof(EntityEntry.Collection) + "()." + nameof(CollectionEntry.FindEntry) + "()"));
                    }

                    throw new InvalidOperationException(CoreStrings.EntityTypeNotFound(entity.GetType().ShortDisplayName()));
                }

                if (entityType.FindPrimaryKey() == null)
                {
                    throw new InvalidOperationException(CoreStrings.KeylessTypeTracked(entityType.DisplayName()));
                }

                entry = _internalEntityEntryFactory.Create(this, entityType, entity);

                UpdateReferenceMaps(entry, EntityState.Detached, null);
            }

            return entry;
        }

statemanager会有五个对象分别记录每一个entity的不同的记录，这五个对象分别是_detachedReferenceMap,_unchangedReferenceMap,_deletedReferenceMap,_modifiedReferenceMap,_addedReferenceMap,对应着放弃追踪，没有变化，删除的，修改的，增加的各种entity 对象，如下图所示，就是我们EF在内存维护的给个状态的对象。

     switch (state)
                    {
                        case EntityState.Detached:
                            _detachedReferenceMap ??= new Dictionary<object, InternalEntityEntry>(LegacyReferenceEqualityComparer.Instance);
                            _detachedReferenceMap[mapKey] = entry;
                            break;
                        case EntityState.Unchanged:
                            _unchangedReferenceMap ??=
                                new Dictionary<object, InternalEntityEntry>(LegacyReferenceEqualityComparer.Instance);
                            _unchangedReferenceMap[mapKey] = entry;
                            break;
                        case EntityState.Deleted:
                            _deletedReferenceMap ??= new Dictionary<object, InternalEntityEntry>(LegacyReferenceEqualityComparer.Instance);
                            _deletedReferenceMap[mapKey] = entry;
                            break;
                        case EntityState.Modified:
                            _modifiedReferenceMap ??= new Dictionary<object, InternalEntityEntry>(LegacyReferenceEqualityComparer.Instance);
                            _modifiedReferenceMap[mapKey] = entry;
                            break;
                        case EntityState.Added:
                            _addedReferenceMap ??= new Dictionary<object, InternalEntityEntry>(LegacyReferenceEqualityComparer.Instance);
                            _addedReferenceMap[mapKey] = entry;
                            break;
                    }

随后在这个entity会进入到一个changetracking 的状态。

好了今天写到这个地方了，进入tracking 的状态时会有一个graph 对象所管理，其中拥有一些图的数据结构，这时候会对导航属性等信息进行处理，现在快11点了，就写到这里后面我会跟上后续的内容，谢谢大家的阅读，如果有任何不理解或者指正的地方欢迎评论，最后谢谢大家。