经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » Java相关 » Java » 查看文章
【源码解读(一)】EFCORE源码解读之创建DBContext查询拦截
来源：cnblogs　　作者：四处观察　　时间：2023/10/16 16:07:55　　对本文有异议

引言

　　　　在网上很少看到有关于系统讲解EFCore源码的，可能大概也许是因为EFCore的源码总体是没有asp.net web的源码流程清晰，正如群友所说，EFCore的源码大致看起来有点凌乱，与其说凌乱，不如说是没有一个好的方向；然后昨天在群里有一个朋友再说，EfCore的拦截器如何注入Web的服务，以及EfCore如何自定义查询，我就看了一下EfCore的源码，在此之前我针对asp.net web 做了一个源码解读，有兴趣的朋友可以看前面的文章，也给别人说过啥时候讲解一下efcore的源码，刚好借助这么一个机会，讲一讲EfCore的源码，本篇文章作为一个开端，会呈现一下几点

　　　　一：首先是AddDbContext里面做了什么。

　　　　二：DbContext的构造函数里面做了那些事情。

　　　　三：如何在EfCore的服务中获取到Web注入的服务的方式之一。

　　　　四：拦截查询的几种方式。

　　　　五：使用缓存查询方法提升性能。

　　　　六：如何托管EFCORE的IOC容器(和Web的IOC使用同一个)

　　　　以上作为本篇文章的所有内容，接下来，我们来开始讲解源码，动手实践。

AddDbContext

　　　　EfCore提供了AddDbContext，AddDbContextFactory，AddDbContextPool，AddPooledDbContextFactory这几种扩展方法，我们会依次讲解，首先会讲解AddDbContext，后续的文章会依次讲解其余的方法。话不多说，上源码。下面是AddDbContext的源码，提供了多种方法，但是最终都会调用到这里，第一个参数是一个设置OptionBuilder的委托，传入了ServiceProvider和OptionBuilder，第二，三个分别是DbContext和DBContextOption的生命周期。

　　　　在下面的代码，刚开始判断了如果DBContext的生命周期是单例，要将Option的生命周期也设置为单例，如果不设置为单例，就会出现错误，这个错误在之前讲解IOC的文章中，我记得也提到过，接下来判断设置Option的委托是否为null，如果不为null，那DBContext的构造函数是必须要有一个参数，所以下面调用了一个方法CheckContextConstructors。

  1.  public static IServiceCollection AddDbContext<TContextService, TContextImplementation>(
  2.      this IServiceCollection serviceCollection,
  3.      Action<IServiceProvider, DbContextOptionsBuilder>? optionsAction,
  4.      ServiceLifetime contextLifetime = ServiceLifetime.Scoped,
  5.      ServiceLifetime optionsLifetime = ServiceLifetime.Scoped)
  6.      where TContextImplementation : DbContext, TContextService
  7.  {
  8.      if (contextLifetime == ServiceLifetime.Singleton)
  9.      {
  10.          optionsLifetime = ServiceLifetime.Singleton;
  11.      }
  13.      if (optionsAction != null)
  14.      {
  15.          CheckContextConstructors<TContextImplementation>();
  16.      }
  18.      AddCoreServices<TContextImplementation>(serviceCollection, optionsAction, optionsLifetime);
  20.      if (serviceCollection.Any(d => d.ServiceType == typeof(IDbContextFactorySource<TContextImplementation>)))
  21.      {
  22.          // Override registration made by AddDbContextFactory
  23.          var serviceDescriptor = serviceCollection.FirstOrDefault(d => d.ServiceType == typeof(TContextImplementation));
  24.          if (serviceDescriptor != null)
  25.          {
  26.              serviceCollection.Remove(serviceDescriptor);
  27.          }
  28.      }
  30.      serviceCollection.TryAdd(new ServiceDescriptor(typeof(TContextService), typeof(TContextImplementation), contextLifetime));
  32.      if (typeof(TContextService) != typeof(TContextImplementation))
  33.      {
  34.          serviceCollection.TryAdd(
  35.              new ServiceDescriptor(
  36.                  typeof(TContextImplementation),
  37.                  p => (TContextImplementation)p.GetService<TContextService>()!,
  38.                  contextLifetime));
  39.      }
  41.      return serviceCollection;
  42.  }

  1.  private static void CheckContextConstructors<TContext>()
  2.      where TContext : DbContext
  3.  {
  4.      var declaredConstructors = typeof(TContext).GetTypeInfo().DeclaredConstructors.ToList();
  5.      if (declaredConstructors.Count == 1
  6.          && declaredConstructors[0].GetParameters().Length == 0)
  7.      {
  8.          throw new ArgumentException(CoreStrings.DbContextMissingConstructor(typeof(TContext).ShortDisplayName()));
  9.      }
  10.  }

　　　　在CheckContextConstructors，我们看到反射去获取DBContext的继承类，查找构造函数，并且参数如果是0就会报异常。接下来在往下走，调用了一个AddCoreServices的方法，在这个方法里，我们是将DBContextOptions的泛型和非泛型注入到容器里面去，其中有一个CreateDbContextOptions的方法，里面去new了一个DbContextOptionsBuilder类，然后调用了一个UseApplicationServiceProvider方法，

  1.     private static void AddCoreServices<TContextImplementation>(
  2.         IServiceCollection serviceCollection,
  3.         Action<IServiceProvider, DbContextOptionsBuilder>? optionsAction,
  4.         ServiceLifetime optionsLifetime)
  5.         where TContextImplementation : DbContext
  6.     {
  7.         serviceCollection.TryAdd(
  8.             new ServiceDescriptor(
  9.                 typeof(DbContextOptions<TContextImplementation>),
  10.                 p => CreateDbContextOptions<TContextImplementation>(p, optionsAction),
  11.                 optionsLifetime));
  13.         serviceCollection.Add(
  14.             new ServiceDescriptor(
  15.                 typeof(DbContextOptions),
  16.                 p => p.GetRequiredService<DbContextOptions<TContextImplementation>>(),
  17.                 optionsLifetime));
  18.     }
  20.     private static DbContextOptions<TContext> CreateDbContextOptions<TContext>(
  21.         IServiceProvider applicationServiceProvider,
  22.         Action<IServiceProvider, DbContextOptionsBuilder>? optionsAction)
  23.         where TContext : DbContext
  24.     {
  25.         var builder = new DbContextOptionsBuilder<TContext>(
  26.             new DbContextOptions<TContext>(new Dictionary<Type, IDbContextOptionsExtension>()));
  28.         builder.UseApplicationServiceProvider(applicationServiceProvider);
  30.         optionsAction?.Invoke(applicationServiceProvider, builder);
  32.         return builder.Options;
  33.     }

　　　　下面是一个UseApplicationServiceProvider的调用链，最终调用到了WithApplicationServiceProvider方法，可以看到是返回了一个CoreOptionsExtension，最终调用WithOptions添加到了DbContextOptionsBuilder里面去，上面的代码中，我们new了一个DbContextOptionsBuilder，里面传入了一个DbContextOptions，构造函数传入了new Dictionary<Type,IDbContextOptionsExtension>()，最终我们的CoreOptionsExtension会添加到我们传入的这个字典里，用来保存所有的IDbContextOptionsExtension，这个接口可以理解为，数据库Options的扩展，接口定义如下，Info是关于扩展的一些元数据信息，ApplyService方法，参数是一个IServiceCollection，这个方法是我们将我们要注入的服务注入到这个里面去，因为EfCore的IOC和Web的IOC是区分开的，所以使用了不同的IServiceCollection，虽然提供了UseApplicationServiceProvider和UseInternalServiceProvider方法，实际上并不能实现IOC接管，设计实在是鸡肋，待会到了DbContext的构造函数中我们会看到为什么说鸡肋。Validate方法则是验证当前扩展，例如你得这个实现里面有一些参数，是必须要配置，或者配置有一个规则，我们在这里验证我们的配置或者规则是否符合我们需要的数据，如果不符合，在这里可以直接抛出异常。

