// <summary>
// Load the entity type or complex type mapping
// </summary>
private static void LoadEntityTypeOrComplexTypeMapping(
ObjectTypeMapping objectMapping, EdmType edmType, EdmType objectType,
DefaultObjectMappingItemCollection ocItemCollection, Dictionary <string, ObjectTypeMapping> typeMappings)
{
Debug.Assert(
edmType.BuiltInTypeKind == BuiltInTypeKind.EntityType ||
edmType.BuiltInTypeKind == BuiltInTypeKind.ComplexType,
"Expected Type Encountered in LoadEntityTypeOrComplexTypeMapping");
Debug.Assert(
(edmType.BuiltInTypeKind == objectType.BuiltInTypeKind),
"The BuiltInTypeKind must be same in LoadEntityTypeOrComplexTypeMapping");
var cdmStructuralType = (StructuralType)edmType;
var objectStructuralType = (StructuralType)objectType;
ValidateAllMembersAreMapped(cdmStructuralType, objectStructuralType);
//Go through the CDMMembers and find the corresponding member in Object space
//and create a member map.
foreach (var edmMember in cdmStructuralType.Members)
{
var objectMember = GetObjectMember(edmMember, objectStructuralType);
ValidateMembersMatch(edmMember, objectMember);
if (Helper.IsEdmProperty(edmMember))
{
var edmPropertyMember = (EdmProperty)edmMember;
var edmPropertyObject = (EdmProperty)objectMember;
//Depending on the type of member load the member mapping i.e. For complex
//members we have to go in and load the child members of the Complex type.
if (Helper.IsComplexType(edmMember.TypeUsage.EdmType))
{
objectMapping.AddMemberMap(
LoadComplexMemberMapping(edmPropertyMember, edmPropertyObject, ocItemCollection, typeMappings));
}
else
{
objectMapping.AddMemberMap(
LoadScalarPropertyMapping(edmPropertyMember, edmPropertyObject));
}
}
else
{
Debug.Assert(edmMember.BuiltInTypeKind == BuiltInTypeKind.NavigationProperty, "Unexpected Property type encountered");
// For navigation properties, we need to make sure the relationship type on the navigation property is mapped
var navigationProperty = (NavigationProperty)edmMember;
var objectNavigationProperty = (NavigationProperty)objectMember;
LoadTypeMapping(
navigationProperty.RelationshipType, objectNavigationProperty.RelationshipType, ocItemCollection, typeMappings);
objectMapping.AddMemberMap(new ObjectNavigationPropertyMapping(navigationProperty, objectNavigationProperty));
}
}
}
private Map GetOCMapForTransientType(EdmType edmType, DataSpace typeSpace)
{
Debug.Assert(
typeSpace == DataSpace.CSpace || typeSpace == DataSpace.OSpace || Helper.IsRowType(edmType) ||
Helper.IsCollectionType(edmType));
EdmType clrType = null;
EdmType cdmType = null;
var index = -1;
if (typeSpace != DataSpace.OSpace)
{
if (cdmTypeIndexes.TryGetValue(edmType.Identity, out index))
{
return((Map)this[index]);
}
else
{
cdmType = edmType;
clrType = ConvertCSpaceToOSpaceType(edmType);
}
}
else if (typeSpace == DataSpace.OSpace)
{
if (clrTypeIndexes.TryGetValue(edmType.Identity, out index))
{
return((Map)this[index]);
}
else
{
clrType = edmType;
cdmType = ConvertOSpaceToCSpaceType(clrType);
}
}
var typeMapping = new ObjectTypeMapping(clrType, cdmType);
if (BuiltInTypeKind.RowType
== edmType.BuiltInTypeKind)
{
var clrRowType = (RowType)clrType;
var edmRowType = (RowType)cdmType;
Debug.Assert(clrRowType.Properties.Count == edmRowType.Properties.Count, "Property count mismatch");
for (var idx = 0; idx < clrRowType.Properties.Count; idx++)
{
typeMapping.AddMemberMap(new ObjectPropertyMapping(edmRowType.Properties[idx], clrRowType.Properties[idx]));
}
}
if ((!cdmTypeIndexes.ContainsKey(cdmType.Identity)) &&
(!clrTypeIndexes.ContainsKey(clrType.Identity)))
{
AddInternalMapping(typeMapping);
}
return(typeMapping);
}
private static void LoadEntityTypeOrComplexTypeMapping(
ObjectTypeMapping objectMapping,
EdmType edmType,
EdmType objectType,
DefaultObjectMappingItemCollection ocItemCollection,
Dictionary <string, ObjectTypeMapping> typeMappings)
{
StructuralType cdmStructuralType = (StructuralType)edmType;
StructuralType structuralType = (StructuralType)objectType;
DefaultObjectMappingItemCollection.ValidateAllMembersAreMapped(cdmStructuralType, structuralType);
foreach (EdmMember member in cdmStructuralType.Members)
{
EdmMember objectMember = DefaultObjectMappingItemCollection.GetObjectMember(member, structuralType);
DefaultObjectMappingItemCollection.ValidateMembersMatch(member, objectMember);
if (Helper.IsEdmProperty(member))
{
EdmProperty edmProperty1 = (EdmProperty)member;
EdmProperty edmProperty2 = (EdmProperty)objectMember;
if (Helper.IsComplexType(member.TypeUsage.EdmType))
{
objectMapping.AddMemberMap((ObjectMemberMapping)DefaultObjectMappingItemCollection.LoadComplexMemberMapping(edmProperty1, edmProperty2, ocItemCollection, typeMappings));
}
else
{
objectMapping.AddMemberMap((ObjectMemberMapping)DefaultObjectMappingItemCollection.LoadScalarPropertyMapping(edmProperty1, edmProperty2));
}
}
else
{
NavigationProperty edmNavigationProperty = (NavigationProperty)member;
NavigationProperty clrNavigationProperty = (NavigationProperty)objectMember;
DefaultObjectMappingItemCollection.LoadTypeMapping((EdmType)edmNavigationProperty.RelationshipType, (EdmType)clrNavigationProperty.RelationshipType, ocItemCollection, typeMappings);
objectMapping.AddMemberMap((ObjectMemberMapping) new ObjectNavigationPropertyMapping(edmNavigationProperty, clrNavigationProperty));
}
}
}
private MappingBase GetOCMapForTransientType(EdmType edmType, DataSpace typeSpace)
{
EdmType clrType = (EdmType)null;
EdmType cdmType = (EdmType)null;
int index1 = -1;
if (typeSpace != DataSpace.OSpace)
{
if (this._edmTypeIndexes.TryGetValue(edmType.Identity, out index1))
{
return((MappingBase)this[index1]);
}
cdmType = edmType;
clrType = this.ConvertCSpaceToOSpaceType(edmType);
}
else if (typeSpace == DataSpace.OSpace)
{
if (this._clrTypeIndexes.TryGetValue(edmType.Identity, out index1))
{
return((MappingBase)this[index1]);
}
clrType = edmType;
cdmType = this.ConvertOSpaceToCSpaceType(clrType);
}
ObjectTypeMapping objectMap = new ObjectTypeMapping(clrType, cdmType);
if (BuiltInTypeKind.RowType == edmType.BuiltInTypeKind)
{
RowType rowType1 = (RowType)clrType;
RowType rowType2 = (RowType)cdmType;
for (int index2 = 0; index2 < rowType1.Properties.Count; ++index2)
{
objectMap.AddMemberMap((ObjectMemberMapping) new ObjectPropertyMapping(rowType2.Properties[index2], rowType1.Properties[index2]));
}
}
if (!this._edmTypeIndexes.ContainsKey(cdmType.Identity) && !this._clrTypeIndexes.ContainsKey(clrType.Identity))
{
lock (this._lock)
{
Dictionary <string, int> clrTypeIndexes = new Dictionary <string, int>((IDictionary <string, int>) this._clrTypeIndexes);
Dictionary <string, int> edmTypeIndexes = new Dictionary <string, int>((IDictionary <string, int>) this._edmTypeIndexes);
objectMap = this.AddInternalMapping(objectMap, clrTypeIndexes, edmTypeIndexes);
this._clrTypeIndexes = clrTypeIndexes;
this._edmTypeIndexes = edmTypeIndexes;
}
}
return((MappingBase)objectMap);
}
private static void LoadAssociationTypeMapping(
ObjectTypeMapping objectMapping,
EdmType edmType,
EdmType objectType,
DefaultObjectMappingItemCollection ocItemCollection,
Dictionary <string, ObjectTypeMapping> typeMappings)
{
AssociationType associationType1 = (AssociationType)edmType;
AssociationType associationType2 = (AssociationType)objectType;
foreach (AssociationEndMember associationEndMember in associationType1.AssociationEndMembers)
{
AssociationEndMember objectMember = (AssociationEndMember)DefaultObjectMappingItemCollection.GetObjectMember((EdmMember)associationEndMember, (StructuralType)associationType2);
DefaultObjectMappingItemCollection.ValidateMembersMatch((EdmMember)associationEndMember, (EdmMember)objectMember);
if (associationEndMember.RelationshipMultiplicity != objectMember.RelationshipMultiplicity)
{
throw new MappingException(Strings.Mapping_Default_OCMapping_MultiplicityMismatch((object)associationEndMember.RelationshipMultiplicity, (object)associationEndMember.Name, (object)associationType1.FullName, (object)objectMember.RelationshipMultiplicity, (object)objectMember.Name, (object)associationType2.FullName));
}
DefaultObjectMappingItemCollection.LoadTypeMapping((EdmType)((RefType)associationEndMember.TypeUsage.EdmType).ElementType, (EdmType)((RefType)objectMember.TypeUsage.EdmType).ElementType, ocItemCollection, typeMappings);
objectMapping.AddMemberMap((ObjectMemberMapping) new ObjectAssociationEndMapping(associationEndMember, objectMember));
}
}
// <summary>
// Loads Association Type Mapping
// </summary>
private static void LoadAssociationTypeMapping(
ObjectTypeMapping objectMapping, EdmType edmType, EdmType objectType,
DefaultObjectMappingItemCollection ocItemCollection, Dictionary <string, ObjectTypeMapping> typeMappings)
{
Debug.Assert(
edmType.BuiltInTypeKind == BuiltInTypeKind.AssociationType, "Expected Type Encountered in LoadAssociationTypeMapping");
Debug.Assert(
(edmType.BuiltInTypeKind == objectType.BuiltInTypeKind), "The BuiltInTypeKind must be same in LoadAssociationTypeMapping");
var association = (AssociationType)edmType;
var objectAssociation = (AssociationType)objectType;
foreach (var edmEnd in association.AssociationEndMembers)
{
var objectEnd = (AssociationEndMember)GetObjectMember(edmEnd, objectAssociation);
ValidateMembersMatch(edmEnd, objectEnd);
if (edmEnd.RelationshipMultiplicity
!= objectEnd.RelationshipMultiplicity)
{
throw new MappingException(
Strings.Mapping_Default_OCMapping_MultiplicityMismatch(
edmEnd.RelationshipMultiplicity, edmEnd.Name, association.FullName,
objectEnd.RelationshipMultiplicity, objectEnd.Name, objectAssociation.FullName));
}
Debug.Assert(edmEnd.TypeUsage.EdmType.BuiltInTypeKind == BuiltInTypeKind.RefType, "Ends must be of Ref type");
// GetMap for the entity types for the ends of the relationship type to make sure
// the entity type mentioned are valid
LoadTypeMapping(
((RefType)edmEnd.TypeUsage.EdmType).ElementType,
((RefType)objectEnd.TypeUsage.EdmType).ElementType, ocItemCollection, typeMappings);
objectMapping.AddMemberMap(new ObjectAssociationEndMapping(edmEnd, objectEnd));
}
}
/// <summary>
/// Loads Association Type Mapping
/// </summary>
/// <param name="objectMapping"></param>
/// <param name="edmType"></param>
/// <param name="objectType"></param>
/// <param name="ocItemCollection"></param>
/// <param name="typeMappings"></param>
private static void LoadAssociationTypeMapping(
ObjectTypeMapping objectMapping, EdmType edmType, EdmType objectType,
DefaultObjectMappingItemCollection ocItemCollection, Dictionary<string, ObjectTypeMapping> typeMappings)
{
Debug.Assert(
edmType.BuiltInTypeKind == BuiltInTypeKind.AssociationType, "Expected Type Encountered in LoadAssociationTypeMapping");
Debug.Assert(
(edmType.BuiltInTypeKind == objectType.BuiltInTypeKind), "The BuiltInTypeKind must be same in LoadAssociationTypeMapping");
var association = (AssociationType)edmType;
var objectAssociation = (AssociationType)objectType;
foreach (var edmEnd in association.AssociationEndMembers)
{
var objectEnd = (AssociationEndMember)GetObjectMember(edmEnd, objectAssociation);
ValidateMembersMatch(edmEnd, objectEnd);
if (edmEnd.RelationshipMultiplicity
!= objectEnd.RelationshipMultiplicity)
{
throw new MappingException(
Strings.Mapping_Default_OCMapping_MultiplicityMismatch(
edmEnd.RelationshipMultiplicity, edmEnd.Name, association.FullName,
objectEnd.RelationshipMultiplicity, objectEnd.Name, objectAssociation.FullName));
}
Debug.Assert(edmEnd.TypeUsage.EdmType.BuiltInTypeKind == BuiltInTypeKind.RefType, "Ends must be of Ref type");
// GetMap for the entity types for the ends of the relationship type to make sure
// the entity type mentioned are valid
LoadTypeMapping(
((RefType)edmEnd.TypeUsage.EdmType).ElementType,
((RefType)objectEnd.TypeUsage.EdmType).ElementType, ocItemCollection, typeMappings);
objectMapping.AddMemberMap(new ObjectAssociationEndMapping(edmEnd, objectEnd));
}
}
/// <summary>
/// Load the entity type or complex type mapping
/// </summary>
/// <param name="objectMapping"></param>
/// <param name="edmType"></param>
/// <param name="objectType"></param>
/// <param name="ocItemCollection">
/// <param name="typeMappings"></param></param>
private static void LoadEntityTypeOrComplexTypeMapping(
ObjectTypeMapping objectMapping, EdmType edmType, EdmType objectType,
DefaultObjectMappingItemCollection ocItemCollection, Dictionary<string, ObjectTypeMapping> typeMappings)
{
Debug.Assert(
edmType.BuiltInTypeKind == BuiltInTypeKind.EntityType ||
edmType.BuiltInTypeKind == BuiltInTypeKind.ComplexType,
"Expected Type Encountered in LoadEntityTypeOrComplexTypeMapping");
Debug.Assert(
(edmType.BuiltInTypeKind == objectType.BuiltInTypeKind),
"The BuiltInTypeKind must be same in LoadEntityTypeOrComplexTypeMapping");
var cdmStructuralType = (StructuralType)edmType;
var objectStructuralType = (StructuralType)objectType;
ValidateAllMembersAreMapped(cdmStructuralType, objectStructuralType);
//Go through the CDMMembers and find the corresponding member in Object space
//and create a member map.
foreach (var edmMember in cdmStructuralType.Members)
{
var objectMember = GetObjectMember(edmMember, objectStructuralType);
ValidateMembersMatch(edmMember, objectMember);
if (Helper.IsEdmProperty(edmMember))
{
var edmPropertyMember = (EdmProperty)edmMember;
var edmPropertyObject = (EdmProperty)objectMember;
//Depending on the type of member load the member mapping i.e. For complex
//members we have to go in and load the child members of the Complex type.
if (Helper.IsComplexType(edmMember.TypeUsage.EdmType))
{
objectMapping.AddMemberMap(
LoadComplexMemberMapping(edmPropertyMember, edmPropertyObject, ocItemCollection, typeMappings));
}
else
{
objectMapping.AddMemberMap(
LoadScalarPropertyMapping(edmPropertyMember, edmPropertyObject));
}
}
else
{
Debug.Assert(edmMember.BuiltInTypeKind == BuiltInTypeKind.NavigationProperty, "Unexpected Property type encountered");
// For navigation properties, we need to make sure the relationship type on the navigation property is mapped
var navigationProperty = (NavigationProperty)edmMember;
var objectNavigationProperty = (NavigationProperty)objectMember;
LoadTypeMapping(
navigationProperty.RelationshipType, objectNavigationProperty.RelationshipType, ocItemCollection, typeMappings);
objectMapping.AddMemberMap(new ObjectNavigationPropertyMapping(navigationProperty, objectNavigationProperty));
}
}
}
private Map GetOCMapForTransientType(EdmType edmType, DataSpace typeSpace)
{
Debug.Assert(
typeSpace == DataSpace.CSpace || typeSpace == DataSpace.OSpace || Helper.IsRowType(edmType)
|| Helper.IsCollectionType(edmType));
EdmType clrType = null;
EdmType cdmType = null;
var index = -1;
if (typeSpace != DataSpace.OSpace)
{
if (cdmTypeIndexes.TryGetValue(edmType.Identity, out index))
{
return (Map)this[index];
}
else
{
cdmType = edmType;
clrType = ConvertCSpaceToOSpaceType(edmType);
}
}
else if (typeSpace == DataSpace.OSpace)
{
if (clrTypeIndexes.TryGetValue(edmType.Identity, out index))
{
return (Map)this[index];
}
else
{
clrType = edmType;
cdmType = ConvertOSpaceToCSpaceType(clrType);
}
}
var typeMapping = new ObjectTypeMapping(clrType, cdmType);
if (BuiltInTypeKind.RowType
== edmType.BuiltInTypeKind)
{
var clrRowType = (RowType)clrType;
var edmRowType = (RowType)cdmType;
Debug.Assert(clrRowType.Properties.Count == edmRowType.Properties.Count, "Property count mismatch");
for (var idx = 0; idx < clrRowType.Properties.Count; idx++)
{
typeMapping.AddMemberMap(new ObjectPropertyMapping(edmRowType.Properties[idx], clrRowType.Properties[idx]));
}
}
if ((!cdmTypeIndexes.ContainsKey(cdmType.Identity))
&& (!clrTypeIndexes.ContainsKey(clrType.Identity)))
{
AddInternalMapping(typeMapping);
}
return typeMapping;
}
public void Executes_in_a_transaction_using_ExecutionStrategy()
{
var shaperMock = MockHelper.CreateShaperMock<object>();
shaperMock.Setup(m => m.GetEnumerator()).Returns(
() => new DbEnumeratorShim<object>(((IEnumerable<object>)new[] { new object() }).GetEnumerator()));
var objectResultMock = new Mock<ObjectResult<object>>(shaperMock.Object, null, null)
{
CallBase = true
};
var entityType = new EntityType(
"FakeEntityType", "FakeNamespace", DataSpace.CSpace, new[] { "key" }, new EdmMember[] { new EdmProperty("key") });
var entitySet = new EntitySet("FakeSet", "FakeSchema", "FakeTable", null, entityType);
var entityContainer = new EntityContainer("FakeContainer", DataSpace.CSpace);
entityContainer.AddEntitySetBase(entitySet);
entitySet.ChangeEntityContainerWithoutCollectionFixup(entityContainer);
entitySet.SetReadOnly();
var model = new EdmModel(DataSpace.CSpace);
var omicMock = new Mock<DefaultObjectMappingItemCollection>(new EdmItemCollection(model), new ObjectItemCollection())
{
CallBase = true
};
var objectTypeMapping = new ObjectTypeMapping(entityType, entityType);
objectTypeMapping.AddMemberMap(
new ObjectPropertyMapping((EdmProperty)entityType.Members.First(), (EdmProperty)entityType.Members.First()));
omicMock.Setup(m => m.GetMap(It.IsAny<GlobalItem>())).Returns(objectTypeMapping);
var metadataWorkspaceMock = new Mock<MetadataWorkspace>
{
CallBase = true
};
metadataWorkspaceMock.Setup(m => m.IsItemCollectionAlreadyRegistered(DataSpace.OSpace)).Returns(true);
metadataWorkspaceMock.Setup(m => m.IsItemCollectionAlreadyRegistered(DataSpace.SSpace)).Returns(true);
metadataWorkspaceMock.Setup(m => m.GetEntityContainer(It.IsAny<string>(), It.IsAny<DataSpace>()))
.Returns(entityContainer);
metadataWorkspaceMock.Setup(m => m.TryGetEntityContainer(It.IsAny<string>(), It.IsAny<DataSpace>(), out entityContainer))
.Returns(true);
var storeItemCollection = new StoreItemCollection(
GenericProviderFactory<DbProviderFactory>.Instance, new SqlProviderManifest("2008"), "System.Data.FakeSqlClient", "2008");
metadataWorkspaceMock.Setup(m => m.GetItemCollection(DataSpace.SSpace)).Returns(storeItemCollection);
#pragma warning disable 618
metadataWorkspaceMock.Object.RegisterItemCollection(omicMock.Object);
#pragma warning restore 618
var objectStateManagerMock = new Mock<ObjectStateManager>(metadataWorkspaceMock.Object)
{
CallBase = true
};
var entityKey = new EntityKey(entitySet, "keyValue");
var entityEntry = objectStateManagerMock.Object.AddKeyEntry(entityKey, entitySet);
var objectContextMock = Mock.Get(
CreateObjectContext(
metadataWorkspaceMock: metadataWorkspaceMock,
objectStateManagerMock: objectStateManagerMock));
var entityWrapperMock = new Mock<IEntityWrapper>();
entityWrapperMock.Setup(m => m.EntityKey).Returns(entityKey);
var entityWrapperFactoryMock = new Mock<EntityWrapperFactory>();
entityWrapperFactoryMock.Setup(
m => m.WrapEntityUsingStateManagerGettingEntry(
It.IsAny<object>(), It.IsAny<ObjectStateManager>(), out entityEntry))
.Returns(entityWrapperMock.Object);
objectContextMock.Setup(m => m.EntityWrapperFactory).Returns(entityWrapperFactoryMock.Object);
var executionPlanMock = new Mock<ObjectQueryExecutionPlan>(
MockBehavior.Loose, null, null, null, MergeOption.NoTracking, false, null, null);
executionPlanMock.Setup(
m => m.Execute<object>(It.IsAny<ObjectContext>(), It.IsAny<ObjectParameterCollection>()))
.Returns(objectResultMock.Object);
objectContextMock.Setup(
m => m.PrepareRefreshQuery(It.IsAny<RefreshMode>(), It.IsAny<EntitySet>(), It.IsAny<List<EntityKey>>(), It.IsAny<int>()))
.Returns(new Tuple<ObjectQueryExecutionPlan, int>(executionPlanMock.Object, 1));
// Verify that ExecuteInTransaction calls ObjectQueryExecutionPlan.Execute
objectContextMock.Setup(
m =>
m.ExecuteInTransaction(It.IsAny<Func<ObjectResult<object>>>(), It.IsAny<IDbExecutionStrategy>(), It.IsAny<bool>(), It.IsAny<bool>()))
.Returns<Func<ObjectResult<object>>, IDbExecutionStrategy, bool, bool>(
(f, t, s, r) =>
{
executionPlanMock.Verify(
m =>
m.Execute<object>(It.IsAny<ObjectContext>(), It.IsAny<ObjectParameterCollection>()),
Times.Never());
var result = f();
executionPlanMock.Verify(
m =>
m.Execute<object>(It.IsAny<ObjectContext>(), It.IsAny<ObjectParameterCollection>()),
Times.Once());
return result;
});
// Verify that ExecutionStrategy.Execute calls ExecuteInTransaction
var executionStrategyMock = new Mock<IDbExecutionStrategy>();
executionStrategyMock.Setup(m => m.Execute(It.IsAny<Func<ObjectResult<object>>>()))
.Returns<Func<ObjectResult<object>>>(
f =>
{
objectContextMock.Verify(
m =>
m.ExecuteInTransaction(
It.IsAny<Func<ObjectResult<object>>>(), It.IsAny<IDbExecutionStrategy>(), false, true),
Times.Never());
var result = f();
objectContextMock.Verify(
m =>
m.ExecuteInTransaction(
It.IsAny<Func<ObjectResult<object>>>(), It.IsAny<IDbExecutionStrategy>(), false, true),
Times.Once());
return result;
});
MutableResolver.AddResolver<Func<IDbExecutionStrategy>>(key => (Func<IDbExecutionStrategy>)(() => executionStrategyMock.Object));
try
{
objectContextMock.Object.Refresh(RefreshMode.StoreWins, new object());
}
finally
{
MutableResolver.ClearResolvers();
}
// Finally verify that ExecutionStrategy.Execute was called
executionStrategyMock.Verify(m => m.Execute(It.IsAny<Func<ObjectResult<object>>>()), Times.Once());
}
