EF Core 源码分析
NeilHu 人气:0最近在接触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 官方文档
1 using System; 2 using System.Linq; 3 4 namespace EFGetStarted 5 { 6 internal class Program 7 { 8 private static void Main() 9 { 10 using (var db = new BloggingContext()) 11 { 12 // Note: This sample requires the database to be created before running. 13 14 // Create 15 Console.WriteLine("Inserting a new blog"); 16 db.Add(new Blog { Url = "http://blogs.msdn.com/adonet" }); 17 db.SaveChanges(); 18 19 // Read 20 Console.WriteLine("Querying for a blog"); 21 var blog = db.Blogs 22 .OrderBy(b => b.BlogId) 23 .First(); 24 25 // Update 26 Console.WriteLine("Updating the blog and adding a post"); 27 blog.Url = "https://devblogs.microsoft.com/dotnet"; 28 blog.Posts.Add( 29 new Post { Title = "Hello World", Content = "I wrote an app using EF Core!" }); 30 db.SaveChanges(); 31 32 // Delete 33 Console.WriteLine("Delete the blog"); 34 db.Remove(blog); 35 db.SaveChanges(); 36 } 37 } 38 } 39 }
首先我们先看在new DbContext的时候做了哪些的初始化的动作
1 protected DbContext() 2 : this(new DbContextOptions<DbContext>()) 3 { 4 }
这个Context创建了了自己的DbContextOptions,很明显我们需要的一些配置像数据库组件等信息都是需要在DbContextOptions里配置的,我们继续看下去会发现在初始化的时候会创建一个字典对象,正如其名所说的一样这是在维护一些扩展组件。当你想使用不同类型的数据库是引用的library 就是在动态注册这些组件。在本例中,我们使用InMemoryDatabse来测试。
1 protected DbContextOptions( 2 [NotNull] IReadOnlyDictionary<Type, IDbContextOptionsExtension> extensions) 3 { 4 Check.NotNull(extensions, nameof(extensions)); 5 6 _extensions = extensions; 7 }
在相应的DbContext的继承子类重写OnConfiguring方法就可以使用memory database,配置如下
1 protected internal override void OnConfiguring(DbContextOptionsBuilder options) 2 { 3 options.UseInMemoryDatabase(nameof(BloggingContext)); 4 }
初始化新的option好的时候,这是一个空的配置文件,后面就是对option做的初始化的动作。
1 public DbContext([NotNull] DbContextOptions options) 2 { 3 Check.NotNull(options, nameof(options)); 4 5 if (!options.ContextType.IsAssignableFrom(GetType())) 6 { 7 throw new InvalidOperationException(CoreStrings.NonGenericOptions(GetType().ShortDisplayName())); 8 } 9 10 _options = options; 11 12 // This service is not stored in _setInitializer as this may not be the service provider that will be used 13 // as the internal service provider going forward, because at this time OnConfiguring has not yet been called. 14 // Mostly that isn't a problem because set initialization is done by our internal services, but in the case 15 // where some of those services are replaced, this could initialize set using non-replaced services. 16 // In this rare case if this is a problem for the app, then the app can just not use this mechanism to create 17 // DbSet instances, and this code becomes a no-op. However, if this set initializer is then saved and used later 18 // for the Set method, then it makes the problem bigger because now an app is using the non-replaced services 19 // even when it doesn't need to. 20 ServiceProviderCache.Instance.GetOrAdd(options, providerRequired: false) 21 .GetRequiredService<IDbSetInitializer>() 22 .InitializeSets(this); 23 24 EntityFrameworkEventSource.Log.DbContextInitializing(); 25 }
check完之后,ServiceProviderCache的单例模式去获取内部的service provide,这个很明显是对需要的组件进行依赖注入。我们截取了一些核心代码如下。
1 public virtual IServiceProvider GetOrAdd([NotNull] IDbContextOptions options, bool providerRequired) 2 { 3 var key = options.Extensions 4 .OrderBy(e => e.GetType().Name) 5 .Aggregate(0L, (t, e) => (t * 397) ^ ((long)e.GetType().GetHashCode() * 397) ^ e.Info.GetServiceProviderHashCode()); 6 7 return _configurations.GetOrAdd(key, k => BuildServiceProvider()).ServiceProvider; 8 9 (IServiceProvider ServiceProvider, IDictionary<string, string> DebugInfo) BuildServiceProvider() 10 { 11 12 var services = new ServiceCollection(); 13 var hasProvider = ApplyServices(options, services); 14 15 var serviceProvider = services.BuildServiceProvider(); 16 17 if (hasProvider) 18 { 19 serviceProvider 20 .GetRequiredService<ISingletonOptionsInitializer>() 21 .EnsureInitialized(serviceProvider, options); 22 } 23 24 return (serviceProvider, debugInfo); 25 } 26 }
从上面可以看出,option 的注册扩展组件不一样会创建不一样的service provide,在第13行代码会进行依赖注入,我们点进去之后会看到如下代码。
1 private static bool ApplyServices(IDbContextOptions options, ServiceCollection services) 2 { 3 var coreServicesAdded = false; 4 5 foreach (var extension in options.Extensions) 6 { 7 extension.ApplyServices(services); 8 9 if (extension.Info.IsDatabaseProvider) 10 { 11 coreServicesAdded = true; 12 } 13 } 14 15 if (coreServicesAdded) 16 { 17 return true; 18 } 19 20 new EntityFrameworkServicesBuilder(services).TryAddCoreServices(); 21 22 return false; 23 }
循环option获取其中的扩展组件,每个组件会有自己的依赖对象注入,如果没找到database provider,再注入当前的context的核心依赖对象注入,注入的逻辑不用看了,后面去查接口的实现对象参考这个就行了。代码到现在我们能看到已经获取service provider了,接下来继续看InitializeSets的方法。
1 public virtual void InitializeSets(DbContext context) 2 { 3 foreach (var setInfo in _setFinder.FindSets(context.GetType()).Where(p => p.Setter != null)) 4 { 5 setInfo.Setter.SetClrValue( 6 context, 7 ((IDbSetCache)context).GetOrAddSet(_setSource, setInfo.Type)); 8 } 9 }
我们记得之前声明dbcontext 的时候我们会写dbset 属性,但是并没有对其进行赋值,并且所有对表的操作仿佛都是通过这个对象来完成的,是因为dbcontext 帮我们自动做了赋值的操作,我们找到findSets的实现逻辑。
1 public virtual IReadOnlyList<DbSetProperty> FindSets(Type contextType) 2 => _cache.GetOrAdd(contextType, FindSetsNonCached); 3 4 private static DbSetProperty[] FindSetsNonCached(Type contextType) 5 { 6 var factory = new ClrPropertySetterFactory(); 7 8 return contextType.GetRuntimeProperties() 9 .Where( 10 p => !p.IsStatic() 11 && !p.GetIndexParameters().Any() 12 && p.DeclaringType != typeof(DbContext) 13 && p.PropertyType.GetTypeInfo().IsGenericType 14 && p.PropertyType.GetGenericTypeDefinition() == typeof(DbSet<>)) 15 .OrderBy(p => p.Name) 16 .Select( 17 p => new DbSetProperty( 18 p.Name, 19 p.PropertyType.GenericTypeArguments.Single(), 20 p.SetMethod == null ? null : factory.Create(p))) 21 .ToArray(); 22 }
上面的代码会显示不是静态的,不是索引,type不是dbcontext的,是泛型的,是dbset泛型的属性会当做dbcontext 的set来处理,然后map成DbSetProperty对象进行维护,值得注意的一点是SetMethod为factory.Create(p)返回的Func类型,这个时候对象并没有赋值,指到在上面代码setInfo.Setter.SetClrValue调用完这个set才是真正的进行赋值,而其中的逻辑是如下所示。
1 [UsedImplicitly] 2 private static Func<DbContext, string, object> CreateSetFactory<TEntity>() 3 where TEntity : class 4 => (c, name) => new InternalDbSet<TEntity>(c, name);
其中的dbset 属性就是一个个的InternalDbSet对象,初始化set之后dbcontext就是日志记录一下,这个不是我的研究重点对象,到此为止一个dbcontext对象创建成功,这个时候我们的疑问就来了,我们的数据库配置的组件等配置是什么时候初始化的呢,明显现在的option 是非常干净的。
不用急我们现在来看一下第一个代码片段中的db.Add方法吧,看一下这个里面做了啥。
1 private EntityEntry<TEntity> SetEntityState<TEntity>( 2 TEntity entity, 3 EntityState entityState) 4 where TEntity : class 5 { 6 var entry = EntryWithoutDetectChanges(entity); 7 8 SetEntityState(entry.GetInfrastructure(), entityState); 9 10 return entry; 11 }
我们会传入一个entity对象,并且将entityState 置为add 的状态,这个时候我们会涉及到一个重要的对象,就是DbContextDependencies.StateManager,这个就是内部的entity的状态管理对象,我们稍后会讨论这个对象。
1 private EntityEntry<TEntity> EntryWithoutDetectChanges<TEntity>(TEntity entity) 2 where TEntity : class 3 => new(DbContextDependencies.StateManager.GetOrCreateEntry(entity));
这个时候我们需要重视DbContextDependencies这个对象,也就是dbcontext的依赖对象,它会通过InternalServiceProvider对象来获得,但是其中会有一些初始化的逻辑
1 private IServiceProvider InternalServiceProvider 2 { 3 get 4 { 5 CheckDisposed(); 6 7 if (_contextServices != null) 8 { 9 return _contextServices.InternalServiceProvider; 10 } 11 12 if (_initializing) 13 { 14 throw new InvalidOperationException(CoreStrings.RecursiveOnConfiguring); 15 } 16 17 try 18 { 19 _initializing = true; 20 21 var optionsBuilder = new DbContextOptionsBuilder(_options); 22 23 OnConfiguring(optionsBuilder); 24 25 if (_options.IsFrozen 26 && !ReferenceEquals(_options, optionsBuilder.Options)) 27 { 28 throw new InvalidOperationException(CoreStrings.PoolingOptionsModified); 29 } 30 31 var options = optionsBuilder.Options; 32 33 _serviceScope = ServiceProviderCache.Instance.GetOrAdd(options, providerRequired: true) 34 .GetRequiredService<IServiceScopeFactory>() 35 .CreateScope(); 36 37 var scopedServiceProvider = _serviceScope.ServiceProvider; 38 39 var contextServices = scopedServiceProvider.GetService<IDbContextServices>(); 40 41 contextServices.Initialize(scopedServiceProvider, options, this); 42 43 _contextServices = contextServices; 44 45 DbContextDependencies.InfrastructureLogger.ContextInitialized(this, options); 46 } 47 finally 48 { 49 _initializing = false; 50 } 51 52 return _contextServices.InternalServiceProvider; 53 } 54 }
在23行的OnConfiguring方法就是会调用我们配置的数据库组件,本例中我们用的就是inmemorydatabase,我们现在撇一下这个组件中间做了啥。很简单的就是在option中注册了扩展组件InMemoryOptionsExtension,之前说过注册了组件之后会重新生成新的server provider, 在新的server collection 重新注入memory database 组件所需要的依赖对象。在扩展组件的InMemoryOptionsExtension.ApplyServices 方法。这是每个扩展组件必须要实现的方法。现在我们知道database组件现在已经注册进来了。继续查看contetx.add 方法的逻辑。
1 private IServiceProvider InternalServiceProvider 2 { 3 get 4 { 5 CheckDisposed(); 6 7 if (_contextServices != null) 8 { 9 return _contextServices.InternalServiceProvider; 10 } 11 12 if (_initializing) 13 { 14 throw new InvalidOperationException(CoreStrings.RecursiveOnConfiguring); 15 } 16 17 try 18 { 19 _initializing = true; 20 21 var optionsBuilder = new DbContextOptionsBuilder(_options); 22 23 OnConfiguring(optionsBuilder); 24 25 if (_options.IsFrozen 26 && !ReferenceEquals(_options, optionsBuilder.Options)) 27 { 28 throw new InvalidOperationException(CoreStrings.PoolingOptionsModified); 29 } 30 31 var options = optionsBuilder.Options; 32 33 _serviceScope = ServiceProviderCache.Instance.GetOrAdd(options, providerRequired: true) 34 .GetRequiredService<IServiceScopeFactory>() 35 .CreateScope(); 36 37 var scopedServiceProvider = _serviceScope.ServiceProvider; 38 39 var contextServices = scopedServiceProvider.GetService<IDbContextServices>(); 40 41 contextServices.Initialize(scopedServiceProvider, options, this); 42 43 _contextServices = contextServices; 44 45 DbContextDependencies.InfrastructureLogger.ContextInitialized(this, options); 46 } 47 finally 48 { 49 _initializing = false; 50 } 51 52 return _contextServices.InternalServiceProvider; 53 } 54 }
现在转到上上上个代码片段,statemanager 需要创建一个entity,这时候会判断这个entity存在不存在,如果不存在会在facyor 方法创建一个statemanager管理的entity,然后在statemanager更新这个entity的状态。
1 public virtual InternalEntityEntry GetOrCreateEntry(object entity) 2 { 3 var entry = TryGetEntry(entity); 4 if (entry == null) 5 { 6 var entityType = _model.FindRuntimeEntityType(entity.GetType()); 7 if (entityType == null) 8 { 9 if (_model.IsShared(entity.GetType())) 10 { 11 throw new InvalidOperationException( 12 CoreStrings.UntrackedDependentEntity( 13 entity.GetType().ShortDisplayName(), 14 "." + nameof(EntityEntry.Reference) + "()." + nameof(ReferenceEntry.TargetEntry), 15 "." + nameof(EntityEntry.Collection) + "()." + nameof(CollectionEntry.FindEntry) + "()")); 16 } 17 18 throw new InvalidOperationException(CoreStrings.EntityTypeNotFound(entity.GetType().ShortDisplayName())); 19 } 20 21 if (entityType.FindPrimaryKey() == null) 22 { 23 throw new InvalidOperationException(CoreStrings.KeylessTypeTracked(entityType.DisplayName())); 24 } 25 26 entry = _internalEntityEntryFactory.Create(this, entityType, entity); 27 28 UpdateReferenceMaps(entry, EntityState.Detached, null); 29 } 30 31 return entry; 32 }
statemanager会有五个对象分别记录每一个entity的不同的记录,如下图所示
1 switch (state) 2 { 3 case EntityState.Detached: 4 _detachedReferenceMap ??= new Dictionary<object, InternalEntityEntry>(LegacyReferenceEqualityComparer.Instance); 5 _detachedReferenceMap[mapKey] = entry; 6 break; 7 case EntityState.Unchanged: 8 _unchangedReferenceMap ??= 9 new Dictionary<object, InternalEntityEntry>(LegacyReferenceEqualityComparer.Instance); 10 _unchangedReferenceMap[mapKey] = entry; 11 break; 12 case EntityState.Deleted: 13 _deletedReferenceMap ??= new Dictionary<object, InternalEntityEntry>(LegacyReferenceEqualityComparer.Instance); 14 _deletedReferenceMap[mapKey] = entry; 15 break; 16 case EntityState.Modified: 17 _modifiedReferenceMap ??= new Dictionary<object, InternalEntityEntry>(LegacyReferenceEqualityComparer.Instance); 18 _modifiedReferenceMap[mapKey] = entry; 19 break; 20 case EntityState.Added: 21 _addedReferenceMap ??= new Dictionary<object, InternalEntityEntry>(LegacyReferenceEqualityComparer.Instance); 22 _addedReferenceMap[mapKey] = entry; 23 break; 24 }
随后在这个entity会进入到一个changetracking 的状态。
好了今天写到这个地方了,进入tracking 的状态时会有一个graph 对象所管理,其中拥有一些图的数据结构,现在快11点了,就写到这里后面我会跟上后续的内容,谢谢大家的阅读,如果有任何不理解或者指正的地方欢迎评论,最后谢谢大家。
加载全部内容