/// <summary>
/// Constructs a new context instance around an existing ObjectContext.
/// </summary>
/// <param name="objectContext"> An existing ObjectContext to wrap with the new context. </param>
/// <param name="dbContextOwnsObjectContext">
/// If set to <c>true</c> the ObjectContext is disposed when the DbContext is disposed, otherwise the caller must dispose the connection.
/// </param>
public DbContext(ObjectContext objectContext, bool dbContextOwnsObjectContext)
{
Check.NotNull <ObjectContext>(objectContext, nameof(objectContext));
DbConfigurationManager.Instance.EnsureLoadedForContext(this.GetType());
this._internalContext = (InternalContext) new EagerInternalContext(this, objectContext, dbContextOwnsObjectContext);
this.DiscoverAndInitializeSets();
}
private void ChangeStateToModifiedIfApplicable(T entity)
{
if (entity.IsTransientRecord())
{
return;
}
var entry = InternalContext.Entry(entity);
if (entry.State == EfState.Detached)
{
// Entity was detached before or was explicitly constructed.
// This unfortunately sets all properties to modified.
entry.State = EfState.Modified;
}
else if (entry.State == EfState.Unchanged)
{
// We simply do nothing here, because it is ensured now that DetectChanges()
// gets implicitly called prior SaveChanges().
//if (this.AutoCommitEnabledInternal && !ctx.Configuration.AutoDetectChangesEnabled)
//{
// _context.DetectChanges();
//}
}
}
/// <summary>
/// Creates a database using the core provider (i.e. ObjectContext.CreateDatabase) or
/// by using Code First Migrations <see cref="DbMigrator" /> to create an empty database
/// and the perform an automatic migration to the current model.
/// </summary>
public virtual void CreateDatabase(
InternalContext internalContext,
Func<DbMigrationsConfiguration, DbContext, MigratorBase> createMigrator,
ObjectContext objectContext)
{
DebugCheck.NotNull(internalContext);
DebugCheck.NotNull(createMigrator);
// objectContext may be null when testing.
if (internalContext.CodeFirstModel != null
&& _resolver.GetService<Func<MigrationSqlGenerator>>(internalContext.ProviderName) != null)
{
if (!_migrationsChecker.IsMigrationsConfigured(internalContext, () => false))
{
var migrator = createMigrator(
GetMigrationsConfiguration(internalContext),
internalContext.Owner);
migrator.Update();
}
}
else
{
internalContext.DatabaseOperations.Create(objectContext);
internalContext.SaveMetadataToDatabase();
}
// If the database is created explicitly, then this is treated as overriding the
// database initialization strategy, so make it as already run.
internalContext.MarkDatabaseInitialized();
}
/// <summary>
/// Finds an entity with the given primary key values.
/// If an entity with the given primary key values exists in the context, then it is
/// returned immediately without making a request to the store. Otherwise, a request
/// is made to the store for an entity with the given primary key values and this entity,
/// if found, is attached to the context and returned. If no entity is found in the
/// context or the store, then null is returned.
/// </summary>
/// <remarks>
/// The ordering of composite key values is as defined in the EDM, which is in turn as defined in
/// the designer, by the Code First fluent API, or by the DataMember attribute.
/// </remarks>
/// <param name="keyValues"> The values of the primary key for the entity to be found. </param>
/// <returns> The entity found, or null. </returns>
/// <exception cref="InvalidOperationException">Thrown if multiple entities exist in the context with the primary key values given.</exception>
/// <exception cref="InvalidOperationException">Thrown if the type of entity is not part of the data model for this context.</exception>
/// <exception cref="InvalidOperationException">Thrown if the types of the key values do not match the types of the key values for the entity type to be found.</exception>
/// <exception cref="InvalidOperationException">Thrown if the context has been disposed.</exception>
public TEntity Find(params object[] keyValues)
{
InternalContext.ObjectContext.AsyncMonitor.EnsureNotEntered();
// This DetectChanges is useful in the case where objects are added to the graph and then the user
// attempts to find one of those added objects.
InternalContext.DetectChanges();
var key = new WrappedEntityKey(EntitySet, EntitySetName, keyValues, "keyValues");
// First, check for the entity in the state manager. This includes first checking
// for non-Added objects that match the key. If the entity was not found, then
// we check for Added objects. We don't just use GetObjectByKey
// because it would go to the store before checking for Added objects, and also
// because if the object found was of the wrong type then it would still get into
// the state manager.
var entity = FindInStateManager(key) ?? FindInStore(key, "keyValues");
if (entity != null &&
!(entity is TEntity))
{
throw Error.DbSet_WrongEntityTypeFound(entity.GetType().Name, typeof(TEntity).Name);
}
return((TEntity)entity);
}
/// <summary>
/// 尝试创建对应的表。
/// </summary>
/// <param name="entityType">实体类型。</param>
/// <param name="context"></param>
/// <returns></returns>
public static bool TryCreate(Type entityType, InternalContext context)
{
var metadata = EntityMetadataUnity.GetEntityMetadata(entityType);
var lazy = new Lazy <bool>(() =>
{
var syntax = context.Database.Provider.GetService <ISyntaxProvider>();
//判断表是否存在
SqlCommand sql = syntax.ExistsTable(metadata.TableName);
if (context.Database.ExecuteScalar <int>(sql) == 0)
{
if (InternalCreate(metadata, syntax, context))
{
//通知 context 仓储已经创建
if (context.OnRespositoryCreated != null)
{
context.OnRespositoryCreated(entityType);
}
return(true);
}
return(false);
}
return(true);
});
return(cache.TryGetValue(entityType, () => lazy.Value));
}
public void Update(T entity)
{
if (entity == null)
{
throw new ArgumentNullException("entity");
}
if (this.AutoCommitEnabled)
{
if (!InternalContext.Configuration.AutoDetectChangesEnabled)
{
InternalContext.Entry(entity).State = System.Data.Entity.EntityState.Modified;
}
_context.SaveChanges();
}
else
{
try
{
this.Entities.Attach(entity);
InternalContext.Entry(entity).State = System.Data.Entity.EntityState.Modified;
}
finally { }
}
}
public override PropertyValue GetValue(IEntity entity, IProperty property)
{
var entityProperty = property.As <EntityProperty>();
var instanceName = GetInstanceName(entity, entityProperty.RelationType);
var environment = GetEnvironment(entity);
using (var context = new InternalContext(instanceName))
{
context.As <IEntityPersistentEnvironment>(s => s.Environment = environment);
context.As <IEntityPersistentInstanceContainer>(s => s.InstanceName = instanceName);
var provider = context.CreateRepositoryProvider(entityProperty.RelationType);
var expression = BuidRelationExpression(entity, entityProperty);
if (expression != null)
{
var value = Execute(provider.Queryable, expression);
//设置实体所属的实体Owner
value.As <IEntityRelation>(e => e.Owner = new EntityOwner(entity, property));
return(value == null ? PropertyValue.Empty : PropertyValue.NewValue(value));
}
return(PropertyValue.Empty);
}
}
public void Delete(T entity)
{
if (entity == null)
{
throw new ArgumentNullException("entity");
}
if (InternalContext.Entry(entity).State == System.Data.Entity.EntityState.Detached)
{
T attachedEntity = Local.SingleOrDefault(e => e.Id == entity.Id); // You need to have access to key
if (attachedEntity != null)
{
var attachedEntry = InternalContext.Entry(attachedEntity);
attachedEntry.CurrentValues.SetValues(entity);
}
else
{
this.Entities.Attach(entity);
}
}
this.Entities.Remove(entity);
if (this.AutoCommitEnabledInternal)
{
_context.SaveChanges();
}
else
{
_context.SaveChanges();
}
}
public virtual bool IsMigrationsConfigured(InternalContext internalContext, Func<bool> databaseExists)
{
DebugCheck.NotNull(internalContext);
try
{
if (!_finder(internalContext))
{
return false;
}
}
catch (Exception ex)
{
Debug.Fail("Exception ignored while attempting to create migration configuration: " + ex);
return false;
}
if (databaseExists())
{
return true;
}
throw new InvalidOperationException(
Strings.DatabaseInitializationStrategy_MigrationsEnabled(internalContext.Owner.GetType().Name));
}
/// <summary>
/// 尝试创建对应的表。
/// </summary>
/// <param name="entityType">实体类型。</param>
/// <param name="context"></param>
/// <returns></returns>
public static bool TryCreate(Type entityType, InternalContext context, Action <Type> succeed, Action <Type, Exception> failed)
{
var metadata = EntityMetadataUnity.GetEntityMetadata(entityType);
var lazy = new Lazy <bool>(() =>
{
var service = context.Database.Provider.GetTableGenerateProvider();
if (service == null || service.IsExists(context.Database, entityType))
{
return(true);
}
try
{
service.TryCreate(context.Database, entityType);
//通知 context 仓储已经创建
succeed?.Invoke(entityType);
return(true);
}
catch (Exception exp)
{
failed?.Invoke(entityType, exp);
return(false);
}
});
var cacheKey = string.Format("{0}:{1}", context.InstanceName, entityType.FullName);
return(cache.GetOrAdd(cacheKey, key => lazy.Value));
}
private void IterateOverGraph(Action <DatasetViewGraph, DatasetFacade, DatasetFacade> action)
{
var root = m_Project.Root();
action(m_Graph, null, root);
var nodes = new Queue <DatasetFacade>();
nodes.Enqueue(root);
while (nodes.Count > 0)
{
var dataset = nodes.Dequeue();
foreach (var child in dataset.Children())
{
var temp = child;
if (InternalContext.IsSynchronized)
{
action(m_Graph, dataset, temp);
}
else
{
Action a = () => action(m_Graph, dataset, temp);
InternalContext.Invoke(a);
}
nodes.Enqueue(child);
}
}
}
/// <summary>
/// 更新数据
/// </summary>
/// <param name="entity"></param>
/// <param name="autoLog"></param>
/// <param name="logAction"></param>
/// <returns></returns>
public IEntityLogInfo <T> Update(T entity, bool autoLog = true, string logAction = null)
{
Guard.ArgumentNotNull(() => entity);
if (entity is BaseDataEntity)
{
(entity as BaseDataEntity).LastUpdatedOn = DateTime.Now;
}
var logInfo = CreateEntityLogInfo(EntityLogActionType.Update, entity, false, logAction);
if (this.AutoCommitEnabled)
{
DbContext.SaveChanges();
}
else
{
try
{
this.Entities.Attach(entity);
InternalContext.Entry(entity).State = System.Data.Entity.EntityState.Modified;
}
finally { }
}
if (autoLog && _autoUpdateEntityLog)
{
logInfo.Update(this.AutoCommitEnabled);
}
return(logInfo);
}
public override PropertyValue GetValue(IEntity entity, IProperty property)
{
var entityProperty = property.As <EntitySetProperty>();
var instanceName = GetInstanceName(entity, entityProperty.RelationType);
var environment = GetEnvironment(entity);
using (var context = new InternalContext(instanceName))
{
context.Environment = environment;
context.InstanceName = instanceName;
var provider = context.CreateRepositoryProvider(entityProperty.RelationType);
var expression = BuidRelationExpression(entity, entityProperty);
object result = null;
if (expression != null)
{
result = Execute(provider.Queryable, expression);
var querySetType = typeof(EntitySet <>).MakeGenericType(entityProperty.RelationType);
var list = querySetType.New(new[] { result });
//设置实体集所属的实体Owner
list.As <IEntityRelation>(e => e.Owner = new EntityOwner(entity, property));
return(PropertyValueHelper.NewValue(list));
}
return(PropertyValueHelper.NewValue(result));
}
}
/// <summary>
/// 初始化。
/// </summary>
protected virtual void Initialize()
{
context = new InternalContext(configName);
context.OnRespositoryCreated = new Action <Type>(t =>
{
});
}
public DatabaseExistenceState AnyModelTableExists(InternalContext internalContext)
{
var exists = internalContext.DatabaseOperations.Exists(
internalContext.Connection,
internalContext.CommandTimeout,
new Lazy<StoreItemCollection>(() => CreateStoreItemCollection(internalContext)));
if (!exists)
{
return DatabaseExistenceState.DoesNotExist;
}
using (var clonedObjectContext = internalContext.CreateObjectContextForDdlOps())
{
try
{
if (internalContext.CodeFirstModel == null)
{
// If not Code First, then assume tables created in some other way
return DatabaseExistenceState.Exists;
}
var checker = DbConfiguration.DependencyResolver.GetService<TableExistenceChecker>(internalContext.ProviderName);
if (checker == null)
{
// If we can't check for tables, then assume they exist as we did in older versions
return DatabaseExistenceState.Exists;
}
var modelTables = GetModelTables(internalContext).ToList();
if (!modelTables.Any())
{
// If this is an empty model, then all tables that can exist (0) do exist
return DatabaseExistenceState.Exists;
}
if (QueryForTableExistence(checker, clonedObjectContext, modelTables))
{
// If any table exists, then assume that this is a non-empty database
return DatabaseExistenceState.Exists;
}
// At this point we know no model tables exist. If the history table exists and has an entry
// for this context, then treat this as a non-empty database, otherwise treat is as existing
// but empty.
return internalContext.HasHistoryTableEntry()
? DatabaseExistenceState.Exists
: DatabaseExistenceState.ExistsConsideredEmpty;
}
catch (Exception ex)
{
Debug.Fail(ex.Message, ex.ToString());
// Revert to previous behavior on error
return DatabaseExistenceState.Exists;
}
}
}
/// <summary>
/// Uses Code First with the given context and writes the resulting Entity Data Model to the given
/// writer in EDMX form. This method can only be used with context instances that use Code First
/// and create the model internally. The method cannot be used for contexts created using Database
/// First or Model First, for contexts created using a pre-existing <see cref="T:System.Data.Entity.Core.Objects.ObjectContext" />, or
/// for contexts created using a pre-existing <see cref="T:System.Data.Entity.Infrastructure.DbCompiledModel" />.
/// </summary>
/// <param name="context"> The context. </param>
/// <param name="writer"> The writer. </param>
public static void WriteEdmx(DbContext context, XmlWriter writer)
{
Check.NotNull <DbContext>(context, nameof(context));
Check.NotNull <XmlWriter>(writer, nameof(writer));
InternalContext internalContext = context.InternalContext;
if (internalContext is EagerInternalContext)
{
throw Error.EdmxWriter_EdmxFromObjectContextNotSupported();
}
DbModel beingInitialized = internalContext.ModelBeingInitialized;
if (beingInitialized != null)
{
EdmxWriter.WriteEdmx(beingInitialized, writer);
}
else
{
DbCompiledModel codeFirstModel = internalContext.CodeFirstModel;
if (codeFirstModel == null)
{
throw Error.EdmxWriter_EdmxFromModelFirstNotSupported();
}
DbModelBuilder dbModelBuilder = codeFirstModel.CachedModelBuilder.Clone();
EdmxWriter.WriteEdmx(internalContext.ModelProviderInfo == null ? dbModelBuilder.Build(internalContext.Connection) : dbModelBuilder.Build(internalContext.ModelProviderInfo), writer);
}
}
/// <summary>
/// Creates a new internal query based on the information in an existing query together with
/// a new underlying ObjectQuery.
/// </summary>
public InternalQuery(InternalContext internalContext, ObjectQuery objectQuery)
{
DebugCheck.NotNull(internalContext);
_internalContext = internalContext;
_objectQuery = (ObjectQuery <TElement>)objectQuery;
}
/// <summary>
/// 尝试创建对应的表。
/// </summary>
/// <param name="entityType">实体类型。</param>
/// <param name="context"></param>
/// <returns></returns>
public static bool TryCreate(Type entityType, InternalContext context)
{
var metadata = EntityMetadataUnity.GetEntityMetadata(entityType);
var lazy = new Lazy <bool>(() =>
{
var syntax = context.Database.Provider.GetService <ISyntaxProvider>();
//判断表是否存在
SqlCommand sql = syntax.ExistsTable(metadata.TableName);
if (context.Database.ExecuteScalar <int>(sql) == 0)
{
if (InternalCreate(metadata, syntax, context))
{
//通知 context 仓储已经创建
context.OnRespositoryCreated?.Invoke(entityType);
return(true);
}
return(false);
}
return(true);
});
var cacheKey = string.Format("{0}:{1}", context.InstanceName, entityType.FullName);
return(cache.GetOrAdd(cacheKey, key => lazy.Value));
}
private static StoreItemCollection CreateStoreItemCollection(InternalContext internalContext)
{
using (var clonedObjectContext = internalContext.CreateObjectContextForDdlOps())
{
var entityConnection = ((EntityConnection)clonedObjectContext.ObjectContext.Connection);
return (StoreItemCollection)entityConnection.GetMetadataWorkspace().GetItemCollection(DataSpace.SSpace);
}
}
// <summary>
// Creates a provider that wraps the given provider.
// </summary>
// <param name="internalQuery"> The internal query to wrap. </param>
public DbQueryProvider(InternalContext internalContext, IInternalQuery internalQuery)
{
DebugCheck.NotNull(internalContext);
DebugCheck.NotNull(internalQuery);
_internalContext = internalContext;
_internalQuery = internalQuery;
}
/// <summary>
/// Initializes a new instance of the <see cref="DbDataRecordPropertyValues" /> class.
/// </summary>
/// <param name="internalContext"> The internal context. </param>
/// <param name="type"> The type. </param>
/// <param name="dataRecord"> The data record. </param>
/// <param name="isEntityValues">
/// If set to <c>true</c> this is a dictionary for an entity, otherwise it is a dictionary for a complex object.
/// </param>
internal DbDataRecordPropertyValues(
InternalContext internalContext, Type type, DbUpdatableDataRecord dataRecord, bool isEntity)
: base(internalContext, type, isEntity)
{
DebugCheck.NotNull(dataRecord);
_dataRecord = dataRecord;
}
internal virtual void InitializeLazyInternalContext(
IInternalConnection internalConnection,
DbCompiledModel model = null)
{
DbConfigurationManager.Instance.EnsureLoadedForContext(this.GetType());
this._internalContext = (InternalContext) new LazyInternalContext(this, internalConnection, model, DbConfiguration.DependencyResolver.GetService <Func <DbContext, IDbModelCacheKey> >(), DbConfiguration.DependencyResolver.GetService <AttributeProvider>(), (Lazy <DbDispatchers>)null, (ObjectContext)null);
this.DiscoverAndInitializeSets();
}
protected virtual void Dispose(bool disposing)
{
if (!_disposed && disposing)
{
Debug.WriteLine(string.Format("ContextCacheDispose({0})", _configHash));
_currentContext = null;
}
}
public EntityPersister(InternalContext context)
{
this.context = context;
Database = context.Database;
entityQueryProvider = new EntityQueryProvider(context);
queryable = new QueryProvider(entityQueryProvider);
environment = context.Environment;
}
/// <summary>
/// Initializes the internal context, discovers and initializes sets, and initializes from a model if one is provided.
/// </summary>
private void InitializeLazyInternalContext(IInternalConnection internalConnection, DbCompiledModel model = null)
{
DbConfigurationManager.Instance.EnsureLoadedForContext(GetType());
_internalContext = new LazyInternalContext(
this, internalConnection, model, DbConfiguration.GetService <IDbModelCacheKeyFactory>());
DiscoverAndInitializeSets();
}
/// <summary>
/// Returns an <see cref="IDbAsyncEnumerator{TElement}" /> which when enumerated will execute the query against the database.
/// </summary>
/// <returns> The query results. </returns>
public virtual IDbAsyncEnumerator <TElement> GetAsyncEnumerator()
{
Debug.Assert(_objectQuery != null, "InternalQuery should have been initialized.");
InternalContext.Initialize();
return(((IDbAsyncEnumerable <TElement>)_objectQuery).GetAsyncEnumerator());
}
/// <summary>
/// 使用 <see cref="IDatabase"/> 对象初始化 <see cref="T:Lord.Data.Entity.EntityPersister`1"/> 类的新实例。
/// </summary>
/// <param name="database">一个 <see cref="IDatabase"/> 对象。</param>
public EntityPersister(IDatabase database)
{
Database = database;
context = new InternalContext(database);
entityQueryProvider = new EntityQueryProvider(context);
queryable = new QueryProvider(entityQueryProvider);
environment = context.Environment;
}
/// <summary>
/// Initializes a new instance of the <see cref = "DbDataRecordPropertyValues" /> class.
/// </summary>
/// <param name = "internalContext">The internal context.</param>
/// <param name = "type">The type.</param>
/// <param name = "dataRecord">The data record.</param>
/// <param name = "isEntityValues">If set to <c>true</c> this is a dictionary for an entity, otherwise it is a dictionary for a complex object.</param>
internal DbDataRecordPropertyValues(
InternalContext internalContext, Type type, DbUpdatableDataRecord dataRecord, bool isEntity)
: base(internalContext, type, isEntity)
{
Contract.Requires(dataRecord != null);
_dataRecord = dataRecord;
}
/// <summary>
/// Creates a provider that wraps the given provider.
/// </summary>
/// <param name="provider"> The provider to wrap. </param>
public DbQueryProvider(InternalContext internalContext, ObjectQueryProvider provider)
{
DebugCheck.NotNull(internalContext);
DebugCheck.NotNull(provider);
_internalContext = internalContext;
_provider = provider;
}
/// <summary>
/// 初始化。
/// </summary>
private void Initialize(EntityContextOptions options)
{
context = new InternalContext(options)
{
OnRespositoryCreated = OnRespositoryCreated,
OnRespositoryCreateFailed = OnRespositoryCreateFailed
};
}
// <summary>
// Initializes a new instance of the <see cref="InternalPropertyValues" /> class.
// </summary>
// <param name="internalContext"> The internal context with which the entity of complex object is associated. </param>
// <param name="type"> The type of the entity or complex object. </param>
// <param name="isEntityValues">
// If set to <c>true</c> this is a dictionary for an entity, otherwise it is a dictionary for a complex object.
// </param>
protected InternalPropertyValues(InternalContext internalContext, Type type, bool isEntityValues)
{
DebugCheck.NotNull(internalContext);
DebugCheck.NotNull(type);
_internalContext = internalContext;
_type = type;
_isEntityValues = isEntityValues;
}
/// <summary>
/// 初始化 <see cref="DefaultRepositoryProvider"/> 类的新实例。
/// </summary>
/// <param name="context"></param>
public DefaultRepositoryProvider(InternalContext context)
{
this.context = context;
var entityQueryProvider = new EntityQueryProvider(context);
context.As <IEntityPersistentInstanceContainer>(s => entityQueryProvider.InitializeInstanceName(s.InstanceName));
QueryProvider = new QueryProvider(entityQueryProvider);
Queryable = new QuerySet <TEntity>(QueryProvider, null);
}
private void SetEntityStateToModifiedIfApplicable(T entity)
{
var entry = InternalContext.Entry(entity);
if (entry.State == System.Data.Entity.EntityState.Detached || (this.AutoCommitEnabledInternal && !InternalContext.Configuration.AutoDetectChangesEnabled))
{
entry.State = System.Data.Entity.EntityState.Modified;
}
}
public virtual void AddRange(IEnumerable entities)
{
DebugCheck.NotNull(entities);
InternalContext.DetectChanges();
ActOnSet(
entity => InternalContext.ObjectContext.AddObject(EntitySetName, entity), EntityState.Added, entities, "AddRange");
}
/// <summary>
/// 初始化 <see cref="EntityTreeRepository<TEntity>"/> 类的新实例。
/// </summary>
/// <param name="repository"></param>
/// <param name="context"></param>
public EntityTreeRepository(EntityRepository <TEntity> repository, InternalContext context)
{
this.repository = repository;
entityType = typeof(TEntity);
metadata = EntityMetadataUnity.GetEntityMetadata(entityType);
metaTree = metadata.EntityTree;
database = context.Database;
syntax = database.Provider.GetService <ISyntaxProvider>();
}
private static void SetInternalNodeName()
{
PropertyInfo internalProperty = typeof(TelemetryContext).GetProperty("Internal",
BindingFlags.NonPublic | BindingFlags.Instance);
InternalContext internalContext = (InternalContext)internalProperty.GetValue(Tc.Context);
internalContext.NodeName = Tc.Context.User.Id;
}
private InternalSqlNonSetQuery(InternalContext internalContext, Type elementType, string sql, bool? streaming, object[] parameters)
: base(sql, streaming, parameters)
{
DebugCheck.NotNull(internalContext);
DebugCheck.NotNull(elementType);
_internalContext = internalContext;
_elementType = elementType;
}
/// <summary>
/// Constructs a new context instance around an existing ObjectContext.
/// </summary>
/// <param name="objectContext"> An existing ObjectContext to wrap with the new context. </param>
/// <param name="dbContextOwnsObjectContext">
/// If set to <c>true</c> the ObjectContext is disposed when the DbContext is disposed, otherwise the caller must dispose the connection.
/// </param>
public DbContext(ObjectContext objectContext, bool dbContextOwnsObjectContext)
{
Check.NotNull(objectContext, "objectContext");
DbConfigurationManager.Instance.EnsureLoadedForContext(GetType());
_internalContext = new EagerInternalContext(this, objectContext, dbContextOwnsObjectContext);
DiscoverAndInitializeSets();
}
/// <summary>
/// Initializes a new instance of the <see cref = "InternalPropertyValues" /> class.
/// </summary>
/// <param name = "internalContext">The internal context with which the entity of complex object is associated.</param>
/// <param name = "type">The type of the entity or complex object.</param>
/// <param name = "isEntityValues">If set to <c>true</c> this is a dictionary for an entity, otherwise it is a dictionary for a complex object.</param>
protected InternalPropertyValues(InternalContext internalContext, Type type, bool isEntityValues)
{
Contract.Requires(internalContext != null);
Contract.Requires(type != null);
_internalContext = internalContext;
_type = type;
_isEntityValues = isEntityValues;
}
/// <summary>
/// Initializes a new instance of the <see cref="InternalSqlNonSetQuery" /> class.
/// </summary>
/// <param name="internalContext"> The internal context. </param>
/// <param name="elementType"> Type of the element. </param>
/// <param name="sql"> The SQL. </param>
/// <param name="parameters"> The parameters. </param>
internal InternalSqlNonSetQuery(
InternalContext internalContext, Type elementType, string sql, object[] parameters)
: base(sql, parameters)
{
Contract.Requires(internalContext != null);
Contract.Requires(elementType != null);
_internalContext = internalContext;
_elementType = elementType;
}
/// <summary>
/// Initializes a new instance of the <see cref = "InternalEntityEntry" /> class.
/// </summary>
/// <param name = "internalContext">The internal context.</param>
/// <param name = "stateEntry">The state entry.</param>
public InternalEntityEntry(InternalContext internalContext, IEntityStateEntry stateEntry)
{
//Contract.Requires(internalContext != null);
//Contract.Requires(stateEntry != null);
Contract.Assert(stateEntry.Entity != null);
_internalContext = internalContext;
_stateEntry = stateEntry;
_entity = stateEntry.Entity;
_entityType = ObjectContextTypeCache.GetObjectType(_entity.GetType());
}
/// <summary>
/// Initializes a new instance of the <see cref="InternalEntityEntry" /> class.
/// </summary>
/// <param name="internalContext"> The internal context. </param>
/// <param name="stateEntry"> The state entry. </param>
public InternalEntityEntry(InternalContext internalContext, IEntityStateEntry stateEntry)
{
DebugCheck.NotNull(internalContext);
DebugCheck.NotNull(stateEntry);
Debug.Assert(stateEntry.Entity != null);
_internalContext = internalContext;
_stateEntry = stateEntry;
_entity = stateEntry.Entity;
_entityType = ObjectContextTypeCache.GetObjectType(_entity.GetType());
}
/// <summary>
/// Initializes a new instance of the <see cref = "DbUpdateException" /> class.
/// </summary>
/// <param name = "internalContext">The internal context.</param>
/// <param name = "innerException">The inner exception.</param>
internal DbUpdateException(
InternalContext internalContext, UpdateException innerException, bool involvesIndependentAssociations)
: base(
involvesIndependentAssociations
? Strings.DbContext_IndependentAssociationUpdateException
: innerException.Message,
innerException)
{
_internalContext = internalContext;
_state.InvolvesIndependentAssociations = involvesIndependentAssociations;
SubscribeToSerializeObjectState();
}
protected RepositoryBase(InternalContext usersContext, string connectionString, DbProviderFactory providerFactory)
{
DebugCheck.NotNull(usersContext);
DebugCheck.NotEmpty(connectionString);
DebugCheck.NotNull(providerFactory);
var existingConnection = usersContext.Connection;
if (existingConnection != null)
{
_existingConnection = existingConnection;
}
_connectionString = connectionString;
_providerFactory = providerFactory;
}
/// <summary>
/// Initializes a new instance of the <see cref = "InternalEntityEntry" /> class for an
/// entity which may or may not be attached to the context.
/// </summary>
/// <param name = "internalContext">The internal context.</param>
/// <param name = "entity">The entity.</param>
public InternalEntityEntry(InternalContext internalContext, object entity)
{
//Contract.Requires(internalContext != null);
//Contract.Requires(entity != null);
_internalContext = internalContext;
_entity = entity;
_entityType = ObjectContextTypeCache.GetObjectType(_entity.GetType());
_stateEntry = _internalContext.GetStateEntry(entity);
if (_stateEntry == null)
{
// This will cause the context and model to be initialized and will throw an exception
// if the entity type is not part of the model.
_internalContext.Set(_entityType).InternalSet.Initialize();
}
}
public static DbMigrationsConfiguration GetMigrationsConfiguration(InternalContext internalContext)
{
DebugCheck.NotNull(internalContext);
var contextType = internalContext.Owner.GetType();
return new DbMigrationsConfiguration
{
ContextType = contextType,
AutomaticMigrationsEnabled = true,
MigrationsAssembly = contextType.Assembly,
MigrationsNamespace = contextType.Namespace,
ContextKey = internalContext.ContextKey,
TargetDatabase = new DbConnectionInfo(internalContext.OriginalConnectionString, internalContext.ProviderName),
CommandTimeout = internalContext.CommandTimeout
};
}
/// <summary>
/// Creates a database using the core provider (i.e. ObjectContext.CreateDatabase) or
/// by using Code First Migrations <see cref = "DbMigrator" /> to create an empty database
/// and the perform an automatic migration to the current model.
/// Migrations is used if Code First is being used and the EF provider is for SQL Server
/// or SQL Compact. The core is used for non-Code First models and for other providers even
/// when using Code First.
/// </summary>
public virtual void CreateDatabase(
InternalContext internalContext,
Func<DbMigrationsConfiguration, DbContext, MigratorBase> createMigrator,
ObjectContext objectContext)
{
//Contract.Requires(internalContext != null);
//Contract.Requires(createMigrator != null);
// objectContext may be null when testing.
var sqlGenerator = _resolver.Value.GetService<MigrationSqlGenerator>(internalContext.ProviderName);
if (internalContext.CodeFirstModel != null
&& sqlGenerator != null)
{
var contextType = internalContext.Owner.GetType();
var migrator = createMigrator(
new DbMigrationsConfiguration
{
ContextType = contextType,
AutomaticMigrationsEnabled = true,
MigrationsAssembly = contextType.Assembly,
MigrationsNamespace = contextType.Namespace,
TargetDatabase =
new DbConnectionInfo(
internalContext.OriginalConnectionString, internalContext.ProviderName)
},
internalContext.Owner);
migrator.Update();
}
else
{
internalContext.DatabaseOperations.Create(objectContext);
internalContext.SaveMetadataToDatabase();
}
// If the database is created explicitly, then this is treated as overriding the
// database initialization strategy, so make it as already run.
internalContext.MarkDatabaseInitialized();
}
public virtual bool CompatibleWithModel(
InternalContext internalContext, ModelHashCalculator modelHashCalculator,
bool throwIfNoMetadata, DatabaseExistenceState existenceState = DatabaseExistenceState.Unknown)
{
DebugCheck.NotNull(internalContext);
DebugCheck.NotNull(modelHashCalculator);
if (internalContext.CodeFirstModel == null)
{
if (throwIfNoMetadata)
{
throw Error.Database_NonCodeFirstCompatibilityCheck();
}
return true;
}
var model = internalContext.QueryForModel(existenceState);
if (model != null)
{
return internalContext.ModelMatches(model);
}
// Migrations history was not found in the database so fall back to doing a model hash compare
// to deal with databases created using EF 4.1 and 4.2.
var databaseModelHash = internalContext.QueryForModelHash();
if (databaseModelHash == null)
{
if (throwIfNoMetadata)
{
throw Error.Database_NoDatabaseMetadata();
}
return true;
}
return String.Equals(
databaseModelHash, modelHashCalculator.Calculate(internalContext.CodeFirstModel),
StringComparison.Ordinal);
}
public EdmMetadataRepository(InternalContext usersContext, string connectionString, DbProviderFactory providerFactory)
: base(usersContext, connectionString, providerFactory)
{
_existingTransaction = usersContext.TryGetCurrentStoreTransaction();
}
// <summary>
// Initializes a new instance of the <see cref="InternalSqlNonSetQuery" /> class.
// </summary>
// <param name="internalContext"> The internal context. </param>
// <param name="elementType"> Type of the element. </param>
// <param name="sql"> The SQL. </param>
// <param name="parameters"> The parameters. </param>
internal InternalSqlNonSetQuery(InternalContext internalContext, Type elementType, string sql, object[] parameters) : this(internalContext, elementType, sql, /*streaming:*/ null, parameters) {}
/// <summary>
/// Initializes a new instance of the <see cref="DbContextConfiguration" /> class.
/// </summary>
/// <param name="internalContext"> The internal context. </param>
internal DbContextConfiguration(InternalContext internalContext)
{
DebugCheck.NotNull(internalContext);
_internalContext = internalContext;
}
/// <summary>
/// Initializes a new instance of the <see cref="DbContextConfiguration" /> class.
/// </summary>
/// <param name="internalContext"> The internal context. </param>
internal DbContextConfiguration(InternalContext internalContext)
{
Contract.Requires(internalContext != null);
_internalContext = internalContext;
}
public virtual IEnumerable<EntitySet> GetModelTables(InternalContext internalContext)
{
return internalContext.ObjectContext.MetadataWorkspace
.GetItemCollection(DataSpace.SSpace)
.GetItems<EntityContainer>()
.Single()
.BaseEntitySets
.OfType<EntitySet>()
.Where(
s => !s.MetadataProperties.Contains("Type")
|| (string)s.MetadataProperties["Type"].Value == "Tables");
}
public HistoryRepository(
InternalContext usersContext,
string connectionString,
DbProviderFactory providerFactory,
string contextKey,
int? commandTimeout,
Func<DbConnection, string, HistoryContext> historyContextFactory,
IEnumerable<string> schemas = null,
DbContext contextForInterception = null,
DatabaseExistenceState initialExistence = DatabaseExistenceState.Unknown)
: base(usersContext, connectionString, providerFactory)
{
DebugCheck.NotEmpty(contextKey);
DebugCheck.NotNull(historyContextFactory);
_initialExistence = initialExistence;
_commandTimeout = commandTimeout;
_existingTransaction = usersContext.TryGetCurrentStoreTransaction();
_schemas
= new[] { EdmModelExtensions.DefaultSchema }
.Concat(schemas ?? Enumerable.Empty<string>())
.Distinct();
_contextForInterception = contextForInterception;
_historyContextFactory = historyContextFactory;
DbConnection connection = null;
try
{
connection = CreateConnection();
using (var context = CreateContext(connection))
{
var historyRowEntity
= ((IObjectContextAdapter)context).ObjectContext
.MetadataWorkspace
.GetItems<EntityType>(DataSpace.CSpace)
.Single(et => et.GetClrType() == typeof(HistoryRow));
var maxLength
= historyRowEntity
.Properties
.Single(p => p.GetClrPropertyInfo().IsSameAs(MigrationIdProperty))
.MaxLength;
_migrationIdMaxLength
= maxLength.HasValue
? maxLength.Value
: HistoryContext.MigrationIdMaxLength;
maxLength
= historyRowEntity
.Properties
.Single(p => p.GetClrPropertyInfo().IsSameAs(ContextKeyProperty))
.MaxLength;
_contextKeyMaxLength
= maxLength.HasValue
? maxLength.Value
: HistoryContext.ContextKeyMaxLength;
}
}
finally
{
DisposeConnection(connection);
}
_contextKey = contextKey.RestrictTo(_contextKeyMaxLength);
}
internal FakeContext(DbConnection connection, InternalContext internalContext)
: base(connection, contextOwnsConnection: false)
{
_internalContext = internalContext;
}
/// <summary>
/// Initializes a new instance of the <see cref="DbUpdateConcurrencyException" /> class.
/// </summary>
/// <param name="context"> The context. </param>
/// <param name="innerException"> The inner exception. </param>
internal DbUpdateConcurrencyException(InternalContext context, OptimisticConcurrencyException innerException)
: base(context, innerException, involvesIndependentAssociations: false)
{
}
/// <summary>
/// Validates that the given name is a property of the declaring type (either on the CLR type or in the EDM)
/// and that it is a complex or scalar property rather than a nav property and then returns metadata about
/// the property.
/// </summary>
/// <param name = "internalContext">The internal context.</param>
/// <param name = "declaringType">The type that the property is declared on.</param>
/// <param name = "requestedType">The type of property requested, which may be 'object' if any type can be accepted.</param>
/// <param name = "propertyName">Name of the property.</param>
/// <returns>Metadata about the property, or null if the property does not exist or is a navigation property.</returns>
public static PropertyEntryMetadata ValidateNameAndGetMetadata(
InternalContext internalContext, Type declaringType, Type requestedType, string propertyName)
{
//Contract.Requires(internalContext != null);
//Contract.Requires(declaringType != null);
//Contract.Requires(requestedType != null);
//Contract.Requires(!string.IsNullOrWhiteSpace(propertyName));
Type propertyType;
DbHelpers.GetPropertyTypes(declaringType).TryGetValue(propertyName, out propertyType);
var metadataWorkspace = internalContext.ObjectContext.MetadataWorkspace;
var edmType = metadataWorkspace.GetItem<StructuralType>(declaringType.FullName, DataSpace.OSpace);
var isMapped = false;
var isComplex = false;
EdmMember member;
edmType.Members.TryGetValue(propertyName, false, out member);
if (member != null)
{
// If the property is in the model, then it must be a scalar or complex property, not a nav prop
var edmProperty = member as EdmProperty;
if (edmProperty == null)
{
return null;
}
if (propertyType == null)
{
var asPrimitive = edmProperty.TypeUsage.EdmType as PrimitiveType;
if (asPrimitive != null)
{
propertyType = asPrimitive.ClrEquivalentType;
}
else
{
Contract.Assert(
edmProperty.TypeUsage.EdmType is StructuralType,
"Expected a structural type if property type is not primitive.");
var objectItemCollection =
(ObjectItemCollection)metadataWorkspace.GetItemCollection(DataSpace.OSpace);
propertyType = objectItemCollection.GetClrType((StructuralType)edmProperty.TypeUsage.EdmType);
}
}
isMapped = true;
isComplex = edmProperty.TypeUsage.EdmType.BuiltInTypeKind == BuiltInTypeKind.ComplexType;
}
else
{
// If the prop is not in the model, then it must have a getter or a setter
var propertyGetters = DbHelpers.GetPropertyGetters(declaringType);
var propertySetters = DbHelpers.GetPropertySetters(declaringType);
if (!(propertyGetters.ContainsKey(propertyName) || propertySetters.ContainsKey(propertyName)))
{
return null;
}
Contract.Assert(
propertyType != null, "If the property has a getter or setter, then it must exist and have a type.");
}
if (!requestedType.IsAssignableFrom(propertyType))
{
throw Error.DbEntityEntry_WrongGenericForProp(
propertyName, declaringType.Name, requestedType.Name, propertyType.Name);
}
return new PropertyEntryMetadata(declaringType, propertyType, propertyName, isMapped, isComplex);
}