　　　　回到CreateDbContextOptions，此时我们可以确保我们的Option的Extension里面是有一个CoreOptionsExtension，接下来，判断有没有设置OptionsBuilder的委托，调用然后返回到AddDbContext。

  1.  public new virtual DbContextOptionsBuilder<TContext> UseApplicationServiceProvider(IServiceProvider? serviceProvider)
  2.      => (DbContextOptionsBuilder<TContext>)base.UseApplicationServiceProvider(serviceProvider);
  3.   public virtual DbContextOptionsBuilder UseApplicationServiceProvider(IServiceProvider? serviceProvider)
  4.       => WithOption(e => e.WithApplicationServiceProvider(serviceProvider));
  5.     public virtual CoreOptionsExtension WithApplicationServiceProvider(IServiceProvider? applicationServiceProvider)
  6.     {
  7.         var clone = Clone();
  9.         clone._applicationServiceProvider = applicationServiceProvider;
  11.         return clone;
  12.     }
  1.   private DbContextOptionsBuilder WithOption(Func<CoreOptionsExtension, CoreOptionsExtension> withFunc)
  2.   {
  3.       ((IDbContextOptionsBuilderInfrastructure)this).AddOrUpdateExtension(
  4.           withFunc(Options.FindExtension<CoreOptionsExtension>() ?? new CoreOptionsExtension()));
  6.       return this;
  7.   }
  1. public interface IDbContextOptionsExtension
  2. {
  3.     /// <summary>
  4.     ///     Information/metadata about the extension.
  5.     /// </summary>
  6.     DbContextOptionsExtensionInfo Info { get; }
  8.     /// <summary>
  9.     ///     Adds the services required to make the selected options work. This is used when there
  10.     ///     is no external <see cref="IServiceProvider" /> and EF is maintaining its own service
  11.     ///     provider internally. This allows database providers (and other extensions) to register their
  12.     ///     required services when EF is creating an service provider.
  13.     /// </summary>
  14.     /// <param name="services">The collection to add services to.</param>
  15.     void ApplyServices(IServiceCollection services);
  17.     /// <summary>
  18.     ///     Gives the extension a chance to validate that all options in the extension are valid.
  19.     ///     Most extensions do not have invalid combinations and so this will be a no-op.
  20.     ///     If options are invalid, then an exception should be thrown.
  21.     /// </summary>
  22.     /// <param name="options">The options being validated.</param>
  23.     void Validate(IDbContextOptions options);
  24. }
  1.     void IDbContextOptionsBuilderInfrastructure.AddOrUpdateExtension<TExtension>(TExtension extension)
  2.         => _options = _options.WithExtension(extension);

　　　　在AddDbContext的最后，这几行代码，是将我们的DbContext注入到我们的IOC容器中去。

  1. if (serviceCollection.Any(d => d.ServiceType == typeof(IDbContextFactorySource<TContextImplementation>)))
  2. {
  3.     // Override registration made by AddDbContextFactory
  4.     var serviceDescriptor = serviceCollection.FirstOrDefault(d => d.ServiceType == typeof(TContextImplementation));
  5.     if (serviceDescriptor != null)
  6.     {
  7.         serviceCollection.Remove(serviceDescriptor);
  8.     }
  9. }
  11. serviceCollection.TryAdd(new ServiceDescriptor(typeof(TContextService), typeof(TContextImplementation), contextLifetime));
  13. if (typeof(TContextService) != typeof(TContextImplementation))
  14. {
  15.     serviceCollection.TryAdd(
  16.         new ServiceDescriptor(
  17.             typeof(TContextImplementation),
  18.             p => (TContextImplementation)p.GetService<TContextService>()!,
  19.             contextLifetime));
  20. }

　　　　至此，关于AddDbContext的源码讲解完毕，接下来进到DbContext构造函数的源码讲解，这里设计内容稍微多一些。

DBContext构造

　　　　构造函数的代码是整体是没多少的，但是最重要的还是在于GetOrAdd的方法。所以这里我会只讲这个方法的内部

  1.  public DbContext(DbContextOptions options)
  2.  {
  3.      Check.NotNull(options, nameof(options));
  5.      if (!options.ContextType.IsAssignableFrom(GetType()))
  6.      {
  7.          throw new InvalidOperationException(CoreStrings.NonGenericOptions(GetType().ShortDisplayName()));
  8.      }
  10.      _options = options;
  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);
  24.      EntityFrameworkEventSource.Log.DbContextInitializing();
  25.  }

　　　　下面是ServiceProviderCache的全部源码，在GetOrAdd方法，先获取了CoreOptionsExtension，这个我们在AddDbContext的时候，已经添加过了，并且设置了ApplicationProvider，在往下走，判断InternalServiceProvider，这里我们没有设置，就会继续往下走，判断了一个ServiceProviderCachingEnabled 这个默认是true，然后下面获取CoreOptionsExtension的ApplicationServiceProvider，还记得我们在最初的时候AddDbContext的时候，创建DbContextOptionsBuilder的时候，我们UseApplicationServiceProvider方法，就是设置了一个公用的Provider，现在把他在设置为null，如果说这个Provider有啥作用，哈哈哈哈，我认为他就是创建Options的时候需要用，然后给一个有东西的不为空的CoreOptionsExtension，这个方法，实际上我觉得微软设置为internal最好了，这样可能会存在误解开发者，而InternalServiceProvider是很有用，可以和我们的web共用一个ioc容器，在本文的最后，我会将ef的ioc容器托管到web的。

　　　　ServiceProviderCachingEnabled参数代表是否将GetOrAdd通过BuildServiceProvider创建的ServiceProvider缓存到_configuration中去，不缓存的话，每次都是一个新的Provider，对性能有影响，如果缓存，则第一次创建后面都是从那里面取。

