public void CreateDatabase_using_Migrations_does_not_suppress_initializers()
{
var internalContext = CreateMockContextForMigrator().Object;
DbContextInfo.ClearInfoForContext(internalContext.Owner.GetType());
new DatabaseCreator().CreateDatabase(
internalContext,
(config, context) => new Mock <DbMigrator>(config, context, DatabaseExistenceState.Unknown).Object,
null);
Assert.Null(DbContextInfo.TryGetInfoForContext(internalContext.Owner.GetType()));
}
// <summary>
// Initializes the underlying <see cref="ObjectContext" />.
// </summary>
protected override void InitializeContext()
{
CheckContextNotDisposed();
if (_objectContext == null)
{
if (_creatingModel)
{
throw Error.DbContext_ContextUsedInModelCreating();
}
try
{
var contextInfo = DbContextInfo.TryGetInfoForContext(Owner.GetType());
if (contextInfo != null)
{
ApplyContextInfo(contextInfo);
}
_creatingModel = true;
if (_createdWithExistingModel)
{
// A DbCompiledModel was supplied, which means we should just create the ObjectContext from the model.
// The connection cannot be an EF connection because it would then contain a second source of model info.
if (_internalConnection.ConnectionHasModel)
{
throw Error.DbContext_ConnectionHasModel();
}
Debug.Assert(_model != null);
_objectContext = _model.CreateObjectContext <ObjectContext>(_internalConnection.Connection);
}
else
{
// No model was supplied, so we should either create one using Code First, or if an EF connection
// was supplied then we should use the metadata in that connection to create a model.
if (_internalConnection.ConnectionHasModel)
{
_objectContext = _internalConnection.CreateObjectContextFromConnectionModel();
}
else
{
// The idea here is that for a given derived context type and provider we will only ever create one DbCompiledModel.
// The delegate given to GetOrAdd may be executed more than once even though ultimately only one of the
// values will make it in the dictionary. The RetryLazy ensures that that delegate only gets called
// exactly one time, thereby ensuring that OnModelCreating will only ever be called once. BUT, sometimes
// the delegate will fail (and throw and exception). This may be due to some resource issue--most notably
// a problem with the database connection. In such a situation it makes sense to have the model creation
// try again later when the resource issue has potentially been resolved. To enable this RetryLazy will
// try again next time GetValue called. We have to pass the context to GetValue so that the next time it tries
// again it will use the new connection.
var key = _cacheKeyFactory(Owner);
var model
= _cachedModels.GetOrAdd(
key, t => new RetryLazy <LazyInternalContext, DbCompiledModel>(CreateModel)).GetValue(this);
_objectContext = model.CreateObjectContext <ObjectContext>(_internalConnection.Connection);
// Don't actually set the _model unless we succeed in creating the object context.
_model = model;
}
}
_objectContext.ContextOptions.EnsureTransactionsForFunctionsAndCommands = _initialEnsureTransactionsForFunctionsAndCommands;
_objectContext.ContextOptions.LazyLoadingEnabled = _initialLazyLoadingFlag;
_objectContext.ContextOptions.ProxyCreationEnabled = _initialProxyCreationFlag;
_objectContext.ContextOptions.UseCSharpNullComparisonBehavior = !_useDatabaseNullSemanticsFlag;
_objectContext.CommandTimeout = _commandTimeout;
_objectContext.ContextOptions.UseConsistentNullReferenceBehavior = true;
_objectContext.InterceptionContext = _objectContext.InterceptionContext.WithDbContext(Owner);
ResetDbSets();
_objectContext.InitializeMappingViewCacheFactory(Owner);
}
finally
{
_creatingModel = false;
}
}
}