private object InstantiateEntity(
EntityType entityType,
DbContext context,
Type clrType,
DbSet set)
{
object structuralObject;
if (!clrType.IsAbstract())
{
structuralObject = set.Create();
}
else
{
EntityType entityType1 = this._metadataWorkspace.GetItems <EntityType>(DataSpace.CSpace).First <EntityType>((Func <EntityType, bool>)(et =>
{
if (entityType.IsAncestorOf(et))
{
return(!et.Abstract);
}
return(false);
}));
structuralObject = context.Set(EntityTypeExtensions.GetClrType(entityType1)).Create();
}
ModificationCommandTreeGenerator.InstantiateComplexProperties(structuralObject, (IEnumerable <EdmProperty>)entityType.Properties);
return(structuralObject);
}
private void GenerateIndependentAssociationType(
AssociationType associationType,
DbDatabaseMapping databaseMapping)
{
AssociationEndMember principalEnd;
AssociationEndMember dependentEnd;
if (!associationType.TryGuessPrincipalAndDependentEnds(out principalEnd, out dependentEnd))
{
if (!associationType.IsPrincipalConfigured())
{
throw Error.UnableToDeterminePrincipal((object)EntityTypeExtensions.GetClrType(associationType.SourceEnd.GetEntityType()), (object)EntityTypeExtensions.GetClrType(associationType.TargetEnd.GetEntityType()));
}
principalEnd = associationType.SourceEnd;
dependentEnd = associationType.TargetEnd;
}
EntityTypeMapping mappingInHierarchy = StructuralTypeMappingGenerator.GetEntityTypeMappingInHierarchy(databaseMapping, dependentEnd.GetEntityType());
EntityType table = mappingInHierarchy.MappingFragments.First <MappingFragment>().Table;
AssociationSetMapping associationSetMapping = AssociationTypeMappingGenerator.GenerateAssociationSetMapping(associationType, databaseMapping, principalEnd, dependentEnd, table);
this.GenerateIndependentForeignKeyConstraint(databaseMapping, principalEnd.GetEntityType(), dependentEnd.GetEntityType(), table, associationSetMapping, associationSetMapping.SourceEndMapping, associationType.Name, principalEnd, false);
foreach (EdmProperty keyProperty in dependentEnd.GetEntityType().KeyProperties())
{
associationSetMapping.TargetEndMapping.AddPropertyMapping(new ScalarPropertyMapping(keyProperty, mappingInHierarchy.GetPropertyMapping(keyProperty).ColumnProperty));
}
}
private void ConfigureFunctionMappings(
EdmModel model,
EntityTypeConfiguration entityTypeConfiguration,
EntityType entityType)
{
if (entityTypeConfiguration.ModificationStoredProceduresConfiguration == null)
{
return;
}
for (; entityType.BaseType != null; entityType = (EntityType)entityType.BaseType)
{
Type clrType = EntityTypeExtensions.GetClrType((EntityType)entityType.BaseType);
EntityTypeConfiguration typeConfiguration;
if (!entityType.BaseType.Abstract && (!this._entityConfigurations.TryGetValue(clrType, out typeConfiguration) || typeConfiguration.ModificationStoredProceduresConfiguration == null))
{
throw Error.BaseTypeNotMappedToFunctions((object)clrType.Name, (object)entityTypeConfiguration.ClrType.Name);
}
}
model.GetSelfAndAllDerivedTypes(entityType).Each <EntityType>((Action <EntityType>)(e =>
{
EntityTypeConfiguration typeConfiguration = this.Entity(EntityTypeExtensions.GetClrType(e));
if (typeConfiguration.ModificationStoredProceduresConfiguration != null)
{
return;
}
typeConfiguration.MapToStoredProcedures();
}));
}
private object InstantiateAndAttachEntity(EntityType entityType, DbContext context)
{
Type clrType = EntityTypeExtensions.GetClrType(entityType);
DbSet set = context.Set(clrType);
object entity = this.InstantiateEntity(entityType, context, clrType, set);
ModificationCommandTreeGenerator.SetFakeReferenceKeyValues(entity, entityType);
ModificationCommandTreeGenerator.SetFakeKeyValues(entity, entityType);
set.Attach(entity);
return(entity);
}
private void ChangeRelationshipStates(
DbContext context,
EntityType entityType,
object entity,
EntityState state)
{
ObjectStateManager objectStateManager = ((IObjectContextAdapter)context).ObjectContext.ObjectStateManager;
foreach (AssociationType associationType in this._metadataWorkspace.GetItems <AssociationType>(DataSpace.CSpace).Where <AssociationType>((Func <AssociationType, bool>)(at =>
{
if (at.IsForeignKey || at.IsManyToMany())
{
return(false);
}
if (!at.SourceEnd.GetEntityType().IsAssignableFrom((EdmType)entityType))
{
return(at.TargetEnd.GetEntityType().IsAssignableFrom((EdmType)entityType));
}
return(true);
})))
{
AssociationEndMember principalEnd;
AssociationEndMember dependentEnd;
if (!associationType.TryGuessPrincipalAndDependentEnds(out principalEnd, out dependentEnd))
{
principalEnd = associationType.SourceEnd;
dependentEnd = associationType.TargetEnd;
}
if (dependentEnd.GetEntityType().IsAssignableFrom((EdmType)entityType))
{
EntityType entityType1 = principalEnd.GetEntityType();
Type clrType = EntityTypeExtensions.GetClrType(entityType1);
DbSet set = context.Set(clrType);
object obj1 = set.Local.Cast <object>().SingleOrDefault <object>();
if (obj1 == null || object.ReferenceEquals(entity, obj1) && state == EntityState.Added)
{
obj1 = this.InstantiateEntity(entityType1, context, clrType, set);
ModificationCommandTreeGenerator.SetFakeReferenceKeyValues(obj1, entityType1);
set.Attach(obj1);
}
if (principalEnd.IsRequired() && state == EntityState.Modified)
{
object obj2 = this.InstantiateEntity(entityType1, context, clrType, set);
ModificationCommandTreeGenerator.SetFakeKeyValues(obj2, entityType1);
set.Attach(obj2);
objectStateManager.ChangeRelationshipState(entity, obj2, associationType.FullName, principalEnd.Name, EntityState.Deleted);
}
objectStateManager.ChangeRelationshipState(entity, obj1, associationType.FullName, principalEnd.Name, state == EntityState.Deleted ? state : EntityState.Added);
}
}
}
public void Generate(EntityType entityType, DbDatabaseMapping databaseMapping)
{
EntitySet entitySet = databaseMapping.Model.GetEntitySet(entityType);
EntitySetMapping entitySetMapping = databaseMapping.GetEntitySetMapping(entitySet) ?? databaseMapping.AddEntitySetMapping(entitySet);
EntityTypeMapping entityTypeMapping1 = entitySetMapping.EntityTypeMappings.FirstOrDefault <EntityTypeMapping>((Func <EntityTypeMapping, bool>)(m => m.EntityTypes.Contains((EntityTypeBase)entitySet.ElementType))) ?? entitySetMapping.EntityTypeMappings.FirstOrDefault <EntityTypeMapping>();
EntityType entityType1 = entityTypeMapping1 != null?entityTypeMapping1.MappingFragments.First <MappingFragment>().Table : databaseMapping.Database.AddTable(entityType.GetRootType().Name);
EntityTypeMapping entityTypeMapping2 = new EntityTypeMapping((EntitySetMapping)null);
MappingFragment mappingFragment = new MappingFragment(databaseMapping.Database.GetEntitySet(entityType1), (TypeMapping)entityTypeMapping2, false);
entityTypeMapping2.AddType(entityType);
entityTypeMapping2.AddFragment(mappingFragment);
entityTypeMapping2.SetClrType(EntityTypeExtensions.GetClrType(entityType));
entitySetMapping.AddTypeMapping(entityTypeMapping2);
new PropertyMappingGenerator(this._providerManifest).Generate(entityType, (IEnumerable <EdmProperty>)entityType.Properties, entitySetMapping, mappingFragment, (IList <EdmProperty>) new List <EdmProperty>(), false);
}
private void ConfigureKey(EntityType entityType)
{
if (!this._keyProperties.Any <PropertyInfo>())
{
return;
}
if (entityType.BaseType != null)
{
throw Error.KeyRegisteredOnDerivedType((object)this.ClrType, (object)EntityTypeExtensions.GetClrType(entityType.GetRootType()));
}
IEnumerable <PropertyInfo> propertyInfos = this._keyProperties.AsEnumerable <PropertyInfo>();
if (!this._isKeyConfigured)
{
IEnumerable <\u003C\u003Ef__AnonymousType41 <PropertyInfo, int?> > source = this._keyProperties.Select(p => new
{
PropertyInfo = p,
ColumnOrder = this.Property(new PropertyPath(p), new OverridableConfigurationParts?()).ColumnOrder
});
if (this._keyProperties.Count > 1 && source.Any(p => !p.ColumnOrder.HasValue))
{
throw Error.ModelGeneration_UnableToDetermineKeyOrder((object)this.ClrType);
}
propertyInfos = source.OrderBy(p => p.ColumnOrder).Select(p => p.PropertyInfo);
}
foreach (PropertyInfo propertyInfo in propertyInfos)
{
EdmProperty primitiveProperty = entityType.GetDeclaredPrimitiveProperty(propertyInfo);
if (primitiveProperty == null)
{
throw Error.KeyPropertyNotFound((object)propertyInfo.Name, (object)entityType.Name);
}
primitiveProperty.Nullable = false;
entityType.AddKeyMember((EdmMember)primitiveProperty);
}
}
/// <inheritdoc />
public virtual void Apply(EntityType item, DbModel model)
{
Check.NotNull <EntityType>(item, nameof(item));
Check.NotNull <DbModel>(model, nameof(model));
if (item.BaseType != null)
{
return;
}
foreach (EdmProperty keyProperty in item.KeyProperties)
{
item.RemoveMember((EdmMember)keyProperty);
item.AddKeyMember((EdmMember)keyProperty);
}
foreach (PropertyInfo property in new PropertyFilter(DbModelBuilderVersion.Latest).GetProperties(EntityTypeExtensions.GetClrType(item), false, (IEnumerable <PropertyInfo>)null, (IEnumerable <Type>)null, true))
{
PropertyInfo p = property;
EdmProperty edmProperty = item.DeclaredProperties.SingleOrDefault <EdmProperty>((Func <EdmProperty, bool>)(ep => ep.Name == p.Name));
if (edmProperty != null && !item.KeyProperties.Contains(edmProperty))
{
item.RemoveMember((EdmMember)edmProperty);
item.AddMember((EdmMember)edmProperty);
}
}
}
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)
{
this._initialExistence = initialExistence;
this._commandTimeout = commandTimeout;
this._existingTransaction = usersContext.TryGetCurrentStoreTransaction();
this._schemas = ((IEnumerable <string>) new string[1]
{
"dbo"
}).Concat <string>(schemas ?? Enumerable.Empty <string>()).Distinct <string>();
this._contextForInterception = contextForInterception;
this._historyContextFactory = historyContextFactory;
DbConnection connection = (DbConnection)null;
try
{
connection = this.CreateConnection();
using (HistoryContext context = this.CreateContext(connection, (string)null))
{
EntityType entityType = ((IObjectContextAdapter)context).ObjectContext.MetadataWorkspace.GetItems <EntityType>(DataSpace.CSpace).Single <EntityType>((Func <EntityType, bool>)(et => EntityTypeExtensions.GetClrType(et) == typeof(HistoryRow)));
int? maxLength = entityType.Properties.Single <EdmProperty>((Func <EdmProperty, bool>)(p => p.GetClrPropertyInfo().IsSameAs(HistoryRepository.MigrationIdProperty))).MaxLength;
this._migrationIdMaxLength = maxLength.HasValue ? maxLength.Value : 150;
maxLength = entityType.Properties.Single <EdmProperty>((Func <EdmProperty, bool>)(p => p.GetClrPropertyInfo().IsSameAs(HistoryRepository.ContextKeyProperty))).MaxLength;
this._contextKeyMaxLength = maxLength.HasValue ? maxLength.Value : 300;
}
}
finally
{
this.DisposeConnection(connection);
}
this._contextKey = contextKey.RestrictTo(this._contextKeyMaxLength);
}
private static void ConfigureUnconfiguredDerivedTypes(
DbDatabaseMapping databaseMapping,
ICollection <EntitySet> entitySets,
DbProviderManifest providerManifest,
EntityType entityType,
IList <EntityTypeConfiguration> sortedEntityConfigurations)
{
List <EntityType> list = databaseMapping.Model.GetDerivedTypes(entityType).ToList <EntityType>();
while (list.Count > 0)
{
EntityType currentType = list[0];
list.RemoveAt(0);
if (!currentType.Abstract && sortedEntityConfigurations.All <EntityTypeConfiguration>((Func <EntityTypeConfiguration, bool>)(etc => etc.ClrType != EntityTypeExtensions.GetClrType(currentType))))
{
EntityTypeConfiguration.ConfigureUnconfiguredType(databaseMapping, entitySets, providerManifest, currentType, (IDictionary <string, object>) new Dictionary <string, object>());
list.AddRange(databaseMapping.Model.GetDerivedTypes(currentType));
}
}
}
internal static void ConfigureUnconfiguredType(
DbDatabaseMapping databaseMapping,
ICollection <EntitySet> entitySets,
DbProviderManifest providerManifest,
EntityType entityType,
IDictionary <string, object> commonAnnotations)
{
EntityMappingConfiguration mappingConfiguration = new EntityMappingConfiguration();
EntityTypeMapping entityTypeMapping = databaseMapping.GetEntityTypeMapping(EntityTypeExtensions.GetClrType(entityType));
mappingConfiguration.Configure(databaseMapping, entitySets, providerManifest, entityType, ref entityTypeMapping, false, 0, 1, commonAnnotations);
}
private static IEnumerable <EdmProperty> GetDependentProperties(
EntityType dependentType,
IEnumerable <string> dependentPropertyNames,
EntityType declaringEntityType,
NavigationProperty navigationProperty)
{
foreach (string dependentPropertyName1 in dependentPropertyNames)
{
string dependentPropertyName = dependentPropertyName1;
if (string.IsNullOrWhiteSpace(dependentPropertyName))
{
throw Error.ForeignKeyAttributeConvention_EmptyKey((object)navigationProperty.Name, (object)EntityTypeExtensions.GetClrType(declaringEntityType));
}
EdmProperty dependentProperty = dependentType.Properties.SingleOrDefault <EdmProperty>((Func <EdmProperty, bool>)(p => p.Name.Equals(dependentPropertyName, StringComparison.Ordinal)));
if (dependentProperty == null)
{
throw Error.ForeignKeyAttributeConvention_InvalidKey((object)navigationProperty.Name, (object)EntityTypeExtensions.GetClrType(declaringEntityType), (object)dependentPropertyName, (object)EntityTypeExtensions.GetClrType(dependentType));
}
yield return(dependentProperty);
}
}
private static void GenerateEntityTypes(DbDatabaseMapping databaseMapping)
{
foreach (EntityType entityType1 in databaseMapping.Model.EntityTypes)
{
EntityType entityType = entityType1;
if (entityType.Abstract && databaseMapping.Model.EntityTypes.All <EntityType>((Func <EntityType, bool>)(e => e.BaseType != entityType)))
{
throw new InvalidOperationException(Strings.UnmappedAbstractType((object)EntityTypeExtensions.GetClrType(entityType)));
}
new TableMappingGenerator(databaseMapping.ProviderManifest).Generate(entityType, databaseMapping);
}
}
private IList <EntityTypeConfiguration> SortEntityConfigurationsByInheritance(
DbDatabaseMapping databaseMapping)
{
List <EntityTypeConfiguration> typeConfigurationList = new List <EntityTypeConfiguration>();
foreach (EntityTypeConfiguration entityConfiguration in this.ActiveEntityConfigurations)
{
EntityType entityType = databaseMapping.Model.GetEntityType(entityConfiguration.ClrType);
if (entityType != null)
{
if (entityType.BaseType == null)
{
if (!typeConfigurationList.Contains(entityConfiguration))
{
typeConfigurationList.Add(entityConfiguration);
}
}
else
{
Stack <EntityType> entityTypeStack = new Stack <EntityType>();
for (; entityType != null; entityType = (EntityType)entityType.BaseType)
{
entityTypeStack.Push(entityType);
}
while (entityTypeStack.Count > 0)
{
entityType = entityTypeStack.Pop();
EntityTypeConfiguration typeConfiguration = this.ActiveEntityConfigurations.SingleOrDefault <EntityTypeConfiguration>((Func <EntityTypeConfiguration, bool>)(ec => ec.ClrType == EntityTypeExtensions.GetClrType(entityType)));
if (typeConfiguration != null && !typeConfigurationList.Contains(typeConfiguration))
{
typeConfigurationList.Add(typeConfiguration);
}
}
}
}
}
return((IList <EntityTypeConfiguration>)typeConfigurationList);
}
public void Test_GetSecuringRelationships_NullEntityType()
{
Assert.That(() => EntityTypeExtensions.GetSecuringRelationships(null, true, false),
Throws.TypeOf <ArgumentNullException>().And.Property("ParamName").EqualTo("entityType"));
}
internal override void Configure(
AssociationType associationType,
AssociationEndMember dependentEnd,
EntityTypeConfiguration entityTypeConfiguration)
{
// ISSUE: object of a compiler-generated type is created
// ISSUE: variable of a compiler-generated type
ForeignKeyConstraintConfiguration.\u003C\u003Ec__DisplayClasse cDisplayClasse1 = new ForeignKeyConstraintConfiguration.\u003C\u003Ec__DisplayClasse();
// ISSUE: reference to a compiler-generated field
cDisplayClasse1.entityTypeConfiguration = entityTypeConfiguration;
if (!this._dependentProperties.Any <PropertyInfo>())
{
return;
}
IEnumerable <PropertyInfo> propertyInfos = this._dependentProperties.AsEnumerable <PropertyInfo>();
if (!this.IsFullySpecified)
{
// ISSUE: reference to a compiler-generated field
if (EntityTypeExtensions.GetClrType(dependentEnd.GetEntityType()) != cDisplayClasse1.entityTypeConfiguration.ClrType)
{
return;
}
// ISSUE: reference to a compiler-generated method
IEnumerable <\u003C\u003Ef__AnonymousType41 <PropertyInfo, int?> > source = this._dependentProperties.Select(new Func <PropertyInfo, \u003C\u003Ef__AnonymousType41 <PropertyInfo, int?> >(cDisplayClasse1.\u003CConfigure\u003Eb__0));
if (this._dependentProperties.Count > 1 && source.Any(p => !p.ColumnOrder.HasValue))
{
ReadOnlyMetadataCollection <EdmProperty> dependentKeys = dependentEnd.GetEntityType().KeyProperties;
if (dependentKeys.Count != this._dependentProperties.Count || !source.All(fk =>
{
// ISSUE: variable of a compiler-generated type
ForeignKeyConstraintConfiguration.\u003C\u003Ec__DisplayClasse cDisplayClasse = cDisplayClasse1;
var fk1 = fk;
return(dependentKeys.Any <EdmProperty>((Func <EdmProperty, bool>)(p => p.GetClrPropertyInfo().IsSameAs(fk1.PropertyInfo))));
}))
{
// ISSUE: reference to a compiler-generated field
throw Error.ForeignKeyAttributeConvention_OrderRequired((object)cDisplayClasse1.entityTypeConfiguration.ClrType);
}
propertyInfos = dependentKeys.Select <EdmProperty, PropertyInfo>((Func <EdmProperty, PropertyInfo>)(p => p.GetClrPropertyInfo()));
}
else
{
propertyInfos = source.OrderBy(p => p.ColumnOrder).Select(p => p.PropertyInfo);
}
}
List <EdmProperty> edmPropertyList = new List <EdmProperty>();
foreach (PropertyInfo propertyInfo in propertyInfos)
{
EdmProperty primitiveProperty = dependentEnd.GetEntityType().GetDeclaredPrimitiveProperty(propertyInfo);
if (primitiveProperty == null)
{
throw Error.ForeignKeyPropertyNotFound((object)propertyInfo.Name, (object)dependentEnd.GetEntityType().Name);
}
edmPropertyList.Add(primitiveProperty);
}
AssociationEndMember otherEnd = associationType.GetOtherEnd(dependentEnd);
ReferentialConstraint referentialConstraint = new ReferentialConstraint((RelationshipEndMember)otherEnd, (RelationshipEndMember)dependentEnd, (IEnumerable <EdmProperty>)otherEnd.GetEntityType().KeyProperties, (IEnumerable <EdmProperty>)edmPropertyList);
if (otherEnd.IsRequired())
{
referentialConstraint.ToProperties.Each <EdmProperty, bool>((Func <EdmProperty, bool>)(p => p.Nullable = false));
}
associationType.Constraint = referentialConstraint;
}
internal void Configure(
EntityType entityType,
DbDatabaseMapping databaseMapping,
DbProviderManifest providerManifest)
{
EntityTypeMapping entityTypeMapping = databaseMapping.GetEntityTypeMapping(EntityTypeExtensions.GetClrType(entityType));
if (entityTypeMapping != null)
{
EntityTypeConfiguration.VerifyAllCSpacePropertiesAreMapped((ICollection <EntityTypeMapping>)databaseMapping.GetEntityTypeMappings(entityType).ToList <EntityTypeMapping>(), (IEnumerable <EdmProperty>)entityTypeMapping.EntityType.DeclaredProperties, (IList <EdmProperty>) new List <EdmProperty>());
}
this.ConfigurePropertyMappings(databaseMapping, entityType, providerManifest, false);
this.ConfigureAssociationMappings(databaseMapping, entityType, providerManifest);
EntityTypeConfiguration.ConfigureDependentKeys(databaseMapping, providerManifest);
this.ConfigureModificationStoredProcedures(databaseMapping, entityType, providerManifest);
}
