/// <summary>
/// Creates an Enum property based on <paramref name="clrProperty" /> and adds it to the parent structural type.
/// </summary>
/// <param name="type">
/// CLR type owning <paramref name="clrProperty" /> .
/// </param>
/// <param name="ospaceType"> OSpace type the created property will be added to. </param>
/// <param name="cspaceProperty"> Corresponding property from CSpace. </param>
/// <param name="clrProperty"> CLR property used to build an Enum property. </param>
private void CreateAndAddEnumProperty(Type type, StructuralType ospaceType, EdmProperty cspaceProperty, PropertyInfo clrProperty)
{
EdmType propertyType;
if (CspaceToOspace.TryGetValue(cspaceProperty.TypeUsage.EdmType, out propertyType))
{
if (clrProperty.CanRead &&
clrProperty.CanWriteExtended())
{
AddScalarMember(type, clrProperty, ospaceType, cspaceProperty, propertyType);
}
else
{
LogError(
Strings.Validator_OSpace_Convention_ScalarPropertyMissginGetterOrSetter(
clrProperty.Name, type.FullName, type.Assembly.FullName),
cspaceProperty.TypeUsage.EdmType);
}
}
else
{
LogError(
Strings.Validator_OSpace_Convention_MissingOSpaceType(cspaceProperty.TypeUsage.EdmType.FullName),
cspaceProperty.TypeUsage.EdmType);
}
}
private EdmType ResolveBaseType(StructuralType baseCSpaceType, Type type)
{
EdmType ospaceType;
var foundValue = CspaceToOspace.TryGetValue(baseCSpaceType, out ospaceType);
if (!foundValue)
{
LogError(Strings.Validator_OSpace_Convention_BaseTypeNotLoaded(type, baseCSpaceType), baseCSpaceType);
}
Debug.Assert(!foundValue || ospaceType is StructuralType, "Structural type expected (if found).");
return(ospaceType);
}
public virtual void CreateRelationships(EdmItemCollection edmItemCollection)
{
foreach (var cspaceAssociation in edmItemCollection.GetItems <AssociationType>())
{
Debug.Assert(cspaceAssociation.RelationshipEndMembers.Count == 2, "Relationships are assumed to have exactly two ends");
if (CspaceToOspace.ContainsKey(cspaceAssociation))
{
// don't try to load relationships that we already know about
continue;
}
var ospaceEndTypes = new EdmType[2];
if (CspaceToOspace.TryGetValue(
GetRelationshipEndType(cspaceAssociation.RelationshipEndMembers[0]), out ospaceEndTypes[0]) &&
CspaceToOspace.TryGetValue(
GetRelationshipEndType(cspaceAssociation.RelationshipEndMembers[1]), out ospaceEndTypes[1]))
{
Debug.Assert(ospaceEndTypes[0] is StructuralType);
Debug.Assert(ospaceEndTypes[1] is StructuralType);
// if we can find both ends of the relationship, then create it
var ospaceAssociation = new AssociationType(
cspaceAssociation.Name, cspaceAssociation.NamespaceName, cspaceAssociation.IsForeignKey, DataSpace.OSpace);
for (var i = 0; i < cspaceAssociation.RelationshipEndMembers.Count; i++)
{
var ospaceEndType = (EntityType)ospaceEndTypes[i];
var cspaceEnd = cspaceAssociation.RelationshipEndMembers[i];
ospaceAssociation.AddKeyMember(
new AssociationEndMember(cspaceEnd.Name, ospaceEndType.GetReferenceType(), cspaceEnd.RelationshipMultiplicity));
}
AddToTypesInAssembly(ospaceAssociation);
LoadedTypes.Add(ospaceAssociation.FullName, ospaceAssociation);
CspaceToOspace.Add(cspaceAssociation, ospaceAssociation);
}
}
}
private void CreateAndAddComplexType(Type type, StructuralType ospaceType, EdmProperty cspaceProperty, PropertyInfo clrProperty)
{
EdmType propertyType;
if (CspaceToOspace.TryGetValue(cspaceProperty.TypeUsage.EdmType, out propertyType))
{
Debug.Assert(propertyType is StructuralType, "Structural type expected.");
var property = new EdmProperty(
cspaceProperty.Name, TypeUsage.Create(
propertyType, new FacetValues
{
Nullable = false
}), clrProperty, type);
ospaceType.AddMember(property);
}
else
{
LogError(
Strings.Validator_OSpace_Convention_MissingOSpaceType(cspaceProperty.TypeUsage.EdmType.FullName),
cspaceProperty.TypeUsage.EdmType);
}
}
private void CreateAndAddNavigationProperty(
StructuralType cspaceType, StructuralType ospaceType, NavigationProperty cspaceProperty)
{
EdmType ospaceRelationship;
if (CspaceToOspace.TryGetValue(cspaceProperty.RelationshipType, out ospaceRelationship))
{
Debug.Assert(ospaceRelationship is StructuralType, "Structural type expected.");
var foundTarget = false;
EdmType targetType = null;
if (Helper.IsCollectionType(cspaceProperty.TypeUsage.EdmType))
{
EdmType findType;
foundTarget =
CspaceToOspace.TryGetValue(
((CollectionType)cspaceProperty.TypeUsage.EdmType).TypeUsage.EdmType, out findType);
if (foundTarget)
{
Debug.Assert(findType is StructuralType, "Structural type expected.");
targetType = findType.GetCollectionType();
}
}
else
{
EdmType findType;
foundTarget = CspaceToOspace.TryGetValue(cspaceProperty.TypeUsage.EdmType, out findType);
if (foundTarget)
{
Debug.Assert(findType is StructuralType, "Structural type expected.");
targetType = findType;
}
}
Debug.Assert(
foundTarget,
"Since the relationship will only be created if it can find the types for both ends, we will never fail to find one of the ends");
var navigationProperty = new NavigationProperty(cspaceProperty.Name, TypeUsage.Create(targetType));
var relationshipType = (RelationshipType)ospaceRelationship;
navigationProperty.RelationshipType = relationshipType;
// we can use First because o-space relationships are created directly from
// c-space relationship
navigationProperty.ToEndMember =
(RelationshipEndMember)relationshipType.Members.First(e => e.Name == cspaceProperty.ToEndMember.Name);
navigationProperty.FromEndMember =
(RelationshipEndMember)relationshipType.Members.First(e => e.Name == cspaceProperty.FromEndMember.Name);
ospaceType.AddMember(navigationProperty);
}
else
{
var missingType =
cspaceProperty.RelationshipType.RelationshipEndMembers.Select(e => ((RefType)e.TypeUsage.EdmType).ElementType).First(
e => e != cspaceType);
LogError(
Strings.Validator_OSpace_Convention_RelationshipNotLoaded(
cspaceProperty.RelationshipType.FullName, missingType.FullName),
missingType);
}
}