　　　　接下来就到了GetOrAdd最后，要调用BuildServiceProvider方法来创建一个ServiceProvider，下面的方法，我们着重看几个关键点一个是ApplyService，一个是new ServiceCollection(说明web的ioc和ef的ioc不是同一个)，ReplaceService。

  1. public class ServiceProviderCache
  2. {
  3.     private readonly ConcurrentDictionary<IDbContextOptions, (IServiceProvider ServiceProvider, IDictionary<string, string> DebugInfo)>
  4.         _configurations = new();
  6.     /// <summary>
  7.     ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
  8.     ///     the same compatibility standards as public APIs. It may be changed or removed without notice in
  9.     ///     any release. You should only use it directly in your code with extreme caution and knowing that
  10.     ///     doing so can result in application failures when updating to a new Entity Framework Core release.
  11.     /// </summary>
  12.     public static ServiceProviderCache Instance { get; } = new();
  14.     /// <summary>
  15.     ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
  16.     ///     the same compatibility standards as public APIs. It may be changed or removed without notice in
  17.     ///     any release. You should only use it directly in your code with extreme caution and knowing that
  18.     ///     doing so can result in application failures when updating to a new Entity Framework Core release.
  19.     /// </summary>
  20.     public virtual IServiceProvider GetOrAdd(IDbContextOptions options, bool providerRequired)
  21.     {
  22.         var coreOptionsExtension = options.FindExtension<CoreOptionsExtension>();
  23.         var internalServiceProvider = coreOptionsExtension?.InternalServiceProvider;
  24.         if (internalServiceProvider != null)
  25.         {
  26.             ValidateOptions(options);
  28.             var optionsInitializer = internalServiceProvider.GetService<ISingletonOptionsInitializer>();
  29.             if (optionsInitializer == null)
  30.             {
  31.                 throw new InvalidOperationException(CoreStrings.NoEfServices);
  32.             }
  34.             if (providerRequired)
  35.             {
  36.                 optionsInitializer.EnsureInitialized(internalServiceProvider, options);
  37.             }
  39.             return internalServiceProvider;
  40.         }
  42.         if (coreOptionsExtension?.ServiceProviderCachingEnabled == false)
  43.         {
  44.             return BuildServiceProvider(options, (_configurations, options)).ServiceProvider;
  45.         }
  47.         var cacheKey = options;
  48.         var extension = options.FindExtension<CoreOptionsExtension>();
  49.         if (extension?.ApplicationServiceProvider != null)
  50.         {
  51.             cacheKey = ((DbContextOptions)options).WithExtension(extension.WithApplicationServiceProvider(null));
  52.         }
  54.         return _configurations.GetOrAdd(
  55.                 cacheKey,
  56.                 static (contextOptions, tuples) => BuildServiceProvider(contextOptions, tuples), (_configurations, options))
  57.             .ServiceProvider;
  59.         static (IServiceProvider ServiceProvider, IDictionary<string, string> DebugInfo) BuildServiceProvider(
  60.             IDbContextOptions _,
  61.             (ConcurrentDictionary<IDbContextOptions, (IServiceProvider ServiceProvider, IDictionary<string, string> DebugInfo)>,
  62.                 IDbContextOptions) arguments)
  63.         {
  64.             var (configurations, options) = arguments;
  66.             ValidateOptions(options);
  68.             var debugInfo = new Dictionary<string, string>();
  69.             foreach (var optionsExtension in options.Extensions)
  70.             {
  71.                 optionsExtension.Info.PopulateDebugInfo(debugInfo);
  72.             }
  74.             debugInfo = debugInfo.OrderBy(_ => debugInfo.Keys).ToDictionary(d => d.Key, v => v.Value);
  76.             var services = new ServiceCollection();
  77.             var hasProvider = ApplyServices(options, services);
  79.             var replacedServices = options.FindExtension<CoreOptionsExtension>()?.ReplacedServices;
  80.             if (replacedServices != null)
  81.             {
  82.                 var updatedServices = new ServiceCollection();
  83.                 foreach (var descriptor in services)
  84.                 {
  85.                     if (replacedServices.TryGetValue((descriptor.ServiceType, descriptor.ImplementationType), out var replacementType))
  86.                     {
  87.                         ((IList<ServiceDescriptor>)updatedServices).Add(
  88.                             new ServiceDescriptor(descriptor.ServiceType, replacementType, descriptor.Lifetime));
  89.                     }
  90.                     else if (replacedServices.TryGetValue((descriptor.ServiceType, null), out replacementType))
  91.                     {
  92.                         ((IList<ServiceDescriptor>)updatedServices).Add(
  93.                             new ServiceDescriptor(descriptor.ServiceType, replacementType, descriptor.Lifetime));
  94.                     }
  95.                     else
  96.                     {
  97.                         ((IList<ServiceDescriptor>)updatedServices).Add(descriptor);
  98.                     }
  99.                 }
  101.                 services = updatedServices;
  102.             }
  104.             var serviceProvider = services.BuildServiceProvider();
  106.             if (hasProvider)
  107.             {
  108.                 serviceProvider
  109.                     .GetRequiredService<ISingletonOptionsInitializer>()
  110.                     .EnsureInitialized(serviceProvider, options);
  111.             }
  113.             using (var scope = serviceProvider.CreateScope())
  114.             {
  115.                 var scopedProvider = scope.ServiceProvider;
  117.                 // If loggingDefinitions is null, then there is no provider yet
  118.                 var loggingDefinitions = scopedProvider.GetService<LoggingDefinitions>();
  119.                 if (loggingDefinitions != null)
  120.                 {
  121.                     // Because IDbContextOptions cannot yet be resolved from the internal provider
  122.                     var logger = new DiagnosticsLogger<DbLoggerCategory.Infrastructure>(
  123.                         ScopedLoggerFactory.Create(scopedProvider, options),
  124.                         scopedProvider.GetRequiredService<ILoggingOptions>(),
  125.                         scopedProvider.GetRequiredService<DiagnosticSource>(),
  126.                         loggingDefinitions,
  127.                         new NullDbContextLogger());
  129.                     if (configurations.IsEmpty)
  130.                     {
  131.                         logger.ServiceProviderCreated(serviceProvider);
  132.                     }
  133.                     else
  134.                     {
  135.                         logger.ServiceProviderDebugInfo(
  136.                             debugInfo,
  137.                             configurations.Values.Select(v => v.DebugInfo).ToList());
  139.                         if (configurations.Count >= 20)
  140.                         {
  141.                             logger.ManyServiceProvidersCreatedWarning(
  142.                                 configurations.Values.Select(e => e.ServiceProvider).ToList());
  143.                         }
  144.                     }
  146.                     var applicationServiceProvider = options.FindExtension<CoreOptionsExtension>()?.ApplicationServiceProvider;
  147.                     if (applicationServiceProvider?.GetService<IRegisteredServices>() != null)
  148.                     {
  149.                         logger.RedundantAddServicesCallWarning(serviceProvider);
  150.                     }
  151.                 }
  152.             }
  154.             return (serviceProvider, debugInfo);
  155.         }
  156.     }
  158.     private static void ValidateOptions(IDbContextOptions options)
  159.     {
  160.         foreach (var extension in options.Extensions)
  161.         {
  162.             extension.Validate(options);
  163.         }
  164.     }
  166.     private static bool ApplyServices(IDbContextOptions options, ServiceCollection services)
  167.     {
  168.         var coreServicesAdded = false;
  170.         foreach (var extension in options.Extensions)
  171.         {
  172.             extension.ApplyServices(services);
  174.             if (extension.Info.IsDatabaseProvider)
  175.             {
  176.                 coreServicesAdded = true;
  177.             }
  178.         }
  180.         if (coreServicesAdded)
  181.         {
  182.             return true;
  183.         }
  185.         new EntityFrameworkServicesBuilder(services).TryAddCoreServices();
  187.         return false;
  188.     }
  189. }

 　　　　我们先看ApplyService，在这个方法我们看到，是传入了Options，ServiceCollection，然后循环遍历Options的Extensions，调用他的ApplyService方法，传入serviceCollection，下图，我们看到默认是有这么多的实现，根据你在对DBContextOptionsBuilder提供的方法的使用，会给Options的Extensions添加不同的Extension，最后调用各自的ApplyService，我们找一个看看具体在做什么事情。哈哈，不用猜，大家也知道，肯定是注入服务，通过options的Extensions附加一些其他关于EF的功能，并且将他们所需要的服务注入到传入的ServiceCollection里面，其他的都是一样，所以在我们没有托管ef的ioc到web的时候可以使用这种方式来实现，后面也会写一个这样的例子。最后调用一下TryAddCoreService方法，这个方法有许多EF需用到重要的服务的注入。

　　　　而ReplaceService就是我们在调用DbContextOptionsBuilder的ReplaceService<>方法的时候里面保存的我们要替换的类型，以及实现，在这里重新注入到容器里，用上面的代码结合看，就是ApplyService先注入一遍，然后在替换一下，最后调用一下BuildServiceProvider方法生成一个ServiceProvider，在后面的代码就是一些日志相关的配置，此处就不过多讲解。

  1.     public virtual void ApplyServices(IServiceCollection services)
  2.         => services.AddEntityFrameworkProxies();

 

 
　　　　在上面的讲解中，我们有几个可以自定义的点就是一个是IDbContextOptionsExtension，这个我们可以在不托管ef的ioc到web的ioc的时候，我们可以实现一个这个接口，然后在代码添加到Extension就可以注入EF所需要用到的服务。接下来在下面段落，我会写一个简单的例子来注入我们要的服务。（不托管ioc到web的方式）。

EFCore服务注入

　　　　先上代码，代码没有多少，就是实现这个接口，定义一个Inject特性，用来标记从Web的IOC我们需要检索那些接口注入到EF的ioc中去，这样做有一个弊端就是Web的会注入一遍，Ef也会注入一遍，重复注入，在Program.cs里面我们先注入一个返回IServiceCollection的Func，这样在DBContext可以获取到这个 传到ServiceExtension里面，就可以拿到Web的IOC注入的服务。

  1.     builder.Services.AddScoped<IWebGetName, WebGetName>();
  2.     builder.Services.AddSingleton(() => builder.Services);
  1.   [InjectAttribute]
  2.   public interface IWebGetName
  3.   {
  4.       public string GetName();
  5.   }
  1.  [AttributeUsage(AttributeTargets.Interface| AttributeTargets.Class)]
  2.  public class InjectAttribute:Attribute
  3.  {
  4.      public InjectAttribute()
  5.      {
  6.              
  7.      }
  8.  }

 

  1. public class ServiceExtension : IDbContextOptionsExtension
  2. {
  3.     public ServiceExtension(Func<IServiceCollection> func)
  4.     {
  5.         Func = func;
  6.     }
  7.     public DbContextOptionsExtensionInfo Info => new ExtensionInfo(this);
  9.     public Func<IServiceCollection> Func { get; }
  11.     public void ApplyServices(IServiceCollection services)
  12.     {
  13.         var ser=Func();
  14.         var type = ser.Where(s => s.ServiceType?.GetCustomAttribute<InjectAttribute>() != null || s.ImplementationType?.GetCustomAttribute<InjectAttribute>() != null).ToList();
  15.         foreach (var item in type)
  16.         {
  17.             services.TryAdd(new ServiceDescriptor(item.ServiceType, item.ImplementationType, item.Lifetime));
  18.         }
  19.         services.AddScoped<IDBGetName, DBGetName>();
  20.     }
  22.     public void Validate(IDbContextOptions options)
  23.     {
  24.     }
  25. }
  26.  public class ExtensionInfo: DbContextOptionsExtensionInfo
  27.  {
  28.      public ExtensionInfo(IDbContextOptionsExtension extension):base(extension) 
  29.      {
  30.              
  31.      }
  32.      public override bool IsDatabaseProvider => false;
  34.      public override string LogFragment => string.Empty;
  36.      public override int GetServiceProviderHashCode()
  37.      {
  38.          return 0;
  39.      }
  41.      public override void PopulateDebugInfo(IDictionary<string, string> debugInfo)
  42.      {
  43.      }
  45.      public override bool ShouldUseSameServiceProvider(DbContextOptionsExtensionInfo other)
  46.      {
  47.          return true;
  48.      }
  49.  }

