class Program
    {
        static void Main(string[] args)
        {
            var services = new ServiceCollection();
            services.AddLogging();


            //test 1
            var options = new DbContextOptionsBuilder<EFCoreDbContext>()
              .UseSqlServer(Config.connectionString)
              .Options;


            ////test 2 模拟 AddDbContext
            //services.AddMemoryCache(/*c=> { c.ExpirationScanFrequency = new TimeSpan(0,0,5);c.CompactionPercentage = 1;c.SizeLimit = 20000; }*/);

            //Action<DbContextOptionsBuilder> optionsAction = o => o.UseSqlServer(Config.connectionString);
            //Action<IServiceProvider, DbContextOptionsBuilder> optionsAction2 = (sp, o) => optionsAction.Invoke(o);

            //services.TryAdd(new ServiceDescriptor(typeof(DbContextOptions<EFCoreDbContext>), p =>
            //{
            //    Console.WriteLine($"正在从ServiceProvider[{p.GetHashCode().ToString()}]中获取/创建DbContextOptions<EFCoreDbContext>实例");
            //    //Console.ReadKey();
            //    return DbContextOptionsFactory<EFCoreDbContext>(p, optionsAction2);
            //}, ServiceLifetime.Scoped));
            //services.Add(new ServiceDescriptor(typeof(DbContextOptions), p => p.GetRequiredService<DbContextOptions<EFCoreDbContext>>(), ServiceLifetime.Scoped));

            //这两个注册方式二选一， 使用第一行表示启用test 1， 使用第二行表示启用test 2    
            //services.AddScoped(s => new EFCoreDbContext(options)); 
            //services.AddScoped(s => new EFCoreDbContext(s.GetRequiredService<DbContextOptions<EFCoreDbContext>>()));

            services.AddScoped<IMemoryCacheTest, MemoryCacheTest>();

            services.AddDbContext<EFCoreDbContext>((p, o) =>
            {
                Console.WriteLine($"UseInternalServiceProvider[{p.GetHashCode().ToString()}]");
                o.UseSqlServer(Config.connectionString);
            });
            //services.AddEntityFrameworkSqlServer().AddDbContext<EFCoreDbContext>((p,o)=> {
            //    Console.WriteLine($"UseInternalServiceProvider[{p.GetHashCode().ToString()}]");
            //    o.UseSqlServer(Config.connectionString).UseInternalServiceProvider(p); });

            ILogger log;

            var rootServiceProvider = services.BuildServiceProvider();
            for (int i = 0; i < 10; i++)
            {
                
                Console.WriteLine($"rootServiceProvider[{rootServiceProvider.GetHashCode().ToString()}]");
                //log = rootServiceProvider.GetService<ILoggerFactory>().AddConsole().CreateLogger<Program>();
                //log.LogInformation("日志输出正常");
                using (var test = new TestUserCase(rootServiceProvider))
                {
                    test.InvokeMethod();
                }

            }

            //rootServiceProvider.Dispose();
            //rootServiceProvider = null;

            Console.WriteLine("执行完毕，请按任意键继续...");
            Console.ReadKey();
        }

        private static DbContextOptions<TContext> DbContextOptionsFactory<TContext>(IServiceProvider applicationServiceProvider,
            Action<IServiceProvider, DbContextOptionsBuilder> optionsAction)
            where TContext : DbContext
        {
            var builder = new DbContextOptionsBuilder<TContext>(
                new DbContextOptions<TContext>(new Dictionary<Type, IDbContextOptionsExtension>()));

            Console.WriteLine($"将ServiceProvider[{applicationServiceProvider.GetHashCode().ToString()}]设置为ApplicationServiceProvider");
            //Console.ReadKey();

            builder.UseApplicationServiceProvider(applicationServiceProvider);

            optionsAction?.Invoke(applicationServiceProvider, builder);

            return builder.Options;
        }
    }

    //调试时使用查看一下当前系统内的缓存状态
    public interface IMemoryCacheTest
    {
        void Test();
    }

    public class MemoryCacheTest : IMemoryCacheTest
    {
        private IMemoryCache _cache;

        public MemoryCacheTest(IMemoryCache memoryCache)
        {
            _cache = memoryCache;
        }

        public void Test()
        {
            var x = _cache.GetType();
        }
    }

    public class TestUserCase : IDisposable
    {
        //private IServiceCollection services;
        private IServiceScope serviceScope;
        private IServiceProvider _serviceProvider;
        private EFCoreDbContext _context;
        public TestUserCase(/*IServiceCollection services,*/IServiceProvider serviceProvider)
        {
            //this.services = services;
            _serviceProvider = serviceProvider;
        }

        public void InvokeMethod()
        {

            //_serviceProvider = services.BuildServiceProvider();
            using (serviceScope = _serviceProvider.GetRequiredService<IServiceScopeFactory>().CreateScope())
            {
                var internalServiceProvider = serviceScope.ServiceProvider;
                Console.WriteLine($"获取一个新的ServiceProvider[{internalServiceProvider.GetHashCode().ToString()}]");

                Console.WriteLine($"获取一个新的ServiceProviderType[{internalServiceProvider.GetType().GetHashCode().ToString()}]");

                var memoryCache = internalServiceProvider?.GetService<IMemoryCache>();
                var loggerFactory = internalServiceProvider?.GetService<ILoggerFactory>();

                Console.WriteLine($"当前ServiceProvider.GetService<IMemoryCache>():{memoryCache.GetHashCode().ToString()}");
                Console.WriteLine($"当前ServiceProvider.GetService<ILoggerFactory>():{loggerFactory.GetHashCode().ToString()}");

                //using (_context = internalServiceProvider.GetRequiredService<EFCoreDbContext>())
                //{
                _context = internalServiceProvider.GetRequiredService<EFCoreDbContext>();
                Printf(_serviceProvider, internalServiceProvider, _context, serviceScope);
                //}

                var cacheTest = _serviceProvider.GetRequiredService<IMemoryCacheTest>();
                cacheTest.Test();

                //(internalServiceProvider as IDisposable)?.Dispose();
                //internalServiceProvider = null;
            }
        }

        public void Printf(IServiceProvider sp, IServiceProvider _serviceProvider, EFCoreDbContext _context, IServiceScope _serviceScope)
        {
            for (var i = 0; i < 100; i++)
            {
                var testA = _context.TestA.AsNoTracking().FirstOrDefault();
                //_context.TestA.Add(new TestA() {  Name = "test"});
                //_context.SaveChanges();

                Console.WriteLine($"RootSP:{sp.GetHashCode()}  CurrentSP:{_serviceProvider.GetHashCode()}  DbContext:{_context?.GetHashCode()}  Index:{i}");
            }
        }


        private bool disposed = false;

        public void Dispose()
        {
            Console.WriteLine($"{this.GetType().Name}.Dispose()...");
            Dispose(true);
            GC.SuppressFinalize(this);
        }
        protected virtual void Dispose(bool disposing)
        {
            if (!this.disposed)
            {
                // Note disposing has been done.
                disposed = true;

                //serviceScope?.Dispose();
                //serviceScope = null;
                ////
                ////(_serviceProvider as IDisposable)?.Dispose();
                ////_serviceProvider = null;

                //_context?.Dispose();
                //_context = null;
            }
        }
    }

    public class EFCoreDbContext : DbContext
    {
        public EFCoreDbContext(DbContextOptions<EFCoreDbContext> options) : base(options)
        {
            //模拟生成EF Core 缓存key
            var key = options.Extensions
                .OrderBy(e => e.GetType().Name)
                .Aggregate(0L, (t, e) => (t * 397) ^ ((long)e.GetType().GetHashCode() * 397) ^ e.GetServiceProviderHashCode());
            Console.WriteLine($"EF Core当前DbContextOptions实例生成的缓存key为：{key}");

            //打印影响生成缓存key值的对象名、HashCore、自定义的ServiceProviderHashCode
            var oExtensions = options.Extensions.OrderBy(e => e.GetType().Name);
            Console.WriteLine($"打印引起key变化的IDbContextOptionsExtension实例列表");
            foreach (var item in oExtensions)
            {
                Console.WriteLine($"item name:{item.GetType().Name} HashCode:{item.GetType().GetHashCode()} ServiceProviderHashCore:{item.GetServiceProviderHashCode()}");
            }

            //从上一步打印结果来看，oExtensions内包含两个对象，SqlServerOptionsExtension和CoreOptionsExtension
            //SqlServerOptionsExtension的HashCode和ServiceProviderHashCode每次都一样，不是变化因素，不再跟踪
            //CoreOptionsExtension 用来表示由EF Core 管理的选项，而不是由数据库提供商或扩展管理的选项。
            //上面的代码中 builder.UseApplicationServiceProvider(applicationServiceProvider); 这句就是把当前 ServiceProvider 设置到该类型实例的 ApplicationServiceProvider 属性
            var coreOptionsExtension = options.FindExtension<CoreOptionsExtension>();
            if (coreOptionsExtension != null)
            {
                var x = coreOptionsExtension;

                Console.WriteLine($"\n打印CoreOptionsExtension的一些HashCode\n" +
                    $"GetServiceProviderHashCode:{x.GetServiceProviderHashCode()} \n" +
                    $"HashCode:{x.GetHashCode()} \n" +
                    $"ApplicationServiceProvider HashCode:{x.ApplicationServiceProvider?.GetHashCode()} \n" +
                    $"InternalServiceProvider HashCode:{x.InternalServiceProvider?.GetHashCode()}");

                //模拟GetServiceProviderHashCode的生成过程
                var memoryCache = x.MemoryCache ?? x.ApplicationServiceProvider?.GetService<IMemoryCache>();
                var loggerFactory = x.LoggerFactory ?? x.ApplicationServiceProvider?.GetService<ILoggerFactory>();
                var isSensitiveDataLoggingEnabled = x.IsSensitiveDataLoggingEnabled;
                var warningsConfiguration = x.WarningsConfiguration;

                var hashCode = loggerFactory?.GetHashCode() ?? 0L;
                hashCode = (hashCode * 397) ^ (memoryCache?.GetHashCode() ?? 0L);
                hashCode = (hashCode * 397) ^ isSensitiveDataLoggingEnabled.GetHashCode();
                hashCode = (hashCode * 397) ^ warningsConfiguration.GetServiceProviderHashCode();

                if (x.ReplacedServices != null)
                {
                    hashCode = x.ReplacedServices.Aggregate(hashCode, (t, e) => (t * 397) ^ e.Value.GetHashCode());
                }

                Console.WriteLine($"\n模拟生成GetServiceProviderHashCode:{hashCode}");
                if (x.GetServiceProviderHashCode() == hashCode)
                {
                    Console.WriteLine($"模拟生成的GetServiceProviderHashCode和GetServiceProviderHashCode()获取的一致");
                }

                //打印GetServiceProviderHashCode的生成步骤，对比差异
                Console.WriteLine($"\n影响GetServiceProviderHashCode值的因素");
                Console.WriteLine($"loggerFactory:{loggerFactory?.GetHashCode() ?? 0L}");
                Console.WriteLine($"memoryCache:{memoryCache?.GetHashCode() ?? 0L}");
                Console.WriteLine($"isSensitiveDataLoggingEnabled:{isSensitiveDataLoggingEnabled.GetHashCode()}");
                Console.WriteLine($"warningsConfiguration:{warningsConfiguration.GetServiceProviderHashCode()}");
            }

        }

        public DbSet<TestA> TestA { get; set; }
    }

    public class TestA
    {
        public long Id { get; set; }
        public string Name { get; set; }
    }