public void CreateModel_uses_DbCompiledModel_from_ModelStore_when_available()
        {
            var store = new Mock<DbModelStore>();

            var dbCompiledModelInStore = new DbCompiledModel();
            store.Setup(c => c.TryLoad(It.IsAny<Type>())).Returns(dbCompiledModelInStore);
            store.Setup(c => c.Save(It.IsAny<Type>(), It.IsAny<DbModel>()));

            try
            {
                var dependencyResolver = new SingletonDependencyResolver<DbModelStore>(store.Object);
                MutableResolver.AddResolver<DbModelStore>(dependencyResolver);

                var mockContext = new Mock<LazyInternalContext>(
                    new Mock<DbContext>().Object, new Mock<IInternalConnection>().Object, null, null, null, null, null)
                {
                    CallBase = true
                };

                var model = LazyInternalContext.CreateModel(mockContext.Object);
             
                Assert.Same(dbCompiledModelInStore, model);

                store.Verify(c => c.TryLoad(It.IsAny<Type>()), Times.Once(),
                    "should load existing model");

                store.Verify(c => c.Save(It.IsAny<Type>(), It.IsAny<DbModel>()), Times.Never(),
                    "should not call Save when loading model from store");
            }
            finally //clean up
            {
                MutableResolver.ClearResolvers();
            }
        }

        public void CreateModel_does_not_use_ModelStore_for_HistoryContext()
        {
            var store = new Mock<DbModelStore>();

            var dbCompiledModelInStore = new DbCompiledModel();
            store.Setup(c => c.TryLoad(It.IsAny<Type>())).Returns(dbCompiledModelInStore);
            store.Setup(c => c.Save(It.IsAny<Type>(), It.IsAny<DbModel>()));

            try
            {
                var dependencyResolver = new SingletonDependencyResolver<DbModelStore>(store.Object);
                MutableResolver.AddResolver<DbModelStore>(dependencyResolver);

                var mockContext = new Mock<LazyInternalContext>(
                    new MockHistoryContext(), new Mock<IInternalConnection>().Object, null, null, null, null, null)
                {
                    CallBase = true
                };
                mockContext.Object.ModelProviderInfo = ProviderRegistry.Sql2008_ProviderInfo;

                var model = LazyInternalContext.CreateModel(mockContext.Object);

                Assert.NotSame(dbCompiledModelInStore, model);

                store.Verify(c => c.TryLoad(It.IsAny<Type>()), Times.Never(),
                    "should not call store for HistoryContext");

                store.Verify(c => c.Save(It.IsAny<Type>(), It.IsAny<DbModel>()), Times.Never(),
                    "should not call store for HistoryContext");
            }
            finally //clean up
            {
                MutableResolver.ClearResolvers();
            }
        }

 /// <summary>
 /// Constructor.
 /// 构造函数
 /// </summary>
 protected OwDbContext(DbCompiledModel model)
     : base(model)
 {
     Logger = NullLogger.Instance;
     OwSession = NullOwSession.Instance;
     EntityChangeEventHelper = NullEntityChangeEventHelper.Instance;
 }

 /// <summary>
 /// Constructor.
 /// </summary>
 protected AbpDbContext(DbCompiledModel model)
     : base(model)
 {
     Logger = NullLogger.Instance;
     AbpSession = NullAbpSession.Instance;
     EntityChangedEventHelper = NullEntityChangedEventHelper.Instance;
 }

        public static IEdmModel AddDbCompiledModelAnnotation(this IEdmModel model, DbCompiledModel dbCompiledModel)
        {
            var annotation = new DbCompiledModelAnnotation(dbCompiledModel);
            model.SetAnnotationValue(model, annotation);

            return model;
        }

        /// <summary>
        ///     Calculates an SHA256 hash of the EDMX from the given code first model. This is the hash stored in
        ///     the database in the EdmMetadata table in EF 4.1/4.2. The hash is always calculated using a v2 schema
        ///     as was generated by EF 4.1/4.2 and with the <see cref = "EdmMetadata" /> entity included in the model.
        /// </summary>
        public virtual string Calculate(DbCompiledModel compiledModel)
        {
            //Contract.Requires(compiledModel != null);
            //Contract.Requires(compiledModel.ProviderInfo != null);
            //Contract.Requires(compiledModel.CachedModelBuilder != null);

            var providerInfo = compiledModel.ProviderInfo;
            var modelBuilder = compiledModel.CachedModelBuilder.Clone();

            // Add back in the EdmMetadata class because the hash created by EF 4.1 and 4.2 will contain it.
            EdmMetadataContext.ConfigureEdmMetadata(modelBuilder.ModelConfiguration);

            var databaseMetadata = modelBuilder.Build(providerInfo).DatabaseMapping.Database;
            databaseMetadata.Version = 2.0; // Ensures SSDL version matches that created by EF 4.1/4.2

            var stringBuilder = new StringBuilder();
            using (var xmlWriter = XmlWriter.Create(
                stringBuilder, new XmlWriterSettings
                    {
                        Indent = true
                    }))
            {
                new SsdlSerializer().Serialize(
                    databaseMetadata,
                    providerInfo.ProviderInvariantName,
                    providerInfo.ProviderManifestToken,
                    xmlWriter);
            }

            return ComputeSha256Hash(stringBuilder.ToString());
        }

 private ChebayDBContext(DbCompiledModel model, string name)
     : base(con, model)
 {
     tenant_name = name;
     Database.SetInitializer<ChebayDBContext>(null);
     this.Configuration.LazyLoadingEnabled = false;
 }

 /// <summary>
 /// Constructor.
 /// </summary>
 protected QdfDbContext(string nameOrConnectionString, DbCompiledModel model)
     : base(nameOrConnectionString, model)
 {
     //Logger = NullLogger.Instance;
     QdfSession = NullQdfSession.Instance;
     EntityChangedEventHelper = NullEntityChangedEventHelper.Instance;
 }

 public F1Context(
     DbConnection existingConnection, DbCompiledModel model, bool contextOwnsConnection, bool lazyLoadingEnabled = true,
     bool proxyCreationEnabled = true)
     : base(existingConnection, model, contextOwnsConnection)
 {
     SetContextOptions(lazyLoadingEnabled, proxyCreationEnabled);
 }

 public DbContextBase(
     string nameOrConnectionString,
     DbCompiledModel model,
     IExceptionMapper exceptionMapper = null)
     : base(nameOrConnectionString, model)
 {
     SetExceptionMapper(exceptionMapper);
 }

        public static DbCompiledModel Model(SqlConnection con)
        {
            if ((_builder == null) || (_model == null))
            {
                _builder = new DbModelBuilder();
                _builder.Configurations.Add(new ProductConfiguration());

                var edm = _builder.Build(con);
                _model = edm.Compile();
            }
            return _model;
        }

 public DbContextBase(
     string nameOrConnectionString,
     DbCompiledModel model,
     IExceptionMapper exceptionMapper = null,
     IEntityAdder entityAdder = null,
     IEntityUpdater entityUpdater = null,
     IEntityDeleter entityDeleter = null,
     IEntityDetacher entityDetacher = null)
     : base(nameOrConnectionString, model)
 {
     Init(exceptionMapper, entityAdder, entityUpdater, entityDeleter, entityDetacher);
 }

        /// <summary>
        ///     Constructs a <see cref = "LazyInternalContext" /> for the given <see cref = "DbContext" /> owner that will be initialized
        ///     on first use.
        /// </summary>
        /// <param name = "owner">The owner <see cref = "DbContext" />.</param>
        /// <param name = "internalConnection">Responsible for creating a connection lazily when the context is used for the first time.</param>
        /// <param name = "model">The model, or null if it will be created by convention</param>
        public LazyInternalContext(
            DbContext owner,
            IInternalConnection internalConnection,
            DbCompiledModel model,
            IDbModelCacheKeyFactory cacheKeyFactory = null)
            : base(owner)
        {
            //Contract.Requires(internalConnection != null);

            _internalConnection = internalConnection;
            _model = model;
            _cacheKeyFactory = cacheKeyFactory ?? new DefaultModelCacheKeyFactory();

            _createdWithExistingModel = model != null;
        }

 /// <summary>
 /// Constructor.
 /// </summary>
 protected AbpDbContext(string nameOrConnectionString, DbCompiledModel model)
     : base(nameOrConnectionString, model)
 {
     InitializeDbContext();
 }

 public SpSynthDbContext(DbConnection existingConnection, DbCompiledModel model, bool contextOwnsConnection)
     : base(existingConnection, model, contextOwnsConnection)
 {
 }

 public AllTypeKeysContext(DbCompiledModel model)
     : base(model)
 {
 }

 /// <summary>
 /// Constructor.
 /// </summary>
 protected AbpDbContext(DbConnection existingConnection, DbCompiledModel model, bool contextOwnsConnection)
     : base(existingConnection, model, contextOwnsConnection)
 {
     AbpSession = NullAbpSession.Instance;
 }

                private static DbCompiledModel GetOrBuildDbCompoledModel(DbConnection connection)
                {
                    if ( _s_compiledModel == null )
                    {
                        lock ( _s_compiledModelSyncRoot )
                        {
                            if ( _s_compiledModel == null )
                            {
                                var modelBuilder = new DbModelBuilder();

                                modelBuilder.Conventions.Add(new NoUnderscoreForeignKeyNamingConvention());

                                var objectSetProducts = modelBuilder.Entity<EntityObject_Product>().HasEntitySetName("Product").ToTable("Products");
                                var objectSetOrders = modelBuilder.Entity<EntityObject_Order>().HasEntitySetName("Order").ToTable("Orders");
                                var objectSetOrderLines = modelBuilder.Entity<EntityObject_OrderLine>().HasEntitySetName("OrderLine").ToTable("OrderLines");

                                var model = modelBuilder.Build(connection);
                                _s_compiledModel = model.Compile();
                            }
                        }
                    }

                    return _s_compiledModel;
                }

                private static DbCompiledModel GetOrBuildDbCompiledModel(DbConnection connection)
                {
                    if ( _s_compiledModel == null )
                    {
                        lock ( _s_compiledModelSyncRoot )
                        {
                            if ( _s_compiledModel == null )
                            {
                                var modelBuilder = new DbModelBuilder();

                                modelBuilder.Conventions.Add(new NoUnderscoreForeignKeyNamingConvention());

                                var objectSetProducts = modelBuilder.Entity<EntityObject_Product>().HasEntitySetName("Product").ToTable("MY_PRODUCTS");
                                var objectSetOrders = modelBuilder.Entity<EntityObject_Order>().HasEntitySetName("Order").ToTable("MY_ORDERS");
                                var objectSetOrderLines = modelBuilder.Entity<EntityObject_OrderLine>().HasEntitySetName("OrderLine").ToTable("MY_ORDER_LINES");

                                objectSetProducts.Property(p => p.Price).HasColumnName("MY_SPECIAL_PRICE_COLUMN").HasColumnType("MONEY");
                                objectSetOrderLines.HasRequired(p => p.Product).WithRequiredDependent().Map(m => m.MapKey("MY_SPECIAL_PRODUCT_ID_COLUMN"));
                                objectSetOrderLines.HasRequired(p => p.Order).WithMany(o => o.OrderLines).Map(m => m.MapKey("OrderId"));
                                objectSetOrders.Property(p => p.Id).HasColumnName("MY_SPECIAL_ORDER_ID_COLUMN");

                                var model = modelBuilder.Build(connection);
                                _s_compiledModel = model.Compile();
                            }
                        }
                    }

                    return _s_compiledModel;
                }

        public void Initialize()
        {
            var connection = Effort.DbConnectionFactory.CreateTransient();

            this.model = CompiledModels.GetModel<RelationEntity, EmptyEntity>();
            this.context = new FeatureDbContext(connection, this.model);
        }