　　　　接口定义好之后，服务也注入进去，接下来就是在DBContext里面添加这个扩展,因为optionsBuilder.Options只读，所以我们添加Extension就需要用AddOrUpdateExtension的方法来添加，因为Options在DbContextOptionsBuilder的内部字段是可以更改的。接下来扩展添加进去之后，我们运行程序，获取一个DBContext，然后就会走到这里添加我们的扩展，从而注入我们注入的IWebGetName，就可以在EF的IOC获取我们web注入服务。

  1.   builder.Services.AddDbContext<DecodeMicroMsgContext>((a, m) => {
  3.       ((IDbContextOptionsBuilderInfrastructure)m).AddOrUpdateExtension(new ServiceExtension(a.GetService<Func<IServiceCollection>>()));
  4.       m.UseSqlite("Data Source=C:\\Users\\Chenxd\\Desktop\\资料\\CrackMsg\\CrackDb\\CrackDb\\bin\\Debug\\net7.0-windows\\TOOLS\\output\\decode_MicroMsg.db;");
  5.   });

拦截查询

　　Sql拦截

　　　　针对SQL拦截，这里我会直接贴上我之前有一篇文章aop的代码，来作为讲解，其中有用到了DBInterceptor作为拦截器拦截DBCommand进行sql拦截，实现读写分离的方式，下面的代码是我自己实现了DBCommandInterceptor来实现的一个拦截器，在DBContext中将拦截器添加进去，在每次执行查询或者增加删除修改的时候，都会进入这个拦截器，从而实现自己想要的业务逻辑，我在此处是写了一个简单的读写分离，感兴趣的可以看看之前的文章https://www.cnblogs.com/1996-Chinese-Chen/p/15776120.html这个文章的代码地址已经失效，最后我会将本例程的所有代码放在百度网盘，其中包括这个AOP的代码，感兴趣的朋友可以下载看看。

  1.     var list=new List<IInterceptor>();
  2.     list.Add(new DbContextInterceptor());
  3.     optionsBuilder.AddInterceptors(list);
  1.     public class DbContextInterceptor:DbCommandInterceptor
  2.     {
  3.         private  DbConnection _connection;
  4.         private  DbCommand _command;
  5.         private CommandSource _commandSource;
  6.         public DbContextInterceptor()
  7.         {
  9.         }
  10.         public override DbCommand CommandCreated(CommandEndEventData eventData, DbCommand result)
  11.         {
  12.             return _command;
  13.         }
  14.         public override InterceptionResult<DbCommand> CommandCreating(CommandCorrelatedEventData eventData, InterceptionResult<DbCommand> result)
  15.         {
  16.             _commandSource = eventData.CommandSource;
  17.             if (eventData.CommandSource==CommandSource.LinqQuery)
  18.             {
  19.                 _connection = new MySqlConnection(eventData.Connection.ConnectionString);
  20.                 _command = new MySqlCommand();
  21.             }
  22.             return InterceptionResult<DbCommand>.SuppressWithResult(_command);
  23.         }
  24.         public override void CommandFailed(DbCommand command, CommandErrorEventData eventData)
  25.         {
  26.             base.CommandFailed(command, eventData);
  27.         }
  28.         public override Task CommandFailedAsync(DbCommand command, CommandErrorEventData eventData, CancellationToken cancellationToken = default)
  29.         {
  30.             return base.CommandFailedAsync(command, eventData, cancellationToken);
  31.         }
  32.         public override InterceptionResult DataReaderDisposing(DbCommand command, DataReaderDisposingEventData eventData, InterceptionResult result)
  33.         {
  34.             return base.DataReaderDisposing(command, eventData, result);
  35.         }
  36.         public override int NonQueryExecuted(DbCommand command, CommandExecutedEventData eventData, int result)
  37.         {
  38.             return base.NonQueryExecuted(command, eventData, result);
  39.         }
  40.         public override ValueTask<int> NonQueryExecutedAsync(DbCommand command, CommandExecutedEventData eventData, int result, CancellationToken cancellationToken = default)
  41.         {
  42.             return base.NonQueryExecutedAsync(command, eventData, result, cancellationToken);
  43.         }
  44.         public override InterceptionResult<int> NonQueryExecuting(DbCommand command, CommandEventData eventData, InterceptionResult<int> result)
  45.         {
  46.             return base.NonQueryExecuting(command, eventData, result);
  47.         }
  48.         public override ValueTask<InterceptionResult<int>> NonQueryExecutingAsync(DbCommand command, CommandEventData eventData, InterceptionResult<int> result, CancellationToken cancellationToken = default)
  49.         {
  50.             return base.NonQueryExecutingAsync(command, eventData, result, cancellationToken);
  51.         }
  52.         public override DbDataReader ReaderExecuted(DbCommand command, CommandExecutedEventData eventData, DbDataReader result)
  53.         {
  54.             return base.ReaderExecuted(command, eventData, result);
  55.         }
  56.         public override ValueTask<DbDataReader> ReaderExecutedAsync(DbCommand command, CommandExecutedEventData eventData, DbDataReader result, CancellationToken cancellationToken = default)
  57.         {
  58.             return base.ReaderExecutedAsync(command, eventData, result, cancellationToken);
  59.         }
  60.         public override InterceptionResult<DbDataReader> ReaderExecuting(DbCommand command, CommandEventData eventData, InterceptionResult<DbDataReader> result)
  61.         {
  62.             command.CommandText = "";
  63.             return base.ReaderExecuting(command, eventData, result);
  64.         }
  65.         public async override ValueTask<InterceptionResult<DbDataReader>> ReaderExecutingAsync(DbCommand command, CommandEventData eventData, InterceptionResult<DbDataReader> result, CancellationToken cancellationToken = default)
  66.         {
  67.             InterceptionResult<DbDataReader> results;
  68.             if (_commandSource == CommandSource.LinqQuery)
  69.             {
  70.                 var connect = new MySqlConnection("data source=192.168.21.129;database=MasterSlave; userid=root;pwd=199645; charset=utf8;ConvertZeroDateTime=True;pooling=true; allowuservariables=true;");
  71.                 connect.Open();
  72.                 _command = new MySqlCommand(command.CommandText, connect);
  73.                 var reader = await _command.ExecuteReaderAsync();
  74.                 results = InterceptionResult<DbDataReader>.SuppressWithResult(reader);
  75.             }
  76.             else
  77.             {
  78.                 results=await base.ReaderExecutingAsync(command, eventData, result, cancellationToken);
  79.             }
  80.             return results;
  81.         }
  82.         public override object ScalarExecuted(DbCommand command, CommandExecutedEventData eventData, object result)
  83.         {
  84.             return base.ScalarExecuted(command, eventData, result);
  85.         }
  86.         public override ValueTask<object> ScalarExecutedAsync(DbCommand command, CommandExecutedEventData eventData, object result, CancellationToken cancellationToken = default)
  87.         {
  88.             return base.ScalarExecutedAsync(command, eventData, result, cancellationToken);
  89.         }
  90.         public override InterceptionResult<object> ScalarExecuting(DbCommand command, CommandEventData eventData, InterceptionResult<object> result)
  91.         {
  92.             return base.ScalarExecuting(command, eventData, result);
  93.         }
  94.         public override ValueTask<InterceptionResult<object>> ScalarExecutingAsync(DbCommand command, CommandEventData eventData, InterceptionResult<object> result, CancellationToken cancellationToken = default)
  95.         {
  96.             return base.ScalarExecutingAsync(command, eventData, result, cancellationToken);
  97.         }
  98.     }

　　表达式拦截

　　　　上面我们讲了SQL拦截，接下来我们讲一下表达式拦截，我们都知道，EF的核心在于表达式树，可以说表达式树构造了整个EF的核心，关于表达式树，我在我的第一篇博客就写了很多关于表达式树的案例，https://www.cnblogs.com/1996-Chinese-Chen/p/14987967.html，感兴趣的朋友可以看看，所以此处表达式树我不会做讲解，只有如何实现自定义的表达式树拦截，

　　　　重要的有三个我们需要实现的接口，一个是IQueryable，IQueryCompiler，还有一个IAsyncQueryProvider，通过实现这三个接口，外加IDatabase，IQueryContextFactory需要用到的两个接口，实际上只是表达式拦截，只需要实现一个IQueryCompiler也可以实现，我i自己是实现了这三个，最主要的还是在IQueryCompiler，接下来看看具体的实现代码。

　　　　IQueryCompiler

  1. public class TestQueryCompiler : IQueryCompiler
  2.     {
  3.         public TestQueryCompiler(IDatabase database, IQueryContextFactory queryContextFactory)
  4.         {
  5.             Database = database;
  6.             var a = Database.GetType();
  7.             QueryContextFactory = queryContextFactory;
  8.         }
  10.         public IDatabase Database { get; }
  11.         public IQueryContextFactory QueryContextFactory { get; }
  13.         public Func<QueryContext, TResult> CreateCompiledAsyncQuery<TResult>(Expression query)
  14.         {
  15.             var queryFunc = Database.CompileQuery<TResult>(query, true);
  16.             return queryFunc;
  17.         }
  19.         public Func<QueryContext, TResult> CreateCompiledQuery<TResult>(Expression query)
  20.         {
  21.             var queryFunc = Database.CompileQuery<TResult>(query, false);
  22.             return queryFunc;
  23.         }
  25.         public TResult Execute<TResult>(Expression query)
  26.         {
  27.             var queryFunc = Database.CompileQuery<TResult>(query, false);
  28.             var res = queryFunc(QueryContextFactory.Create());
  29.             return res;
  30.         }
  32.         public TResult ExecuteAsync<TResult>(Expression query, CancellationToken cancellationToken)
  33.         {
  34.             var queryFunc = Database.CompileQuery<TResult>(query, true);
  35.             var res = queryFunc(QueryContextFactory.Create());
  36.             return res;
  37.         }
  38.     }

