private static PropertyInfo GetPrincipalNavigationProperty(OeEdmModelMetadataProvider metadataProvider,
EntityTypeInfo principalInfo, EntityTypeInfo dependentInfo, PropertyInfo dependentNavigationProperty)
{
PropertyInfo inverseProperty = metadataProvider.GetInverseProperty(dependentNavigationProperty);
if (inverseProperty != null)
{
return(inverseProperty);
}
foreach (PropertyInfo clrProperty in metadataProvider.GetProperties(principalInfo.ClrType))
{
if (clrProperty.PropertyType == dependentInfo.ClrType ||
Parsers.OeExpressionHelper.GetCollectionItemTypeOrNull(clrProperty.PropertyType) == dependentInfo.ClrType)
{
inverseProperty = metadataProvider.GetInverseProperty(clrProperty);
if (inverseProperty == null || inverseProperty == dependentNavigationProperty)
{
return(clrProperty);
}
}
}
return(null);
}
private Dictionary <Type, EntityTypeInfo> BuildEntityTypes()
{
var entityTypeInfos = new Dictionary <Type, EntityTypeInfo>();
foreach (Type entitySetClrType in _entitySets.Values)
{
var baseClrTypes = new Stack <Type>(1);
Type clrType = entitySetClrType;
do
{
baseClrTypes.Push(clrType);
clrType = clrType.BaseType;
}while (clrType != typeof(Object));
EdmEntityType edmType = null;
foreach (Type baseClrType in baseClrTypes)
{
if (entityTypeInfos.TryGetValue(baseClrType, out EntityTypeInfo entityTypeInfo))
{
edmType = entityTypeInfo.EdmType;
}
else
{
edmType = new EdmEntityType(baseClrType.Namespace, baseClrType.Name, edmType, baseClrType.IsAbstract, false);
entityTypeInfo = new EntityTypeInfo(_metadataProvider, baseClrType, edmType);
entityTypeInfos.Add(baseClrType, entityTypeInfo);
}
}
}
return(entityTypeInfos);
}
private static PropertyInfo[] GetDependentStructuralProperties(OeEdmModelMetadataProvider metadataProvider,
EntityTypeInfo dependentInfo, PropertyInfo dependentProperty)
{
var dependentProperties = new List <PropertyInfo>();
PropertyInfo[] fkey = metadataProvider.GetForeignKey(dependentProperty);
if (fkey == null)
{
foreach (PropertyInfo propertyInfo in metadataProvider.GetProperties(dependentInfo.ClrType))
{
fkey = metadataProvider.GetForeignKey(propertyInfo);
if (fkey != null && fkey.Length == 1 && fkey[0] == dependentProperty)
{
dependentProperties.Add(propertyInfo);
}
}
if (dependentProperties.Count == 0)
{
PropertyInfo clrProperty = dependentInfo.ClrType.GetPropertyIgnoreCase(dependentProperty.Name + "id");
if (clrProperty != null)
{
dependentProperties.Add(clrProperty);
}
}
}
else
{
dependentProperties.AddRange(fkey);
}
PropertyInfo[] dependentPropertyArray = dependentProperties.ToArray();
metadataProvider.SortClrPropertyByOrder(dependentPropertyArray);
return(dependentPropertyArray);
}
public static FKeyInfo Create(OeEdmModelMetadataProvider metadataProvider,
Dictionary <Type, EntityTypeInfo> entityTypes, EntityTypeInfo dependentInfo, PropertyInfo dependentNavigationProperty)
{
Type clrType = Parsers.OeExpressionHelper.GetCollectionItemTypeOrNull(dependentNavigationProperty.PropertyType) ?? dependentNavigationProperty.PropertyType;
if (!entityTypes.TryGetValue(clrType, out EntityTypeInfo principalInfo))
{
return(null);
}
PropertyInfo[] dependentStructuralProperties = GetDependentStructuralProperties(metadataProvider, dependentInfo, dependentNavigationProperty);
PropertyInfo principalNavigationProperty = GetPrincipalNavigationProperty(metadataProvider, principalInfo, dependentInfo, dependentNavigationProperty);
if (dependentStructuralProperties.Length == 0)
{
if (principalNavigationProperty != null)
{
return(null);
}
dependentStructuralProperties = metadataProvider.GetPrincipalToDependentWithoutDependent(dependentNavigationProperty);
if (dependentStructuralProperties == null)
{
throw new InvalidOperationException("not found dependent structural property " + dependentInfo.ClrType.Name + "Id for navigation property " + dependentNavigationProperty.Name);
}
return(new FKeyInfo(principalInfo, null, dependentStructuralProperties, dependentInfo, dependentNavigationProperty));
}
return(new FKeyInfo(dependentInfo, dependentNavigationProperty, dependentStructuralProperties, principalInfo, principalNavigationProperty));
}
public static FKeyInfo Create(OeEdmModelMetadataProvider metadataProvider,
Dictionary <Type, EntityTypeInfo> entityTypes, EntityTypeInfo dependentInfo, PropertyInfo dependentNavigationProperty)
{
Type clrType = Parsers.OeExpressionHelper.GetCollectionItemType(dependentNavigationProperty.PropertyType);
if (clrType == null)
{
clrType = dependentNavigationProperty.PropertyType;
}
if (!entityTypes.TryGetValue(clrType, out EntityTypeInfo principalInfo))
{
return(null);
}
PropertyInfo[] dependentStructuralProperties = GetDependentStructuralProperties(metadataProvider, dependentInfo, dependentNavigationProperty);
PropertyInfo principalNavigationProperty = GetPrincipalNavigationProperty(metadataProvider, principalInfo, dependentInfo, dependentNavigationProperty);
if (dependentStructuralProperties.Length == 0 && principalNavigationProperty != null)
{
return(null);
}
return(new FKeyInfo(dependentInfo, dependentNavigationProperty, dependentStructuralProperties, principalInfo, principalNavigationProperty));
}
private Dictionary <Type, EntityTypeInfo> BuildEntityTypes(IEdmModel[] refModels)
{
var entityTypeInfos = new Dictionary <Type, EntityTypeInfo>();
foreach (Db.OeEntitySetAdapter entitySetAdapter in _dataAdapter.EntitySetAdapters)
{
var baseClrTypes = new Stack <Type>();
Type clrType = entitySetAdapter.EntityType;
do
{
baseClrTypes.Push(clrType);
clrType = clrType.BaseType;
}while (clrType != typeof(Object));
EdmEntityType edmType = null;
foreach (Type baseClrType in baseClrTypes)
{
if (entityTypeInfos.TryGetValue(baseClrType, out EntityTypeInfo entityTypeInfo))
{
edmType = entityTypeInfo.EdmType;
}
else
{
EdmEntityType baseEdmType = GetBaseEdmEntityType(baseClrType);
if (baseEdmType == null)
{
edmType = new EdmEntityType(baseClrType.Namespace, baseClrType.Name, edmType, baseClrType.IsAbstract, false);
entityTypeInfo = new EntityTypeInfo(_metadataProvider, baseClrType, edmType, false, entitySetAdapter.IsDbQuery);
}
else
{
edmType = baseEdmType;
entityTypeInfo = new EntityTypeInfo(_metadataProvider, baseClrType, edmType, true, entitySetAdapter.IsDbQuery);
}
entityTypeInfos.Add(baseClrType, entityTypeInfo);
}
}
}
return(entityTypeInfos);
EdmEntityType GetBaseEdmEntityType(Type clrType)
{
foreach (IEdmModel refModel in refModels)
{
foreach (IEdmSchemaElement element in refModel.SchemaElements)
{
if (element is EdmEntityType edmEntityType &&
String.Compare(edmEntityType.Name, clrType.Name, StringComparison.OrdinalIgnoreCase) == 0 &&
String.Compare(edmEntityType.Namespace, clrType.Namespace, StringComparison.OrdinalIgnoreCase) == 0)
{
return(edmEntityType);
}
}
}
return(null);
}
}
public void Build(EntityTypeInfo typeInfo)
{
foreach ((PropertyInfo many, PropertyInfo join) in GetManyToManyInfo(_metadataProvider, typeInfo.ClrType))
{
if (many == null || many.DeclaringType != typeInfo.ClrType)
{
continue;
}
IEdmNavigationProperty joinNavigationProperty = GetJoinNavigationProperty(typeInfo, join.DeclaringType);
if (joinNavigationProperty == null)
{
continue;
}
EntityTypeInfo principalInfo = _entityTypeInfos[join.PropertyType];
EntityTypeInfo dependentInfo = _entityTypeInfos[many.DeclaringType];
var edmDependentInfo = new EdmNavigationPropertyInfo()
{
ContainsTarget = true,
Name = many.Name,
OnDelete = EdmOnDeleteAction.None,
PrincipalProperties = principalInfo.EdmType.DeclaredKey,
Target = principalInfo.EdmType,
TargetMultiplicity = EdmMultiplicity.Many
};
IEdmNavigationProperty edmManyToManyProperty;
if (typeInfo.ClrType.GetProperty(many.Name) == null)
{
IEdmNavigationProperty edmNavigationProperty = EdmNavigationProperty.CreateNavigationProperty(dependentInfo.EdmType, edmDependentInfo);
edmManyToManyProperty = new OeEdmNavigationShadowProperty(edmNavigationProperty, many);
dependentInfo.EdmType.AddProperty(edmManyToManyProperty);
}
else
{
edmManyToManyProperty = dependentInfo.EdmType.AddUnidirectionalNavigation(edmDependentInfo);
}
var targetNavigationProperty = (IEdmNavigationProperty)_entityTypeInfos[join.DeclaringType].EdmType.GetPropertyIgnoreCase(join.Name);
var manyToManyJoinDescription = new ManyToManyJoinDescription(join.DeclaringType, joinNavigationProperty, targetNavigationProperty);
_edmModel.SetAnnotationValue(edmManyToManyProperty, manyToManyJoinDescription);
}
}
private Dictionary <Type, EntityTypeInfo> BuildEntityTypes(IEdmModel[] refModels, Type[] excludedTypes)
{
var entityTypeInfos = new Dictionary <Type, EntityTypeInfo>();
List <Type> typesToExclude = new List <Type>(excludedTypes);
foreach (Db.OeEntitySetAdapter entitySetAdapter in _dataAdapter.EntitySetAdapters)
{
var baseClrTypes = new Stack <Type>();
Type clrType = entitySetAdapter.EntityType;
if (typesToExclude.Contains(clrType))
{
continue;
}
do
{
baseClrTypes.Push(clrType);
clrType = clrType.BaseType !;
}while (!(clrType == typeof(Object) || clrType == typeof(ValueType)));
EdmEntityType?edmType = null;
foreach (Type baseClrType in baseClrTypes)
{
if (entityTypeInfos.TryGetValue(baseClrType, out EntityTypeInfo? entityTypeInfo))
{
edmType = entityTypeInfo.EdmType;
}
else
{
EdmEntityType?baseEdmType = GetBaseEdmEntityType(refModels, baseClrType);
if (baseEdmType == null)
{
edmType = new EdmEntityType(baseClrType.Namespace, baseClrType.Name, edmType, baseClrType.IsAbstract, false);
entityTypeInfo = new EntityTypeInfo(_metadataProvider, baseClrType, edmType, false, entitySetAdapter.IsDbQuery);
}
else
{
edmType = baseEdmType;
entityTypeInfo = new EntityTypeInfo(_metadataProvider, baseClrType, edmType, true, entitySetAdapter.IsDbQuery);
}
entityTypeInfos.Add(baseClrType, entityTypeInfo);
}
}
}
return(entityTypeInfos);
private static IEdmNavigationProperty GetJoinNavigationProperty(EntityTypeInfo typeInfo, Type joinClassType)
{
foreach (PropertyInfo propertyInfo in typeInfo.ClrType.GetProperties())
{
Type itemType = Parsers.OeExpressionHelper.GetCollectionItemType(propertyInfo.PropertyType);
if (itemType == joinClassType)
{
foreach (IEdmNavigationProperty edmNavigationProperty in typeInfo.EdmType.NavigationProperties())
{
if (String.CompareOrdinal(edmNavigationProperty.Name, propertyInfo.Name) == 0)
{
return(edmNavigationProperty);
}
}
}
}
return(null);
}
private static PropertyDescriptor[] GetDependentStructuralProperties(OeEdmModelMetadataProvider metadataProvider,
EntityTypeInfo dependentInfo, PropertyDescriptor dependentProperty)
{
var dependentProperties = new List <PropertyDescriptor>(1);
PropertyDescriptorCollection clrProperties = TypeDescriptor.GetProperties(dependentInfo.ClrType);
PropertyDescriptor fkey = metadataProvider.GetForeignKey(dependentProperty);
if (fkey == null)
{
foreach (PropertyDescriptor propertyDescriptor in clrProperties)
{
fkey = metadataProvider.GetForeignKey(propertyDescriptor);
if (fkey == dependentProperty)
{
dependentProperties.Add(propertyDescriptor);
}
}
if (dependentProperties.Count == 0)
{
PropertyDescriptor clrProperty = clrProperties.Find(dependentProperty.Name + "Id", true);
if (clrProperty != null)
{
dependentProperties.Add(clrProperty);
}
}
}
else
{
dependentProperties.Add(fkey);
}
if (dependentProperties.Count == 1)
{
return(dependentProperties.ToArray());
}
else
{
return(SortClrPropertyByOrder(metadataProvider, dependentProperties).ToArray());
}
}
private FKeyInfo(EntityTypeInfo dependentInfo, PropertyInfo dependentNavigationProperty, PropertyInfo[] dependentStructuralProperties,
EntityTypeInfo principalInfo, PropertyInfo principalNavigationProperty)
{
_dependentInfo = dependentInfo;
_dependentNavigationProperty = dependentNavigationProperty;
_principalInfo = principalInfo;
_dependentStructuralProperties = dependentStructuralProperties;
_dependentMultiplicity = GetEdmMultiplicity(dependentNavigationProperty?.PropertyType, dependentStructuralProperties);
if (principalNavigationProperty == null)
{
_principalMultiplicity = EdmMultiplicity.Unknown;
}
else
{
_principalNavigationProperty = principalNavigationProperty;
_principalMultiplicity = GetEdmMultiplicity(principalNavigationProperty.PropertyType, dependentStructuralProperties);
}
}
public void Build(EntityTypeInfo typeInfo)
{
(PropertyInfo Many, PropertyInfo Join)manyToManyInfo = GetManyToManyInfo(_metadataProvider, typeInfo.ClrType);
if (manyToManyInfo.Many == null)
{
return;
}
IEdmNavigationProperty joinNavigationProperty = GetJoinNavigationProperty(typeInfo, manyToManyInfo.Join.DeclaringType);
if (joinNavigationProperty == null)
{
return;
}
IEdmNavigationProperty targetNavigationProperty = GetTargetNavigationProperty(_entityTypeInfos[manyToManyInfo.Join.DeclaringType], manyToManyInfo.Join.PropertyType);
if (targetNavigationProperty == null)
{
return;
}
EntityTypeInfo principalInfo = _entityTypeInfos[manyToManyInfo.Join.PropertyType];
EntityTypeInfo dependentInfo = _entityTypeInfos[manyToManyInfo.Many.DeclaringType];
var edmDependentInfo = new EdmNavigationPropertyInfo()
{
ContainsTarget = true,
Name = manyToManyInfo.Many.Name,
OnDelete = EdmOnDeleteAction.None,
PrincipalProperties = principalInfo.EdmType.DeclaredKey,
Target = principalInfo.EdmType,
TargetMultiplicity = EdmMultiplicity.Many
};
EdmNavigationProperty edmManyToManyProperty = dependentInfo.EdmType.AddUnidirectionalNavigation(edmDependentInfo);
var manyToManyJoinDescription = new ManyToManyJoinDescription(manyToManyInfo.Join.DeclaringType, joinNavigationProperty, targetNavigationProperty);
_edmModel.SetAnnotationValue(edmManyToManyProperty, manyToManyJoinDescription);
}
public void AddEnumType(Type enumType)
{
_enumTypes.Add(enumType, EntityTypeInfo.CreateEdmEnumType(enumType));
}
