第三節:EF Core上下文DbContext相關配置和生命周期

一. 配置相關

1. 數據庫連接字符串的寫法

(1).賬號密碼：Server=localhost;Database=EFDB01;User ID=sa;Password=123456;

(2).windows身份：Server=localhost;Database=EFDB01;Trusted_Connection=True;

2. 命令超時和默認關閉狀態追蹤

(1).命令超時： providerOptions => providerOptions.CommandTimeout(60)，表示60秒超時。

(2).關閉查詢狀態追蹤：UseQueryTrackingBehavior(QueryTrackingBehavior.NoTracking)，表示關閉追蹤；

(PS: 默認是 QueryTrackingBehavior.TrackAll 開啟追蹤）

 詳見下面案例：

　　a. QueryTrackingBehavior.NoTracking: 對應的是Detached狀態，即有游離狀態。

　　b. QueryTrackingBehavior.TrackAll: 對應的是Unchanged狀態，即未發生改變的。

 

            {
                var d1 = context1.T_UserInfor.First();
                //關閉跟蹤對應的是：Detached；開啟跟蹤對應的是：Unchanged
                var state = context1.Entry(d1).State;
            }

3. 日志記錄

　　最好在控制台中配置，能輸出生成的SQL語句。 

配置代碼分享：

 public partial class EFDB01Context : DbContext
    {
        //public static readonly LoggerFactory MyLoggerFactory = new LoggerFactory(new[] { new ConsoleLoggerProvider((_, __) => true, true) });
        public static readonly LoggerFactory MyLoggerFactory  = new LoggerFactory(new[]
         {
                new ConsoleLoggerProvider((category, level) => category == DbLoggerCategory.Database.Command.Name && level == LogLevel.Information, true)
         });
        public EFDB01Context()
        {

        }
        public virtual DbSet<T_RoleInfor> T_RoleInfor { get; set; }
        public virtual DbSet<T_UserInfor> T_UserInfor { get; set; }
        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        {
            optionsBuilder.UseSqlServer("Server=localhost;Database=EFDB01;User ID=sa;Password=123456;").UseLoggerFactory(MyLoggerFactory);
        } 
    }

輸出結果：

4. 連接彈性

    詳見官方文章：https://docs.microsoft.com/zh-cn/ef/core/miscellaneous/connection-resiliency

5. 線程安全問題

(1).說明

　　EF Core不支持在同一DbContext實例上運行多個並行操作。這包括異步查詢的並行執行以及從多個線程進行的任何顯式並發使用。因此,應await立即異步調用, 或對並行DbContext執行的操作使用單獨的實例。

　　當EFCore檢測到並行使用某個DbContext實例時, 觸發InvalidOperationException異常；但是當並發訪問未被檢測時, 可能會導致未定義的行為、應用程序崩潰和數據損壞.

(2).情況一：在對同一 DbContext 啟動任何其他操作之前, 忘記等待異步操作完成。

　　使用異步方法, EF Core 可以啟動以非阻止方式訪問數據庫的操作。 但是, 如果調用方不等待其中一種方法完成, 並繼續在上DbContext執行其他操作,則的DbContext狀態可能會損壞。

(3).情況二：Core MVC通過依賴關系注入在多個線程之間隱式共享 DbContext 實例

 　　默認AddDbContext情況下，注入的上下文是請求內單例的，所以每個請求都獲得了單獨的DbContext，請求與請求之間的DbContext是線程安全的；但是，在同一個請求中，任何並行顯式執行多個線程的代碼都應該DbContext確保不會同時訪問實例，否則會出現上述“情況一”的狀況。

(4). 案例說明：要避免下面案例的那種情況，公用同一個上下文，是沒法保證線程安全的。

代碼分享：

            {
                var optionsBuilder = new DbContextOptionsBuilder<EFDB01Context>();
                optionsBuilder.UseSqlServer(configuration.GetConnectionString("EFStr"));
                EFDB01Context context = new EFDB01Context(optionsBuilder.Options);
                Task.Run(() =>
                {
                    while (true)
                    {
                        var u1 = new T_UserInfor()
                        {
                            id = Guid.NewGuid().ToString("N"),
                            userName = "ypf2",
                            userSex = "男2",
                            userAge = 19,
                            addTime = DateTime.Now
                        };
                        context.Set<T_UserInfor>().Add(u1);
                        int result = context.SaveChanges();
                    }
                });

                Task.Run(() =>
                {
                    while (true)
                    {
                        var u1 = new T_UserInfor()
                        {
                            id = Guid.NewGuid().ToString("N"),
                            userName = "ypf2",
                            userSex = "男2",
                            userAge = 19,
                            addTime = DateTime.Now
                        };
                        context.Set<T_UserInfor>().Add(u1);
                        int result = context.SaveChanges();
                    }
                });
                Task.Delay(TimeSpan.FromMinutes(15)).Wait();
            }

6. 連接數和連接池問題

(1).查詢數據庫連接數語句：SELECT * FROM SYSPROCESSES WHERE DBID = DB_ID('數據庫名')

(2).手動設置連接池的最大(小)數量： "Server=localhost;Database=Test;Trusted_Connection=True;Max Pool Size=100;Min Pool Size=5"

(3).連接池的運行原理：

概念：連接到數據源可能需要很長時間。 為了最大程度地降低打開連接的成本，ADO.NET 使用一種稱為連接池的優化技術，這會最大程度地降低重復打開和關閉連接的成本。

A. 當一個程序執行Connection.open()時候，ADO.Net就需要判斷，此連接是否支持Connection Pool (Pooling 默認為True)

　①：如果指定為False, ADO.Net就與數據庫之間創建一個連接，然后返回給程序。

　②：如果指定為 True，ADO.Net就會根據ConnectString創建一個Connection Pool，然后向Connection Pool中填充Connection。填充多少個Connection由Min Pool Size (默認為0)屬性來決定。例如如果指定為5，則ADO.Net會一次與SQL數據庫之間打開5個連接，然后將4個Connection，保存在 Connection Pool中，1個Connection返回給程序。

B. 當程序執行到Connection.close() 的時候。如果Pooling 為True，ADO.net 就把當前的Connection放到Connection Pool並且保持與數據庫之間的連接。

同時還會判斷Connection Lifetime(默認為0)屬性，0代表無限大，如果Connection存在的時間超過了Connection LifeTime，ADO.net就會關閉的Connection同時斷開與數據庫的連接，而不是重新保存到Connection Pool中。

C. 當下一次Connection.Open() 執行的時候，ADO.Net就會判斷新的ConnectionString與之前保存在Connection Pool中的Connection的connectionString是否一致。

D. ADO.Net需要判斷當前的Connection Pool中是否有可以使用的Connection(沒有被其他程序所占用)，如果沒有的話，ADO.Net就需要判斷ConnectionString設 置的Max Pool Size （默認為100）

　①. 如果Connection Pool中的所有Connection沒有達到Max Pool Size，ADO.net則會再次連接數據庫，創建一個連接，然后將Connection返回給程序。

　②. 如果已經達到了 Max Pool Size，ADO.Net就不會再次創建任何新的連接，而是等待Connection Pool中被其他程序所占用的Connection釋放，這個等待時間受SqlConnection.ConnectionTimeout（默認是15 秒）限制，也就是說如果時間超過了15秒，SqlConnection就會拋出超時錯誤。

E. 如果有可用的Connection，從Connection Pool 取出的Connection也不是直接就返回給程序，ADO.Net還需要檢查ConnectionString的ConnectionReset屬性 (默認為True)是否需要對Connection 做一次reset。

更詳細的介紹請參考官方文檔：https://docs.microsoft.com/zh-cn/dotnet/framework/data/adonet/sql-server-connection-pooling

7. 總結

(1).SaveChanges的時候數據庫連接自動釋放，所以不需要手動釋放。

(2).調用using的方法可以，因為dispose里講很多東西都滯空了，完全沒問題；但在Core MVC中，EF上下文都是通過依賴注入，能控制生命周期，所以不再需要using。

(3).手動open然后手動close，連接數沒有釋放，因為連接池的概念，當然你可以手動配置連接池數目（強制刪除連接池：ClearAllPools），只有當IIS關閉，連接才徹底釋放。

 

二. 生命周期

1.源碼分析 

public enum ServiceLifetime { Singleton = 0, Scoped = 1, Transient = 2 }

(1).Singleton ：整個應用程序生命周期以內只創建一個實例。

(2).Scoped： 在同一個Scope內只初始化一個實例 ，可以理解為（每一個 request 級別只創建一個實例）

(3).Transient： 每一次 GetService 都會創建一個新的實例。

注：默認是Scoped，即單次請求內是單例的。

 可以自行配置：

 

 通過查源碼可知，默認就是Scoped的。

 

 //
    // 摘要:
    //     Extension methods for setting up Entity Framework related services in an Microsoft.Extensions.DependencyInjection.IServiceCollection.
    public static class EntityFrameworkServiceCollectionExtensions
    {
        //
        // 摘要:
        //     Registers the given context as a service in the Microsoft.Extensions.DependencyInjection.IServiceCollection.
        //     You use this method when using dependency injection in your application, such
        //     as with ASP.NET. For more information on setting up dependency injection, see
        //     http://go.microsoft.com/fwlink/?LinkId=526890.
        //
        // 參數:
        //   serviceCollection:
        //     The Microsoft.Extensions.DependencyInjection.IServiceCollection to add services
        //     to.
        //
        //   optionsAction:
        //     An optional action to configure the Microsoft.EntityFrameworkCore.DbContextOptions
        //     for the context. This provides an alternative to performing configuration of
        //     the context by overriding the Microsoft.EntityFrameworkCore.DbContext.OnConfiguring(Microsoft.EntityFrameworkCore.DbContextOptionsBuilder)
        //     method in your derived context.
        //     If an action is supplied here, the Microsoft.EntityFrameworkCore.DbContext.OnConfiguring(Microsoft.EntityFrameworkCore.DbContextOptionsBuilder)
        //     method will still be run if it has been overridden on the derived context. Microsoft.EntityFrameworkCore.DbContext.OnConfiguring(Microsoft.EntityFrameworkCore.DbContextOptionsBuilder)
        //     configuration will be applied in addition to configuration performed here.
        //     In order for the options to be passed into your context, you need to expose a
        //     constructor on your context that takes Microsoft.EntityFrameworkCore.DbContextOptions`1
        //     and passes it to the base constructor of Microsoft.EntityFrameworkCore.DbContext.
        //
        //   contextLifetime:
        //     The lifetime with which to register the DbContext service in the container.
        //
        //   optionsLifetime:
        //     The lifetime with which to register the DbContextOptions service in the container.
        //
        // 類型參數:
        //   TContext:
        //     The type of context to be registered.
        //
        // 返回結果:
        //     The same service collection so that multiple calls can be chained.
        public static IServiceCollection AddDbContext<TContext>([NotNullAttribute] this IServiceCollection serviceCollection, [CanBeNullAttribute] Action<DbContextOptionsBuilder> optionsAction = null, ServiceLifetime contextLifetime = ServiceLifetime.Scoped, ServiceLifetime optionsLifetime = ServiceLifetime.Scoped) where TContext : DbContext;
        //
        // 摘要:
        //     Registers the given context as a service in the Microsoft.Extensions.DependencyInjection.IServiceCollection.
        //     You use this method when using dependency injection in your application, such
        //     as with ASP.NET. For more information on setting up dependency injection, see
        //     http://go.microsoft.com/fwlink/?LinkId=526890.
        //
        // 參數:
        //   serviceCollection:
        //     The Microsoft.Extensions.DependencyInjection.IServiceCollection to add services
        //     to.
        //
        //   optionsAction:
        //     An optional action to configure the Microsoft.EntityFrameworkCore.DbContextOptions
        //     for the context. This provides an alternative to performing configuration of
        //     the context by overriding the Microsoft.EntityFrameworkCore.DbContext.OnConfiguring(Microsoft.EntityFrameworkCore.DbContextOptionsBuilder)
        //     method in your derived context.
        //     If an action is supplied here, the Microsoft.EntityFrameworkCore.DbContext.OnConfiguring(Microsoft.EntityFrameworkCore.DbContextOptionsBuilder)
        //     method will still be run if it has been overridden on the derived context. Microsoft.EntityFrameworkCore.DbContext.OnConfiguring(Microsoft.EntityFrameworkCore.DbContextOptionsBuilder)
        //     configuration will be applied in addition to configuration performed here.
        //     In order for the options to be passed into your context, you need to expose a
        //     constructor on your context that takes Microsoft.EntityFrameworkCore.DbContextOptions`1
        //     and passes it to the base constructor of Microsoft.EntityFrameworkCore.DbContext.
        //
        //   contextLifetime:
        //     The lifetime with which to register the DbContext service in the container.
        //
        //   optionsLifetime:
        //     The lifetime with which to register the DbContextOptions service in the container.
        //
        // 類型參數:
        //   TContextService:
        //     The class or interface that will be used to resolve the context from the container.
        //
        //   TContextImplementation:
        //     The concrete implementation type to create.
        //
        // 返回結果:
        //     The same service collection so that multiple calls can be chained.
        public static IServiceCollection AddDbContext<TContextService, TContextImplementation>([NotNullAttribute] this IServiceCollection serviceCollection, [CanBeNullAttribute] Action<DbContextOptionsBuilder> optionsAction = null, ServiceLifetime contextLifetime = ServiceLifetime.Scoped, ServiceLifetime optionsLifetime = ServiceLifetime.Scoped) where TContextImplementation : DbContext, TContextService;
        //
        // 摘要:
        //     Registers the given context as a service in the Microsoft.Extensions.DependencyInjection.IServiceCollection.
        //     You use this method when using dependency injection in your application, such
        //     as with ASP.NET. For more information on setting up dependency injection, see
        //     http://go.microsoft.com/fwlink/?LinkId=526890.
        //
        // 參數:
        //   serviceCollection:
        //     The Microsoft.Extensions.DependencyInjection.IServiceCollection to add services
        //     to.
        //
        //   contextLifetime:
        //     The lifetime with which to register the DbContext service in the container.
        //
        //   optionsLifetime:
        //     The lifetime with which to register the DbContextOptions service in the container.
        //
        // 類型參數:
        //   TContext:
        //     The type of context to be registered.
        //
        // 返回結果:
        //     The same service collection so that multiple calls can be chained.
        public static IServiceCollection AddDbContext<TContext>([NotNullAttribute] this IServiceCollection serviceCollection, ServiceLifetime contextLifetime, ServiceLifetime optionsLifetime = ServiceLifetime.Scoped) where TContext : DbContext;
        //
        // 摘要:
        //     Registers the given context as a service in the Microsoft.Extensions.DependencyInjection.IServiceCollection.
        //     You use this method when using dependency injection in your application, such
        //     as with ASP.NET. For more information on setting up dependency injection, see
        //     http://go.microsoft.com/fwlink/?LinkId=526890.
        //
        // 參數:
        //   serviceCollection:
        //     The Microsoft.Extensions.DependencyInjection.IServiceCollection to add services
        //     to.
        //
        //   contextLifetime:
        //     The lifetime with which to register the DbContext service in the container.
        //
        //   optionsLifetime:
        //     The lifetime with which to register the DbContextOptions service in the container.
        //
        // 類型參數:
        //   TContextService:
        //     The class or interface that will be used to resolve the context from the container.
        //
        //   TContextImplementation:
        //     The concrete implementation type to create.
        //
        // 返回結果:
        //     The same service collection so that multiple calls can be chained.
        public static IServiceCollection AddDbContext<TContextService, TContextImplementation>([NotNullAttribute] this IServiceCollection serviceCollection, ServiceLifetime contextLifetime, ServiceLifetime optionsLifetime = ServiceLifetime.Scoped)
            where TContextService : class
            where TContextImplementation : DbContext, TContextService;
        //
        // 摘要:
        //     Registers the given context as a service in the Microsoft.Extensions.DependencyInjection.IServiceCollection.
        //     You use this method when using dependency injection in your application, such
        //     as with ASP.NET. For more information on setting up dependency injection, see
        //     http://go.microsoft.com/fwlink/?LinkId=526890.
        //     This overload has an optionsAction that provides the applications System.IServiceProvider.
        //     This is useful if you want to setup Entity Framework to resolve its internal
        //     services from the primary application service provider. By default, we recommend
        //     using the other overload, which allows Entity Framework to create and maintain
        //     its own System.IServiceProvider for internal Entity Framework services.
        //
        // 參數:
        //   serviceCollection:
        //     The Microsoft.Extensions.DependencyInjection.IServiceCollection to add services
        //     to.
        //
        //   optionsAction:
        //     An optional action to configure the Microsoft.EntityFrameworkCore.DbContextOptions
        //     for the context. This provides an alternative to performing configuration of
        //     the context by overriding the Microsoft.EntityFrameworkCore.DbContext.OnConfiguring(Microsoft.EntityFrameworkCore.DbContextOptionsBuilder)
        //     method in your derived context.
        //     If an action is supplied here, the Microsoft.EntityFrameworkCore.DbContext.OnConfiguring(Microsoft.EntityFrameworkCore.DbContextOptionsBuilder)
        //     method will still be run if it has been overridden on the derived context. Microsoft.EntityFrameworkCore.DbContext.OnConfiguring(Microsoft.EntityFrameworkCore.DbContextOptionsBuilder)
        //     configuration will be applied in addition to configuration performed here.
        //     In order for the options to be passed into your context, you need to expose a
        //     constructor on your context that takes Microsoft.EntityFrameworkCore.DbContextOptions`1
        //     and passes it to the base constructor of Microsoft.EntityFrameworkCore.DbContext.
        //
        //   contextLifetime:
        //     The lifetime with which to register the DbContext service in the container.
        //
        //   optionsLifetime:
        //     The lifetime with which to register the DbContextOptions service in the container.
        //
        // 類型參數:
        //   TContext:
        //     The type of context to be registered.
        //
        // 返回結果:
        //     The same service collection so that multiple calls can be chained.
        public static IServiceCollection AddDbContext<TContext>([NotNullAttribute] this IServiceCollection serviceCollection, [CanBeNullAttribute] Action<IServiceProvider, DbContextOptionsBuilder> optionsAction, ServiceLifetime contextLifetime = ServiceLifetime.Scoped, ServiceLifetime optionsLifetime = ServiceLifetime.Scoped) where TContext : DbContext;
        //
        // 摘要:
        //     Registers the given context as a service in the Microsoft.Extensions.DependencyInjection.IServiceCollection.
        //     You use this method when using dependency injection in your application, such
        //     as with ASP.NET. For more information on setting up dependency injection, see
        //     http://go.microsoft.com/fwlink/?LinkId=526890.
        //     This overload has an optionsAction that provides the applications System.IServiceProvider.
        //     This is useful if you want to setup Entity Framework to resolve its internal
        //     services from the primary application service provider. By default, we recommend
        //     using the other overload, which allows Entity Framework to create and maintain
        //     its own System.IServiceProvider for internal Entity Framework services.
        //
        // 參數:
        //   serviceCollection:
        //     The Microsoft.Extensions.DependencyInjection.IServiceCollection to add services
        //     to.
        //
        //   optionsAction:
        //     An optional action to configure the Microsoft.EntityFrameworkCore.DbContextOptions
        //     for the context. This provides an alternative to performing configuration of
        //     the context by overriding the Microsoft.EntityFrameworkCore.DbContext.OnConfiguring(Microsoft.EntityFrameworkCore.DbContextOptionsBuilder)
        //     method in your derived context.
        //     If an action is supplied here, the Microsoft.EntityFrameworkCore.DbContext.OnConfiguring(Microsoft.EntityFrameworkCore.DbContextOptionsBuilder)
        //     method will still be run if it has been overridden on the derived context. Microsoft.EntityFrameworkCore.DbContext.OnConfiguring(Microsoft.EntityFrameworkCore.DbContextOptionsBuilder)
        //     configuration will be applied in addition to configuration performed here.
        //     In order for the options to be passed into your context, you need to expose a
        //     constructor on your context that takes Microsoft.EntityFrameworkCore.DbContextOptions`1
        //     and passes it to the base constructor of Microsoft.EntityFrameworkCore.DbContext.
        //
        //   contextLifetime:
        //     The lifetime with which to register the DbContext service in the container.
        //
        //   optionsLifetime:
        //     The lifetime with which to register the DbContextOptions service in the container.
        //
        // 類型參數:
        //   TContextService:
        //     The class or interface that will be used to resolve the context from the container.
        //
        //   TContextImplementation:
        //     The concrete implementation type to create.
        //
        // 返回結果:
        //     The same service collection so that multiple calls can be chained.
        public static IServiceCollection AddDbContext<TContextService, TContextImplementation>([NotNullAttribute] this IServiceCollection serviceCollection, [CanBeNullAttribute] Action<IServiceProvider, DbContextOptionsBuilder> optionsAction, ServiceLifetime contextLifetime = ServiceLifetime.Scoped, ServiceLifetime optionsLifetime = ServiceLifetime.Scoped) where TContextImplementation : DbContext, TContextService;
        //
        // 摘要:
        //     Registers the given context as a service in the Microsoft.Extensions.DependencyInjection.IServiceCollection
        //     and enables DbContext pooling. Instance pooling can increase throughput in high-scale
        //     scenarios such as web servers by re-using DbContext instances, rather than creating
        //     new instances for each request. You use this method when using dependency injection
        //     in your application, such as with ASP.NET. For more information on setting up
        //     dependency injection, see http://go.microsoft.com/fwlink/?LinkId=526890.
        //
        // 參數:
        //   serviceCollection:
        //     The Microsoft.Extensions.DependencyInjection.IServiceCollection to add services
        //     to.
        //
        //   optionsAction:
        //     A required action to configure the Microsoft.EntityFrameworkCore.DbContextOptions
        //     for the context. When using context pooling, options configuration must be performed
        //     externally; Microsoft.EntityFrameworkCore.DbContext.OnConfiguring(Microsoft.EntityFrameworkCore.DbContextOptionsBuilder)
        //     will not be called.
        //
        //   poolSize:
        //     Sets the maximum number of instances retained by the pool.
        //
        // 類型參數:
        //   TContext:
        //     The type of context to be registered.
        //
        // 返回結果:
        //     The same service collection so that multiple calls can be chained.
        public static IServiceCollection AddDbContextPool<TContext>([NotNullAttribute] this IServiceCollection serviceCollection, [NotNullAttribute] Action<DbContextOptionsBuilder> optionsAction, int poolSize = 128) where TContext : DbContext;
        //
        // 摘要:
        //     Registers the given context as a service in the Microsoft.Extensions.DependencyInjection.IServiceCollection
        //     and enables DbContext pooling. Instance pooling can increase throughput in high-scale
        //     scenarios such as web servers by re-using DbContext instances, rather than creating
        //     new instances for each request. You use this method when using dependency injection
        //     in your application, such as with ASP.NET. For more information on setting up
        //     dependency injection, see http://go.microsoft.com/fwlink/?LinkId=526890.
        //
        // 參數:
        //   serviceCollection:
        //     The Microsoft.Extensions.DependencyInjection.IServiceCollection to add services
        //     to.
        //
        //   optionsAction:
        //     A required action to configure the Microsoft.EntityFrameworkCore.DbContextOptions
        //     for the context. When using context pooling, options configuration must be performed
        //     externally; Microsoft.EntityFrameworkCore.DbContext.OnConfiguring(Microsoft.EntityFrameworkCore.DbContextOptionsBuilder)
        //     will not be called.
        //
        //   poolSize:
        //     Sets the maximum number of instances retained by the pool.
        //
        // 類型參數:
        //   TContextService:
        //     The class or interface that will be used to resolve the context from the container.
        //
        //   TContextImplementation:
        //     The concrete implementation type to create.
        //
        // 返回結果:
        //     The same service collection so that multiple calls can be chained.
        public static IServiceCollection AddDbContextPool<TContextService, TContextImplementation>([NotNullAttribute] this IServiceCollection serviceCollection, [NotNullAttribute] Action<DbContextOptionsBuilder> optionsAction, int poolSize = 128)
            where TContextService : class
            where TContextImplementation : DbContext, TContextService;
        //
        // 摘要:
        //     Registers the given context as a service in the Microsoft.Extensions.DependencyInjection.IServiceCollection
        //     and enables DbContext pooling. Instance pooling can increase throughput in high-scale
        //     scenarios such as web servers by re-using DbContext instances, rather than creating
        //     new instances for each request. You use this method when using dependency injection
        //     in your application, such as with ASP.NET. For more information on setting up
        //     dependency injection, see http://go.microsoft.com/fwlink/?LinkId=526890.
        //     This overload has an optionsAction that provides the applications System.IServiceProvider.
        //     This is useful if you want to setup Entity Framework to resolve its internal
        //     services from the primary application service provider. By default, we recommend
        //     using the other overload, which allows Entity Framework to create and maintain
        //     its own System.IServiceProvider for internal Entity Framework services.
        //
        // 參數:
        //   serviceCollection:
        //     The Microsoft.Extensions.DependencyInjection.IServiceCollection to add services
        //     to.
        //
        //   optionsAction:
        //     A required action to configure the Microsoft.EntityFrameworkCore.DbContextOptions
        //     for the context. When using context pooling, options configuration must be performed
        //     externally; Microsoft.EntityFrameworkCore.DbContext.OnConfiguring(Microsoft.EntityFrameworkCore.DbContextOptionsBuilder)
        //     will not be called.
        //
        //   poolSize:
        //     Sets the maximum number of instances retained by the pool.
        //
        // 類型參數:
        //   TContext:
        //     The type of context to be registered.
        //
        // 返回結果:
        //     The same service collection so that multiple calls can be chained.
        public static IServiceCollection AddDbContextPool<TContext>([NotNullAttribute] this IServiceCollection serviceCollection, [NotNullAttribute] Action<IServiceProvider, DbContextOptionsBuilder> optionsAction, int poolSize = 128) where TContext : DbContext;
        //
        // 摘要:
        //     Registers the given context as a service in the Microsoft.Extensions.DependencyInjection.IServiceCollection
        //     and enables DbContext pooling. Instance pooling can increase throughput in high-scale
        //     scenarios such as web servers by re-using DbContext instances, rather than creating
        //     new instances for each request. You use this method when using dependency injection
        //     in your application, such as with ASP.NET. For more information on setting up
        //     dependency injection, see http://go.microsoft.com/fwlink/?LinkId=526890.
        //     This overload has an optionsAction that provides the applications System.IServiceProvider.
        //     This is useful if you want to setup Entity Framework to resolve its internal
        //     services from the primary application service provider. By default, we recommend
        //     using the other overload, which allows Entity Framework to create and maintain
        //     its own System.IServiceProvider for internal Entity Framework services.
        //
        // 參數:
        //   serviceCollection:
        //     The Microsoft.Extensions.DependencyInjection.IServiceCollection to add services
        //     to.
        //
        //   optionsAction:
        //     A required action to configure the Microsoft.EntityFrameworkCore.DbContextOptions
        //     for the context. When using context pooling, options configuration must be performed
        //     externally; Microsoft.EntityFrameworkCore.DbContext.OnConfiguring(Microsoft.EntityFrameworkCore.DbContextOptionsBuilder)
        //     will not be called.
        //
        //   poolSize:
        //     Sets the maximum number of instances retained by the pool.
        //
        // 類型參數:
        //   TContextService:
        //     The class or interface that will be used to resolve the context from the container.
        //
        //   TContextImplementation:
        //     The concrete implementation type to create.
        //
        // 返回結果:
        //     The same service collection so that multiple calls can be chained.
        public static IServiceCollection AddDbContextPool<TContextService, TContextImplementation>([NotNullAttribute] this IServiceCollection serviceCollection, [NotNullAttribute] Action<IServiceProvider, DbContextOptionsBuilder> optionsAction, int poolSize = 128)
            where TContextService : class
            where TContextImplementation : DbContext, TContextService;
    }

 2. 測試案例

　　在EF上下文的構造函數中生成一個Guid，如果是單例的，構造函數只會被調用一次，我們通過比較兩個上下文是否相等 或者 比較單次、多次請求中Guid的值是否相同來驗證依賴注入的上下文的各種生命周期。

        public EFDB01Context context1;
        public EFDB01Context context2;
        public FirstController(EFDB01Context db1, EFDB01Context db2)
        {
            context1 = db1;
            context2 = db2;
        }
        /// <summary>
        /// 生命周期測試
        /// </summary>
        public IActionResult TestLifeTime()
        {
            //測試方法一(判斷兩個上下文是否完全相同)
            bool isSame1 = object.ReferenceEquals(context1,context2);
            ViewBag.isSame = isSame1;

            //測試方法二（通過多次請求來判斷Guid值是否相等）
            ViewBag.MyGuid1 = context1.myGuid;
            ViewBag.MyGuid2 = context2.myGuid;

            return View();
        }

(1).將參數設置為Singleton: 每次請求的context1和context2的值相等，單次請求和多次請求MyGuid1、MyGuid2的值均相等，從而證明是全局單例的。

(2).將參數設置為Scoped：每次請求的context1和context2的值相等，單次請求中MyGuid1和MyGuid2的值相等，多次請求的情況下，每次產生的MyGuid1之間均不相同， 每次產生的MyGuid2之間均不相同，從而證明是請求內單例的。

(3).將參數設置為Transient：每次請求的context1和context2的值不相等，單次請求中MyGuid1和MyGuid2的值也不相等，多次請求的情況下，每次產生的MyGuid1之間均不相同， 每次產生的MyGuid2之間均不相同，從而證明是瞬時的。

 

 

 

 

 

 

 

!

• 作       者 : Yaopengfei(姚鵬飛)
• 博客地址 : http://www.cnblogs.com/yaopengfei/
• 聲     明1 : 本人才疏學淺，用郭德綱的話說“我是一個小學生”，如有錯誤，歡迎討論，請勿謾罵^_^。
• 聲     明2 : 原創博客請在轉載時保留原文鏈接或在文章開頭加上本人博客地址，否則保留追究法律責任的權利。