　　　　IAsyncQueryProvider

　　　　

  1.  public class TestQueryProvider : IAsyncQueryProvider
  2.  {
  3.      public TestQueryProvider(IDBGetName ta, IQueryCompiler query,IWebGetName webGetName)
  4.      {
  5.          Ta = ta;
  6.          Query = query;
  7.          WebGetName = webGetName;
  8.      }
  10.      public IDBGetName Ta { get; }
  11.      public IQueryCompiler Query { get; }
  12.      public IWebGetName WebGetName { get; }
  14.      public IQueryable CreateQuery(Expression expression)
  15.      {
  16.          return new Queryable<object>(this, expression);
  17.      }
  19.      public IQueryable<TElement> CreateQuery<TElement>(Expression expression)
  20.      {
  21.          return new Queryable<TElement>(this, expression);
  22.      }
  24.      public object? Execute(Expression expression)
  25.      {
  26.          return Query.Execute<object>(expression);
  27.      }
  29.      public TResult Execute<TResult>(Expression expression)
  30.      {
  31.          return Query.Execute<TResult>(expression);
  32.      }
  34.      public TResult ExecuteAsync<TResult>(Expression expression, CancellationToken cancellationToken = default)
  35.      {
  36.          return Query.ExecuteAsync<TResult>(expression, cancellationToken);
  37.      }
  38.  }　　

　　　　IQueryable

  1.  public class Queryable<T> : IQueryable<T>
  2.  {
  3.      public Queryable(IAsyncQueryProvider queryProvider, Expression expression)
  4.      {
  5.          QueryProvider = queryProvider;
  6.          Expression = expression;
  7.      }
  8.      public Type ElementType => typeof(T);
  10.      public IAsyncQueryProvider QueryProvider { get; }
  11.      public Expression Expression { get; }
  13.      public IQueryProvider Provider => QueryProvider;
  15.      public IEnumerator GetEnumerator()
  16.      {
  17.          return Provider.Execute<IEnumerable>(Expression).GetEnumerator();
  18.      }
  20.      IEnumerator<T> IEnumerable<T>.GetEnumerator()
  21.      {
  22.          return Provider.Execute<IEnumerable<T>>(Expression).GetEnumerator();
  23.      }
  24.  }

　　　　在实现了那三个接口之后，我们就需要将我们的服务使用DBContextOptionsBuilder的ReplaceService替换掉，这样，在执行查询的时候就会走我们创建的TestQueryProvider，然后我们在这个类里调用关于Queryable和TestQueryCompiler来执行查询，如果又需要修改，也可以修改Expression从而达到拦截修改。我们最终是需要借助IDataBase的CompileQuery方法来实现构建查询的委托，从而实现查询，在底层还有Visitor遍历表达式树，当然了，此处我只展示一个拦截表达式树，后续的源码讲解会看到，欢迎大家关注。

　　　　如果是使用了EF的IOC托管到了Web的IOC，只需要正常注入服务就行，生命周期是Scope，

  1.  #未接管
     optionsBuilder.ReplaceService<IAsyncQueryProvider,TestQueryProvider >();
  2.  optionsBuilder.ReplaceService<IQueryCompiler,TestQueryCompiler>();
    #接管IOC

   builder.Services.AddScoped<IAsyncQueryProvider, TestQueryProvider>();
   builder.Services.AddScoped<IQueryCompiler, TestQueryCompiler>(s =>
   {
   var database = s.GetService<IDatabase>();
   var factory = s.GetService<IQueryContextFactory>();
   return new TestQueryCompiler(database, factory);
   });

 

 

 缓存查询方法

　　　　在上面的代码中，我们可以看到我们调用了一个ComileQuery方法，构建了一个委托，实际上，我们在业务编码中，也可以使用缓存查询，来提升业务系统的性能，虽然我们不能使用IDataBase的这个发给发，但是EF提供了一个静态类，里面的ComileQuery方法支持构建查询的委托，

 　　　　看下面代码，我们可以调用这个方法缓存一个查询的方法，后面就不会再去调用很多的类，很多的方法来实现我们的查询，可以缓存起来，来提升我们的查询性能，同时这个ComileQuery方法最终也会调用到我们上面自定义的TestQueryCompiler的ComileQuery方法去，并且同步对同步，异步对异步.

  1.   public class WeatherForecastController : ControllerBase
  2.   {
  3.       private static readonly string[] Summaries = new[]
  4.       {
  5.       "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching"
  6.   };
  7.       private Func<DecodeMicroMsgContext, IQueryable<Contact>> Func;
  8.       private readonly ILogger<WeatherForecastController> _logger;
  9.       private readonly IWebGetName webGetName;
  11.       public WeatherForecastController(ILogger<WeatherForecastController> logger,IWebGetName webGetName, DecodeMicroMsgContext dbContext)
  12.       {
  13.           _logger = logger;
  14.           this.webGetName = webGetName;
  15.           DbContext = dbContext;
  16.       }
  18.       public DecodeMicroMsgContext DbContext { get; }
  20.       [HttpGet(Name = "GetWeatherForecast")]
  21.       public List<Contact> Get()
  22.       {
  23.           Func = EF.CompileQuery<DecodeMicroMsgContext, IQueryable<Contact>>(s => s.Contacts.Take(10));
  24.           return DbContext.Contacts.Take(10).ToList();
  25.       }

EF的IOC托管到WEB的IOC

　　　　在上面讲源码的时候，我们提到了一个方法，叫UseInternalServiceProvider，我们需要借助这个方法来把EF的ioc托管到web，同样是DBContextOptionsBuilder的方法，将web的ServiceProvider获取到并且调用这个方法，同时，我们还需要在Program.cs调用一个方法  builder.Services.AddEntityFrameworkSqlite();如果是其他数据库也是一样的道理，需要调用这样的方法，可以看第三方提供的库源码，或者文档，这里我是SQLITE数据库，就调用这个方法，这个方法是将SqlLite的一些服务注入到容器里，并且将我们的web容器传入到EF里面去，这样EF注入的服务是和Web注入的服务是在一起的，然后在调用UseInternalServiceProvider指定ServiceProvider就可以实现EF和WEB共用一个IOC。

　　　　下面是Program的Main方法的所有代码。

  1.  public static void Main(string[] args)
  2.  {
  3.      var builder = WebApplication.CreateBuilder(args);
  4.      builder.Services.AddScoped<IWebGetName,WebGetName>();
  5.      builder.Services.AddScoped<IAsyncQueryProvider, TestQueryProvider>();
  6.      builder.Services.AddScoped<IQueryCompiler, TestQueryCompiler>(s =>
  7.      {
  8.          var database = s.GetService<IDatabase>();
  9.          var factory = s.GetService<IQueryContextFactory>();
  10.          return new TestQueryCompiler(database, factory);
  11.      });
  12.      builder.Services.AddScoped<IDBGetName, DBGetName>();
  13.      builder.Services.AddEntityFrameworkSqlite();
  14.      builder.Services.AddDbContext<DecodeMicroMsgContext>((a, m) => {
  15.          m.UseSqlite("Data Source=C:\\Users\\Chenxd\\Desktop\\资料\\CrackMsg\\CrackDb\\CrackDb\\bin\\Debug\\net7.0-windows\\TOOLS\\output\\decode_MicroMsg.db;");
  16.      });
  17.      builder.Services.AddControllers();
  18.      // Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
  19.      builder.Services.AddEndpointsApiExplorer();
  20.      builder.Services.AddSwaggerGen();
  21.      builder.Services.AddSingleton(() => builder.Services);
  22.      var app = builder.Build();
  24.      // Configure the HTTP request pipeline.
  25.      if (app.Environment.IsDevelopment())
  26.      {
  27.          app.UseSwagger();
  28.          app.UseSwaggerUI();
  29.      }
  31.      app.UseAuthorization();
  34.      app.MapControllers();
  36.      app.Run();
  37.  }

 

  1.     public static IServiceCollection AddEntityFrameworkSqlite(this IServiceCollection serviceCollection)
  2.     {
  3.         var builder = new EntityFrameworkRelationalServicesBuilder(serviceCollection)
  4.             .TryAdd<LoggingDefinitions, SqliteLoggingDefinitions>()
  5.             .TryAdd<IDatabaseProvider, DatabaseProvider<SqliteOptionsExtension>>()
  6.             .TryAdd<IRelationalTypeMappingSource, SqliteTypeMappingSource>()
  7.             .TryAdd<ISqlGenerationHelper, SqliteSqlGenerationHelper>()
  8.             .TryAdd<IRelationalAnnotationProvider, SqliteAnnotationProvider>()
  9.             .TryAdd<IModelValidator, SqliteModelValidator>()
  10.             .TryAdd<IProviderConventionSetBuilder, SqliteConventionSetBuilder>()
  11.             .TryAdd<IModificationCommandBatchFactory, SqliteModificationCommandBatchFactory>()
  12.             .TryAdd<IRelationalConnection>(p => p.GetRequiredService<ISqliteRelationalConnection>())
  13.             .TryAdd<IMigrationsSqlGenerator, SqliteMigrationsSqlGenerator>()
  14.             .TryAdd<IRelationalDatabaseCreator, SqliteDatabaseCreator>()
  15.             .TryAdd<IHistoryRepository, SqliteHistoryRepository>()
  16.             .TryAdd<IRelationalQueryStringFactory, SqliteQueryStringFactory>()
  17.             .TryAdd<IMethodCallTranslatorProvider, SqliteMethodCallTranslatorProvider>()
  18.             .TryAdd<IAggregateMethodCallTranslatorProvider, SqliteAggregateMethodCallTranslatorProvider>()
  19.             .TryAdd<IMemberTranslatorProvider, SqliteMemberTranslatorProvider>()
  20.             .TryAdd<IQuerySqlGeneratorFactory, SqliteQuerySqlGeneratorFactory>()
  21.             .TryAdd<IQueryableMethodTranslatingExpressionVisitorFactory, SqliteQueryableMethodTranslatingExpressionVisitorFactory>()
  22.             .TryAdd<IRelationalSqlTranslatingExpressionVisitorFactory, SqliteSqlTranslatingExpressionVisitorFactory>()
  23.             .TryAdd<IQueryTranslationPostprocessorFactory, SqliteQueryTranslationPostprocessorFactory>()
  24.             .TryAdd<IUpdateSqlGenerator>(
  25.                 sp =>
  26.                 {
  27.                     // Support for the RETURNING clause on INSERT/UPDATE/DELETE was added in Sqlite 3.35.
  28.                     // Detect which version we're using, and fall back to the older INSERT/UPDATE+SELECT behavior on legacy versions.
  29.                     var dependencies = sp.GetRequiredService<UpdateSqlGeneratorDependencies>();
  31.                     return new Version(new SqliteConnection().ServerVersion) < new Version(3, 35)
  32.                         ? new SqliteLegacyUpdateSqlGenerator(dependencies)
  33.                         : new SqliteUpdateSqlGenerator(dependencies);
  34.                 })
  35.             .TryAdd<ISqlExpressionFactory, SqliteSqlExpressionFactory>()
  36.             .TryAddProviderSpecificServices(
  37.                 b => b.TryAddScoped<ISqliteRelationalConnection, SqliteRelationalConnection>());
  39.         builder.TryAddCoreServices();
  41.         return serviceCollection;
  42.     }

 

  1. using EfDemo.Models;
  2. using Microsoft.EntityFrameworkCore.Infrastructure;
  3. using Microsoft.EntityFrameworkCore.Query.Internal;
  4. using Microsoft.EntityFrameworkCore.Query;
  5. using Microsoft.EntityFrameworkCore;
  6. using EfDemo.QueryableExtension;
  7. using EfDemo.DBExtension;
  8. using Microsoft.EntityFrameworkCore.Diagnostics;
  10. namespace EfDemo.DB
  11. {
  13.     public partial class DecodeMicroMsgContext : DbContext
  14.     {
  15.         public DecodeMicroMsgContext(Func<IServiceCollection> func, IServiceProvider serviceProvider)
  16.         {
  17.             Func = func;
  18.             ServiceProvider = serviceProvider;
  19.         }
  21.         public DecodeMicroMsgContext(DbContextOptions<DecodeMicroMsgContext> options, Func<IServiceCollection> func,IServiceProvider serviceProvider)
  22.             : base(options)
  23.         {
  25.             Func = func;
  26.             ServiceProvider = serviceProvider;
  27.         }
  29.         public virtual DbSet<AppInfo> AppInfos { get; set; }
  31.         public virtual DbSet<BizInfo> BizInfos { get; set; }
  33.         public virtual DbSet<BizName2Id> BizName2Ids { get; set; }
  35.         public virtual DbSet<BizProfileInfo> BizProfileInfos { get; set; }
  37.         public virtual DbSet<BizProfileV2> BizProfileV2s { get; set; }
  39.         public virtual DbSet<BizSessionNewFeed> BizSessionNewFeeds { get; set; }
  41.         public virtual DbSet<ChatInfo> ChatInfos { get; set; }
  43.         public virtual DbSet<ChatLiveInfo> ChatLiveInfos { get; set; }
  45.         public virtual DbSet<ChatRoom> ChatRooms { get; set; }
  47.         public virtual DbSet<ChatRoomInfo> ChatRoomInfos { get; set; }
  49.         public virtual DbSet<ChatroomTool> ChatroomTools { get; set; }
  51.         public virtual DbSet<Contact> Contacts { get; set; }
  53.         public virtual DbSet<ContactHeadImgUrl> ContactHeadImgUrls { get; set; }
  55.         public virtual DbSet<ContactLabel> ContactLabels { get; set; }
  57.         public virtual DbSet<DelayDownLoad> DelayDownLoads { get; set; }
  59.         public virtual DbSet<FtschatroomTran> FtschatroomTrans { get; set; }
  61.         public virtual DbSet<FtscontactTran> FtscontactTrans { get; set; }
  63.         public virtual DbSet<MainConfig> MainConfigs { get; set; }
  65.         public virtual DbSet<OpLog> OpLogs { get; set; }
  67.         public virtual DbSet<PatInfo> PatInfos { get; set; }
  69.         public virtual DbSet<RevokeMsgStorage> RevokeMsgStorages { get; set; }
  71.         public virtual DbSet<Session> Sessions { get; set; }
  73.         public virtual DbSet<TicketInfo> TicketInfos { get; set; }
  75.         public virtual DbSet<TopStoryReddotInfo> TopStoryReddotInfos { get; set; }
  76.         public IServiceProvider ServiceProvider { get; }
  77.         public IServiceCollection ServiceDescriptors { get; }
  78.         public Func<IServiceCollection> Func { get; }
  80.         protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
  81.         {
  82.             optionsBuilder.UseInternalServiceProvider(ServiceProvider);
  83.            // optionsBuilder.ReplaceService<IAsyncQueryProvider, TestQueryProvider>();
  84.            // optionsBuilder.ReplaceService<IQueryCompiler, TestQueryCompiler>();
  85.             // ((IDbContextOptionsBuilderInfrastructure)s).AddOrUpdateExtension(new Extension());
  86.             //var interceptor = new List<IInterceptor>();
  87.             //optionsBuilder.AddInterceptors();
  88.             ((IDbContextOptionsBuilderInfrastructure)optionsBuilder).AddOrUpdateExtension(new ServiceExtension(Func));
  89.             base.OnConfiguring(optionsBuilder);
  90.         }
  92.         protected override void OnModelCreating(ModelBuilder modelBuilder)
  93.         {
  94.             modelBuilder.Entity<AppInfo>(entity =>
  95.             {
  96.                 entity.HasKey(e => e.InfoKey);
  98.                 entity.ToTable("AppInfo");
  100.                 entity.Property(e => e.Description4EnUs).HasColumnName("Description4EnUS");
  101.                 entity.Property(e => e.Description4ZhTw).HasColumnName("Description4ZhTW");
  102.                 entity.Property(e => e.Name4EnUs).HasColumnName("Name4EnUS");
  103.                 entity.Property(e => e.Name4ZhTw).HasColumnName("Name4ZhTW");
  104.                 entity.Property(e => e.Version).HasColumnType("INT");
  105.             });
  107.             modelBuilder.Entity<BizInfo>(entity =>
  108.             {
  109.                 entity.HasKey(e => e.UserName);
  111.                 entity.ToTable("BizInfo");
  113.                 entity.Property(e => e.AcceptType).HasDefaultValueSql("0");
  114.                 entity.Property(e => e.BrandFlag).HasDefaultValueSql("0");
  115.                 entity.Property(e => e.BrandIconUrl).HasColumnName("BrandIconURL");
  116.                 entity.Property(e => e.Reserved1).HasDefaultValueSql("0");
  117.                 entity.Property(e => e.Reserved3).HasDefaultValueSql("0");
  118.                 entity.Property(e => e.Reserved5).HasDefaultValueSql("0");
  119.                 entity.Property(e => e.Reserved7).HasDefaultValueSql("0");
  120.                 entity.Property(e => e.Type).HasDefaultValueSql("0");
  121.                 entity.Property(e => e.UpdateTime).HasDefaultValueSql("0");
  122.             });
  124.             modelBuilder.Entity<BizName2Id>(entity =>
  125.             {
  126.                 entity.HasKey(e => e.UsrName);
  128.                 entity.ToTable("BizName2ID");
  129.             });
  131.             modelBuilder.Entity<BizProfileInfo>(entity =>
  132.             {
  133.                 entity.HasKey(e => e.TableIndex);
  135.                 entity.ToTable("BizProfileInfo");
  137.                 entity.HasIndex(e => e.TableIndex, "versionIdx");
  139.                 entity.Property(e => e.TableIndex)
  140.                     .ValueGeneratedNever()
  141.                     .HasColumnName("tableIndex");
  142.                 entity.Property(e => e.TableDesc).HasColumnName("tableDesc");
  143.                 entity.Property(e => e.TableVersion)
  144.                     .HasColumnType("INTERGER")
  145.                     .HasColumnName("tableVersion");
  146.             });
  148.             modelBuilder.Entity<BizProfileV2>(entity =>
  149.             {
  150.                 entity.HasKey(e => e.TalkerId);
  152.                 entity.ToTable("BizProfileV2");
  154.                 entity.HasIndex(e => e.TimeStamp, "BizProfileV2TimeIdx");
  156.                 entity.Property(e => e.TalkerId).ValueGeneratedNever();
  157.             });
  159.             modelBuilder.Entity<BizSessionNewFeed>(entity =>
  160.             {
  161.                 entity.HasKey(e => e.TalkerId);
  163.                 entity.HasIndex(e => e.CreateTime, "BizSessionNewFeedsCreateTimeIdx");
  165.                 entity.HasIndex(e => e.UpdateTime, "BizSessionNewFeedsUpdateTimeIdx");
  167.                 entity.Property(e => e.TalkerId).ValueGeneratedNever();
  168.             });
  170.             modelBuilder.Entity<ChatInfo>(entity =>
  171.             {
  172.                 entity
  173.                     .HasNoKey()
  174.                     .ToTable("ChatInfo");
  176.                 entity.HasIndex(e => e.Username, "ChatInfoUserNameIndex");
  177.             });
  179.             modelBuilder.Entity<ChatLiveInfo>(entity =>
  180.             {
  181.                 entity
  182.                     .HasNoKey()
  183.                     .ToTable("ChatLiveInfo");
  185.                 entity.HasIndex(e => new { e.RoomName, e.LiveId }, "IX_ChatLiveInfo_RoomName_LiveId").IsUnique();
  187.                 entity.HasIndex(e => e.LiveId, "ChatLiveInfoLiveIdIdx");
  189.                 entity.HasIndex(e => e.RoomName, "ChatLiveInfoRoomNamex");
  190.             });
  192.             modelBuilder.Entity<ChatRoom>(entity =>
  193.             {
  194.                 entity.HasKey(e => e.ChatRoomName);
  196.                 entity.ToTable("ChatRoom");
  198.                 entity.Property(e => e.ChatRoomFlag)
  199.                     .HasDefaultValueSql("0")
  200.                     .HasColumnType("INT");
  201.                 entity.Property(e => e.IsShowName).HasDefaultValueSql("0");
  202.                 entity.Property(e => e.Owner).HasDefaultValueSql("0");
  203.                 entity.Property(e => e.Reserved1).HasDefaultValueSql("0");
  204.                 entity.Property(e => e.Reserved3).HasDefaultValueSql("0");
  205.                 entity.Property(e => e.Reserved5).HasDefaultValueSql("0");
  206.                 entity.Property(e => e.Reserved7).HasDefaultValueSql("0");
  207.             });
  209.             modelBuilder.Entity<ChatRoomInfo>(entity =>
  210.             {
  211.                 entity.HasKey(e => e.ChatRoomName);
  213.                 entity.ToTable("ChatRoomInfo");
  215.                 entity.Property(e => e.AnnouncementPublishTime).HasDefaultValueSql("0");
  216.                 entity.Property(e => e.ChatRoomStatus).HasDefaultValueSql("0");
  217.                 entity.Property(e => e.InfoVersion).HasDefaultValueSql("0");
  218.                 entity.Property(e => e.Reserved1).HasDefaultValueSql("0");
  219.                 entity.Property(e => e.Reserved3).HasDefaultValueSql("0");
  220.                 entity.Property(e => e.Reserved5).HasDefaultValueSql("0");
  221.                 entity.Property(e => e.Reserved7).HasDefaultValueSql("0");
  222.             });
  224.             modelBuilder.Entity<ChatroomTool>(entity =>
  225.             {
  226.                 entity
  227.                     .HasNoKey()
  228.                     .ToTable("ChatroomTool");
  230.                 entity.HasIndex(e => e.ChatroomUsername, "IX_ChatroomTool_ChatroomUsername").IsUnique();
  231.             });
  233.             modelBuilder.Entity<Contact>(entity =>
  234.             {
  235.                 entity.HasKey(e => e.UserName);
  237.                 entity.ToTable("Contact");
  239.                 entity.HasIndex(e => e.Reserved2, "Contact_Idx0");
  241.                 entity.Property(e => e.ChatRoomNotify).HasDefaultValueSql("0");
  242.                 entity.Property(e => e.ChatRoomType).HasColumnType("INT");
  243.                 entity.Property(e => e.DelFlag).HasDefaultValueSql("0");
  244.                 entity.Property(e => e.LabelIdlist).HasColumnName("LabelIDList");
  245.                 entity.Property(e => e.Pyinitial).HasColumnName("PYInitial");
  246.                 entity.Property(e => e.RemarkPyinitial).HasColumnName("RemarkPYInitial");
  247.                 entity.Property(e => e.Reserved1).HasDefaultValueSql("0");
  248.                 entity.Property(e => e.Reserved2).HasDefaultValueSql("0");
  249.                 entity.Property(e => e.Reserved5).HasDefaultValueSql("0");
  250.                 entity.Property(e => e.Reserved8).HasDefaultValueSql("0");
  251.                 entity.Property(e => e.Reserved9).HasDefaultValueSql("0");
  252.                 entity.Property(e => e.Type).HasDefaultValueSql("0");
  253.                 entity.Property(e => e.VerifyFlag).HasDefaultValueSql("0");
  254.             });
  256.             modelBuilder.Entity<ContactHeadImgUrl>(entity =>
  257.             {
  258.                 entity.HasKey(e => e.UsrName);
  260.                 entity.ToTable("ContactHeadImgUrl");
  262.                 entity.HasIndex(e => e.Reverse0, "reverse0Index");
  264.                 entity.Property(e => e.UsrName).HasColumnName("usrName");
  265.                 entity.Property(e => e.BigHeadImgUrl).HasColumnName("bigHeadImgUrl");
  266.                 entity.Property(e => e.HeadImgMd5).HasColumnName("headImgMd5");
  267.                 entity.Property(e => e.Reverse0)
  268.                     .HasColumnType("INT")
  269.                     .HasColumnName("reverse0");
  270.                 entity.Property(e => e.Reverse1).HasColumnName("reverse1");
  271.                 entity.Property(e => e.SmallHeadImgUrl).HasColumnName("smallHeadImgUrl");
  272.             });
  274.             modelBuilder.Entity<ContactLabel>(entity =>
  275.             {
  276.                 entity.HasKey(e => e.LabelId);
  278.                 entity.ToTable("ContactLabel");
  280.                 entity.Property(e => e.LabelId).ValueGeneratedNever();
  281.             });
  283.             modelBuilder.Entity<DelayDownLoad>(entity =>
  284.             {
  285.                 entity
  286.                     .HasNoKey()
  287.                     .ToTable("DelayDownLoad");
  289.                 entity.HasIndex(e => e.MessageServId, "IX_DelayDownLoad_MessageServId").IsUnique();
  290.             });
  292.             modelBuilder.Entity<FtschatroomTran>(entity =>
  293.             {
  294.                 entity
  295.                     .HasNoKey()
  296.                     .ToTable("FTSChatroomTrans");
  298.                 entity.Property(e => e.DisplayName).HasColumnName("displayName");
  299.                 entity.Property(e => e.GroupUsername).HasColumnName("groupUsername");
  300.                 entity.Property(e => e.Nickname).HasColumnName("nickname");
  301.                 entity.Property(e => e.Operation).HasColumnName("operation");
  302.                 entity.Property(e => e.Reserve1).HasColumnName("reserve1");
  303.                 entity.Property(e => e.Reserve2).HasColumnName("reserve2");
  304.                 entity.Property(e => e.Username).HasColumnName("username");
  305.             });
  307.             modelBuilder.Entity<FtscontactTran>(entity =>
  308.             {
  309.                 entity
  310.                     .HasNoKey()
  311.                     .ToTable("FTSContactTrans");
  313.                 entity.Property(e => e.Reserve1).HasColumnName("reserve1");
  314.                 entity.Property(e => e.Reserve2).HasColumnName("reserve2");
  315.                 entity.Property(e => e.Username).HasColumnName("username");
  316.             });
  318.             modelBuilder.Entity<MainConfig>(entity =>
  319.             {
  320.                 entity.HasKey(e => e.Key);
  322.                 entity.ToTable("MainConfig");
  324.                 entity.HasIndex(e => e.Reserved0, "MainConfigReserved0Idx");
  326.                 entity.HasIndex(e => e.Reserved1, "MainConfigReserved1Idx");
  328.                 entity.Property(e => e.Reserved0).HasColumnType("INT");
  329.                 entity.Property(e => e.Reserved1).HasColumnType("INT");
  330.             });
  332.             modelBuilder.Entity<OpLog>(entity =>
  333.             {
  334.                 entity.ToTable("OpLog");
  336.                 entity.Property(e => e.Id)
  337.                     .ValueGeneratedNever()
  338.                     .HasColumnName("ID");
  339.                 entity.Property(e => e.CmditemBuffer).HasColumnName("CMDItemBuffer");
  340.             });
  342.             modelBuilder.Entity<PatInfo>(entity =>
  343.             {
  344.                 entity.HasKey(e => e.Username);
  346.                 entity.ToTable("PatInfo");
  348.                 entity.Property(e => e.Username).HasColumnName("username");
  349.                 entity.Property(e => e.Reserved1)
  350.                     .HasDefaultValueSql("0")
  351.                     .HasColumnName("reserved1");
  352.                 entity.Property(e => e.Reserved2)
  353.                     .HasDefaultValueSql("0")
  354.                     .HasColumnName("reserved2");
  355.                 entity.Property(e => e.Reserved3)
  356.                     .HasDefaultValueSql("0")
  357.                     .HasColumnName("reserved3");
  358.                 entity.Property(e => e.Reserved4)
  359.                     .HasDefaultValueSql("0")
  360.                     .HasColumnName("reserved4");
  361.                 entity.Property(e => e.Reserved5).HasColumnName("reserved5");
  362.                 entity.Property(e => e.Reserved6).HasColumnName("reserved6");
  363.                 entity.Property(e => e.Reserved7).HasColumnName("reserved7");
  364.                 entity.Property(e => e.Reserved8).HasColumnName("reserved8");
  365.                 entity.Property(e => e.Reserved9).HasColumnName("reserved9");
  366.                 entity.Property(e => e.Suffix).HasColumnName("suffix");
  367.             });
  369.             modelBuilder.Entity<RevokeMsgStorage>(entity =>
  370.             {
  371.                 entity.HasKey(e => e.CreateTime);
  373.                 entity.ToTable("RevokeMsgStorage");
  375.                 entity.HasIndex(e => e.MsgSvrId, "MsgSvrId_Idx");
  377.                 entity.HasIndex(e => e.RevokeSvrId, "RevokeSvrID_Idx");
  379.                 entity.Property(e => e.CreateTime).ValueGeneratedNever();
  380.                 entity.Property(e => e.MsgSvrId)
  381.                     .HasColumnType("INTERGER")
  382.                     .HasColumnName("MsgSvrID");
  383.                 entity.Property(e => e.RevokeSvrId)
  384.                     .HasColumnType("INTERGER")
  385.                     .HasColumnName("RevokeSvrID");
  386.             });
  388.             modelBuilder.Entity<Session>(entity =>
  389.             {
  390.                 entity.HasKey(e => e.StrUsrName);
  392.                 entity.ToTable("Session");
  394.                 entity.HasIndex(e => e.NOrder, "nOrderIndex");
  396.                 entity.Property(e => e.StrUsrName).HasColumnName("strUsrName");
  397.                 entity.Property(e => e.BytesXml).HasColumnName("bytesXml");
  398.                 entity.Property(e => e.EditContent).HasColumnName("editContent");
  399.                 entity.Property(e => e.NIsSend).HasColumnName("nIsSend");
  400.                 entity.Property(e => e.NMsgLocalId).HasColumnName("nMsgLocalID");
  401.                 entity.Property(e => e.NMsgStatus).HasColumnName("nMsgStatus");
  402.                 entity.Property(e => e.NMsgType).HasColumnName("nMsgType");
  403.                 entity.Property(e => e.NOrder)
  404.                     .HasDefaultValueSql("0")
  405.                     .HasColumnType("INT")
  406.                     .HasColumnName("nOrder");
  407.                 entity.Property(e => e.NStatus).HasColumnName("nStatus");
  408.                 entity.Property(e => e.NTime).HasColumnName("nTime");
  409.                 entity.Property(e => e.NUnReadCount)
  410.                     .HasDefaultValueSql("0")
  411.                     .HasColumnName("nUnReadCount");
  412.                 entity.Property(e => e.OthersAtMe)
  413.                     .HasColumnType("INT")
  414.                     .HasColumnName("othersAtMe");
  415.                 entity.Property(e => e.ParentRef).HasColumnName("parentRef");
  416.                 entity.Property(e => e.Reserved0).HasDefaultValueSql("0");
  417.                 entity.Property(e => e.Reserved2).HasDefaultValueSql("0");
  418.                 entity.Property(e => e.Reserved4).HasDefaultValueSql("0");
  419.                 entity.Property(e => e.StrContent).HasColumnName("strContent");
  420.                 entity.Property(e => e.StrNickName).HasColumnName("strNickName");
  421.             });
  423.             modelBuilder.Entity<TicketInfo>(entity =>
  424.             {
  425.                 entity.HasKey(e => e.UserName);
  427.                 entity.ToTable("TicketInfo");
  429.                 entity.Property(e => e.Reserved1).HasDefaultValueSql("0");
  430.                 entity.Property(e => e.Reserved3).HasDefaultValueSql("0");
  431.             });
  433.             modelBuilder.Entity<TopStoryReddotInfo>(entity =>
  434.             {
  435.                 entity.HasKey(e => e.MsgId);
  437.                 entity.ToTable("TopStoryReddotInfo");
  439.                 entity.Property(e => e.H5version).HasColumnName("H5Version");
  440.             });
  442.             OnModelCreatingPartial(modelBuilder);
  443.         }
  445.         partial void OnModelCreatingPartial(ModelBuilder modelBuilder);
  446.     }
  447. }

结尾

　　　　在本文中，我们一共讲了AddDbContext做了什么，DBContext的构造函数又做了那些事情，在写了不托管EF的ioc到WEB的ioc的场景下如果注入服务到EF的ioc中，以及如何拦截增删改查的方式，提升查询性能的方式，以及最后的EF的ioc托管到WEB的ioc，本文作为源码讲解的第一章，觉得写的有点多，如果又看不懂的地方，或者代码下载下来没办法运行或者保存的地方可以随时联系我，QQ934550201.我们下次再见。数据库是我破解的我本地的微信数据的一部分，emmm作为了本次的例子，我希望大家能够合理看待我的这个数据库的数据，不要做一些不好的事情，谢谢大家。

　　　　本次的代码例子地址

               链接：https://pan.baidu.com/s/1w6kFG5MCJYE0jzEBxjQTKw

               提取码：foin

　　　　之前AOP的代码例子

　　　　链接：https://pan.baidu.com/s/1AJe4-KhjIESbDtFNqM968Q
　　　　提取码：jp20

原文链接：https://www.cnblogs.com/1996-Chinese-Chen/p/17761733.html

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

Java热门文章

  • 【IDEA】Application context not configured for this file
  • [IDEA] chapter_reader - idea看小说插件 idea阅读插件 idea摸鱼插件
  • thrift常见异常及原因分析
  • Java 调用 PaddleDetection 模型
  • JVM 详解，大白话带你认识 JVM
  • spring-boot-2.0.3不一样系列之番外篇 - @Configuration、Condition与@Conditional
  • Java Comparator.comparing比较导致空指针异常的解决
  • Java使用EasyExcel进行单元格合并的问题详解
  • 死磕 java集合之ArrayBlockingQueue源码分析
  • Java基础之集合Set详解

    • Java推荐文章

  • 面试场景题：一次关于线程池使用场景的讨论。
  • 前端黑科技：使用 JavaScript 实现网页扫码功能
  • 聊一聊 Netty 数据搬运工 ByteBuf 体系的设计与实现
  • 简单设计一个JAVA并行处理工具类
  • 【杂谈】JPA乐观锁改悲观锁遇到的一些问题与思考
  • 认识netty的基本组件
  • Jenkins如何使用CrumbIssuer防御CSRF攻击
  • 如何平稳地从nacos迁移到r-nacos？
  • 线程池遇到父子任务，有大坑，要注意！
  • Java JVM——12. 垃圾回收理论概述

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号