public static EdmProperty Enum(string name, EnumType enumType)
{
Check.NotEmpty(name, "name");
Check.NotNull(enumType, "enumType");
return CreateProperty(name, enumType);
}
internal virtual bool TryGetEnumMember(EnumType type, String memberName, bool ignoreCase, out EnumMember outMember)
{
DebugCheck.NotNull(type);
Check.NotEmpty(memberName, "memberName");
outMember = null;
return type.Members.TryGetValue(memberName, ignoreCase, out outMember);
}
static Converter()
{
Debug.Assert(Enum.GetUnderlyingType(typeof(ConcurrencyMode)) == typeof(int), "Please update underlying type below accordingly.");
// Create the enum types that we will need
var concurrencyModeType = new EnumType(
EdmProviderManifest.ConcurrencyModeFacetName,
EdmConstants.EdmNamespace,
underlyingType: PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32),
isFlags: false,
dataSpace: DataSpace.CSpace);
foreach (var name in Enum.GetNames(typeof(ConcurrencyMode)))
{
concurrencyModeType.AddMember(
new EnumMember(
name,
(int)Enum.Parse(typeof(ConcurrencyMode), name, false)));
}
Debug.Assert(
Enum.GetUnderlyingType(typeof(StoreGeneratedPattern)) == typeof(int), "Please update underlying type below accordingly.");
var storeGeneratedPatternType = new EnumType(
EdmProviderManifest.StoreGeneratedPatternFacetName,
EdmConstants.EdmNamespace,
underlyingType: PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32),
isFlags: false,
dataSpace: DataSpace.CSpace);
foreach (var name in Enum.GetNames(typeof(StoreGeneratedPattern)))
{
storeGeneratedPatternType.AddMember(
new EnumMember(
name,
(int)Enum.Parse(typeof(StoreGeneratedPattern), name, false)));
}
// Now create the facet description objects
ConcurrencyModeFacet = new FacetDescription(
EdmProviderManifest.ConcurrencyModeFacetName,
concurrencyModeType,
null,
null,
ConcurrencyMode.None);
StoreGeneratedPatternFacet = new FacetDescription(
EdmProviderManifest.StoreGeneratedPatternFacetName,
storeGeneratedPatternType,
null,
null,
StoreGeneratedPattern.None);
CollationFacet = new FacetDescription(
DbProviderManifest.CollationFacetName,
MetadataItem.EdmProviderManifest.GetPrimitiveType(PrimitiveTypeKind.String),
null,
null,
string.Empty);
}
public void IsEnumType_returns_true_when_enum_property()
{
var enumType = new EnumType();
var property = EdmProperty.Enum("P", enumType);
Assert.False(property.IsComplexType);
Assert.False(property.IsPrimitiveType);
Assert.True(property.IsEnumType);
}
public void Enum_should_create_enum_property()
{
var enumType = new EnumType();
var property = EdmProperty.CreateEnum("P", enumType);
Assert.NotNull(property);
Assert.NotNull(property.TypeUsage);
Assert.Same(enumType, property.TypeUsage.EdmType);
}
public void Should_be_able_to_get_and_set_clr_type()
{
var enumType = new EnumType();
Assert.Null(enumType.GetClrType());
enumType.SetClrType(typeof(object));
Assert.Equal(typeof(object), enumType.GetClrType());
}
public void GetClrType_returns_CLR_type_annotation_for_EnumType()
{
var enumType = new EnumType();
Assert.Null(((EdmType)enumType).GetClrType());
enumType.Annotations.SetClrType(typeof(Random));
Assert.Same(typeof(Random), ((EdmType)enumType).GetClrType());
}
public void Can_set_and_get_underlying_type()
{
var enumType = new EnumType();
var primitiveType = PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int64);
enumType.UnderlyingType = primitiveType;
Assert.Same(primitiveType, enumType.UnderlyingType);
}
private bool TryCreateEnumType(Type enumType, EnumType cspaceEnumType, out EdmType newOSpaceType)
{
DebugCheck.NotNull(enumType);
Debug.Assert(enumType.IsEnum(), "enum type expected");
DebugCheck.NotNull(cspaceEnumType);
Debug.Assert(Helper.IsEnumType(cspaceEnumType), "Enum type expected");
newOSpaceType = null;
// Check if the OSpace and CSpace enum type match
if (!UnderlyingEnumTypesMatch(enumType, cspaceEnumType)
|| !EnumMembersMatch(enumType, cspaceEnumType))
{
return false;
}
newOSpaceType = new ClrEnumType(enumType, cspaceEnumType.NamespaceName, cspaceEnumType.Name);
LoadedTypes.Add(enumType.FullName, newOSpaceType);
return true;
}
protected override void VisitEdmEnumType(EnumType item)
{
_schemaWriter.WriteEnumTypeElementHeader(item);
base.VisitEdmEnumType(item);
_schemaWriter.WriteEndElement();
}
/// <summary>
/// Converts SchemaEnumType instance to Metadata EnumType.
/// </summary>
/// <param name="somEnumType">SchemaEnumType to be covnerted.</param>
/// <param name="newGlobalItems">Global item objects where newly created Metadata EnumType will be added.</param>
/// <returns></returns>
private static EnumType ConvertToEnumType(Som.SchemaEnumType somEnumType, Dictionary<Som.SchemaElement, GlobalItem> newGlobalItems)
{
Debug.Assert(somEnumType != null, "somEnumType != null");
Debug.Assert(newGlobalItems != null, "newGlobalItems != null");
Debug.Assert(
somEnumType.UnderlyingType is Som.ScalarType,
"At this point the underlying type should have already been validated and should be ScalarType");
var enumUnderlyingType = (Som.ScalarType)somEnumType.UnderlyingType;
// note that enums don't live in SSpace so there is no need to GetDataSpace() for it.
var enumType = new EnumType(
somEnumType.Name,
somEnumType.Namespace,
enumUnderlyingType.Type,
somEnumType.IsFlags,
DataSpace.CSpace);
var clrEnumUnderlyingType = enumUnderlyingType.Type.ClrEquivalentType;
foreach (var somEnumMember in somEnumType.EnumMembers)
{
Debug.Assert(somEnumMember.Value != null, "value must not be null at this point");
var enumMember = new EnumMember(
somEnumMember.Name, Convert.ChangeType(somEnumMember.Value, clrEnumUnderlyingType, CultureInfo.InvariantCulture));
if (somEnumMember.Documentation != null)
{
enumMember.Documentation = ConvertToDocumentation(somEnumMember.Documentation);
}
AddOtherContent(somEnumMember, enumMember);
enumType.AddMember(enumMember);
}
if (somEnumType.Documentation != null)
{
enumType.Documentation = ConvertToDocumentation(somEnumType.Documentation);
}
AddOtherContent(somEnumType, enumType);
newGlobalItems.Add(somEnumType, enumType);
return enumType;
}
public bool TryGetClrType(EnumType objectSpaceType, out Type clrType)
{
return(TryGetClrType((EdmType)objectSpaceType, out clrType));
}
public static EnumType Create(
string name,
string namespaceName,
PrimitiveType underlyingType,
bool isFlags,
IEnumerable<EnumMember> members,
IEnumerable<MetadataProperty> metadataProperties)
{
Check.NotEmpty(name, "name");
Check.NotEmpty(namespaceName, "namespaceName");
Check.NotNull(underlyingType, "underlyingType");
if (!Helper.IsSupportedEnumUnderlyingType(underlyingType.PrimitiveTypeKind))
{
throw new ArgumentException(Strings.InvalidEnumUnderlyingType, "underlyingType");
}
var instance = new EnumType(name, namespaceName, underlyingType, isFlags, DataSpace.CSpace);
if (members != null)
{
foreach (var member in members)
{
if (!Helper.IsEnumMemberValueInRange(
underlyingType.PrimitiveTypeKind, Convert.ToInt64(member.Value, CultureInfo.InvariantCulture)))
{
throw new ArgumentException(
Strings.EnumMemberValueOutOfItsUnderylingTypeRange(
member.Value, member.Name, underlyingType.Name),
"members");
}
instance.AddMember(member);
}
}
if (metadataProperties != null)
{
instance.AddMetadataProperties(metadataProperties.ToList());
}
instance.SetReadOnly();
return instance;
}
public virtual Type GetClrType(EnumType item)
{
return _objectItemCollection.GetClrType(item);
}
public void IsUnderlyingPrimitiveType_returns_true_when_underlying_primitive_property()
{
var primitiveType = PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32);
var property = EdmProperty.CreatePrimitive("P", primitiveType);
Assert.True(property.IsUnderlyingPrimitiveType);
var enumType = new EnumType();
property = EdmProperty.CreateEnum("P", enumType);
Assert.True(property.IsUnderlyingPrimitiveType);
}
public void UnderlyingPrimitiveType_returns_type_when_underlying_primitive_property()
{
var primitiveType = PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32);
var property = EdmProperty.CreatePrimitive("P", primitiveType);
Assert.Same(primitiveType, property.UnderlyingPrimitiveType);
var enumType = new EnumType();
property = EdmProperty.CreateEnum("P", enumType);
Assert.Same(primitiveType, property.UnderlyingPrimitiveType);
var complexType = new ComplexType();
property = EdmProperty.CreateComplex("P", complexType);
Assert.Null(property.UnderlyingPrimitiveType);
}
/// <summary>
/// Removes an enumeration type from the model.
/// </summary>
/// <param name="item">The EnumType instance to be removed.</param>
public void RemoveItem(EnumType item)
{
Check.NotNull(item, "item");
_enumTypes.Remove(item);
}
/// <summary>
/// Adds an enumeration type to the model.
/// </summary>
/// <param name="item">The EnumType instance to be added.</param>
public void AddItem(EnumType item)
{
Check.NotNull(item, "item");
ValidateSpace(item);
_enumTypes.Add(item);
}
protected override void Visit(EnumType enumType)
{
int index;
if (!AddObjectToSeenListAndHashBuilder(enumType, out index))
{
return;
}
AddObjectStartDumpToHashBuilder(enumType, index);
AddObjectContentToHashBuilder(enumType.Identity);
Visit(enumType.UnderlyingType);
base.Visit(enumType);
AddObjectEndDumpToHashBuilder();
}
protected override void VisitEdmEnumType(EnumType item)
{
_schemaWriter.WriteEnumTypeElementHeader(item);
base.VisitEdmEnumType(item);
_schemaWriter.WriteEndElement();
}
public void TranslateColumnMap_returns_correct_columntypes_and_nullablecolumns_for_entity_types()
{
var metadataWorkspaceMock = new Mock<MetadataWorkspace>();
metadataWorkspaceMock.Setup(m => m.GetQueryCacheManager()).Returns(QueryCacheManager.Create());
var cSpaceEntityType = new EntityType(typeof(ManyTypesEntity).Name, "N", DataSpace.CSpace);
cSpaceEntityType.AddMember(
new EdmProperty("P1Bool",
TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Boolean), new FacetValues { Nullable = false })));
cSpaceEntityType.AddMember(
new EdmProperty("P2NullableBool",
TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Boolean), new FacetValues { Nullable = true })));
cSpaceEntityType.AddMember(
new EdmProperty("P3ByteArray",
TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Binary))));
cSpaceEntityType.AddMember(
new EdmProperty("P4Timespan",
TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Time), new FacetValues { Nullable = false })));
cSpaceEntityType.AddMember(
new EdmProperty("P5NullableTimespan",
TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Time), new FacetValues { Nullable = true })));
var enumType = new EnumType(
"DayOfWeek", "N", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32), false, DataSpace.CSpace);
cSpaceEntityType.AddMember(
new EdmProperty("P6Enum", TypeUsage.Create(enumType, new FacetValues { Nullable = false })));
cSpaceEntityType.AddMember(
new EdmProperty("P7NullableEnum", TypeUsage.Create(enumType, new FacetValues { Nullable = true })));
var entityTypeUsage = TypeUsage.Create(cSpaceEntityType);
cSpaceEntityType.AddMember(
new EdmProperty("P8Geography",
TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Geography))));
var oSpaceTypeFactory = new CodeFirstOSpaceTypeFactory();
var oSpaceEntityType = oSpaceTypeFactory.TryCreateType(typeof(ManyTypesEntity), cSpaceEntityType);
oSpaceTypeFactory.CspaceToOspace.Add(enumType, oSpaceTypeFactory.TryCreateType(typeof(DayOfWeek), enumType));
foreach (var resolve in oSpaceTypeFactory.ReferenceResolutions)
{
resolve();
}
var scalarMaps = new List<ScalarColumnMap>();
foreach (var edmProperty in cSpaceEntityType.Properties)
{
scalarMaps.Add(new ScalarColumnMap(edmProperty.TypeUsage, edmProperty.Name, 0, scalarMaps.Count));
}
var entityMap = new EntityColumnMap(
entityTypeUsage, "E", scalarMaps.ToArray(),
new SimpleEntityIdentity(null, new SimpleColumnMap[] { scalarMaps[0] }));
var collectionMap = new SimpleCollectionColumnMap(
entityTypeUsage, "MockCollectionType", entityMap, null, null);
metadataWorkspaceMock.Setup(m => m.GetItem<EdmType>(It.IsAny<string>(), DataSpace.OSpace))
.Returns(oSpaceEntityType);
var factory =
new Translator().TranslateColumnMap<object>(
collectionMap, metadataWorkspaceMock.Object, new SpanIndex(), MergeOption.NoTracking, streaming: false, valueLayer: false);
Assert.NotNull(factory);
Assert.Equal(
new[] { typeof(bool), typeof(bool), typeof(byte[]), typeof(TimeSpan), typeof(TimeSpan), typeof(int), typeof(int), typeof(DbGeography) },
factory.ColumnTypes);
// The first column is nullable as it's part of the key
Assert.Equal(new[] { true, true, true, false, true, false, true, true }, factory.NullableColumns);
}
private bool UnderlyingEnumTypesMatch(Type enumType, EnumType cspaceEnumType)
{
DebugCheck.NotNull(enumType);
Debug.Assert(enumType.IsEnum(), "expected enum OSpace type");
DebugCheck.NotNull(cspaceEnumType);
Debug.Assert(Helper.IsEnumType(cspaceEnumType), "Enum type expected");
// Note that TryGetPrimitiveType() will return false not only for types that are not primitive
// but also for CLR primitive types that are valid underlying enum types in CLR but are not
// a valid Edm primitive types (e.g. ulong)
PrimitiveType underlyingEnumType;
if (!ClrProviderManifest.Instance.TryGetPrimitiveType(enumType.GetEnumUnderlyingType(), out underlyingEnumType))
{
LogLoadMessage(
Strings.Validator_UnsupportedEnumUnderlyingType(enumType.GetEnumUnderlyingType().FullName),
cspaceEnumType);
return false;
}
else if (underlyingEnumType.PrimitiveTypeKind
!= cspaceEnumType.UnderlyingType.PrimitiveTypeKind)
{
LogLoadMessage(
Strings.Validator_OSpace_Convention_NonMatchingUnderlyingTypes, cspaceEnumType);
return false;
}
return true;
}
public void EnumType_returns_type_when_enum_property()
{
var enumType = new EnumType();
var property = EdmProperty.CreateEnum("P", enumType);
Assert.Same(enumType, property.EnumType);
}
/// <summary>
/// Removes an enumeration type from the model.
/// </summary>
/// <param name="item">The EnumType instance to be removed.</param>
public void RemoveItem(EnumType item)
{
Check.NotNull(item, "item");
_enumTypes.Remove(item);
}
public static EnumType AddEnumType(this EdmModel model, string name, string modelNamespace = null)
{
DebugCheck.NotNull(model);
DebugCheck.NotEmpty(name);
var enumType
= new EnumType(
name,
modelNamespace ?? DefaultModelNamespace,
PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32),
false,
DataSpace.CSpace);
model.AddItem(enumType);
return enumType;
}
internal void WriteEnumTypeElementHeader(EnumType enumType)
{
DebugCheck.NotNull(enumType);
_xmlWriter.WriteStartElement(XmlConstants.EnumType);
_xmlWriter.WriteAttributeString(XmlConstants.Name, enumType.Name);
_xmlWriter.WriteAttributeString(
XmlConstants.IsFlags, GetLowerCaseStringFromBoolValue(enumType.IsFlags));
if (enumType.UnderlyingType != null)
{
_xmlWriter.WriteAttributeString(
XmlConstants.UnderlyingType,
enumType.UnderlyingType.PrimitiveTypeKind.ToString());
}
}
private bool EnumMembersMatch(Type enumType, EnumType cspaceEnumType)
{
DebugCheck.NotNull(enumType);
Debug.Assert(enumType.IsEnum(), "expected enum OSpace type");
DebugCheck.NotNull(cspaceEnumType);
Debug.Assert(Helper.IsEnumType(cspaceEnumType), "Enum type expected");
Debug.Assert(
cspaceEnumType.UnderlyingType.ClrEquivalentType == enumType.GetEnumUnderlyingType(),
"underlying types should have already been checked");
var enumUnderlyingType = enumType.GetEnumUnderlyingType();
var cspaceSortedEnumMemberEnumerator = cspaceEnumType.Members.OrderBy(m => m.Name).GetEnumerator();
var ospaceSortedEnumMemberNamesEnumerator = enumType.GetEnumNames().OrderBy(n => n).GetEnumerator();
// no checks required if edm enum type does not have any members
if (!cspaceSortedEnumMemberEnumerator.MoveNext())
{
return true;
}
while (ospaceSortedEnumMemberNamesEnumerator.MoveNext())
{
if (cspaceSortedEnumMemberEnumerator.Current.Name == ospaceSortedEnumMemberNamesEnumerator.Current
&&
cspaceSortedEnumMemberEnumerator.Current.Value.Equals(
Convert.ChangeType(
Enum.Parse(enumType, ospaceSortedEnumMemberNamesEnumerator.Current), enumUnderlyingType,
CultureInfo.InvariantCulture)))
{
if (!cspaceSortedEnumMemberEnumerator.MoveNext())
{
return true;
}
}
}
LogLoadMessage(
Strings.Mapping_Enum_OCMapping_MemberMismatch(
enumType.FullName,
cspaceSortedEnumMemberEnumerator.Current.Name,
cspaceSortedEnumMemberEnumerator.Current.Value,
cspaceEnumType.FullName), cspaceEnumType);
return false;
}
private void AddReference(Dictionary<string, EnumLookupTable> enumSet, EnumType enumType, TableReference reference)
{
EnumLookupTable entry;
if (enumSet.TryGetValue(enumType.FullName, out entry))
{
entry.References.Add(reference);
} else
{
var enumInfo = new EnumLookupTable(enumType, reference);
enumSet.Add(enumType.FullName, enumInfo);
}
}
protected virtual void Visit(EnumType enumType)
{
foreach (var member in enumType.Members)
{
Visit(member);
}
}
public EnumLookupTable(EnumType enumType, TableReference reference)
{
EnumType = enumType;
Rows = new List<EnumLookupTableRow>();
if (enumType.IsFlags)
{
foreach (var enumField in enumType.Members)
{
var enumValue = enumField.Value;
switch (enumType.UnderlyingType.PrimitiveTypeKind)
{
case PrimitiveTypeKind.Byte:
case PrimitiveTypeKind.SByte:
if (((byte)enumValue & ((byte)enumValue - 1)) != 0)
{
// composed enum value
continue;
}
break;
case PrimitiveTypeKind.Int16:
if (((short)enumValue & ((short)enumValue - 1)) != 0)
{
// composed enum value
continue;
}
break;
case PrimitiveTypeKind.Int32:
if (((int)enumValue & ((int)enumValue - 1)) != 0)
{
// composed enum value
continue;
}
break;
case PrimitiveTypeKind.Int64:
if (((long)enumValue & ((long)enumValue - 1)) != 0)
{
// composed enum value
continue;
}
break;
default:
throw new ArgumentOutOfRangeException();
}
var name = enumField.Name.SeparateWords();
Rows.Add(new EnumLookupTableRow
{
Id = enumValue.ToString(),
Name = name
});
}
} else
{
foreach (var enumField in enumType.Members)
{
var enumValue = enumField.Value.ToString();
var name = enumField.Name.SeparateWords();
Rows.Add(new EnumLookupTableRow
{
Id = enumValue,
Name = name
});
}
}
References = new List<TableReference>
{
reference
};
}
public void Can_add_remove_enum_type()
{
var model = new EdmModel(DataSpace.SSpace);
var enumType = new EnumType { DataSpace = DataSpace.SSpace };
model.AddItem(enumType);
Assert.True(model.EnumTypes.Contains(enumType));
Assert.True(model.NamespaceItems.Contains(enumType));
model.RemoveItem(enumType);
Assert.False(model.EnumTypes.Contains(enumType));
Assert.False(model.NamespaceItems.Contains(enumType));
}
/// <summary>
/// Creates new enum OSpace type built based on CLR <paramref name="enumType"/> and <paramref name="cspaceEnumType"/>
/// </summary>
/// <param name="enumType">CLR type to create OSpace type from.</param>
/// <param name="cspaceEnumType">CSpace type used to get namespace and name for the newly created OSpace type.</param>
/// <param name="newOSpaceType">
/// New enum OSpace type built based on CLR <paramref name="enumType"/> and <paramref name="cspaceEnumType"/> or null
/// if the type could not be built.
/// </param>
/// <returns><c>true</c> if the type was built successfully.<c>false</c> otherwise.</returns>
private bool TryCreateEnumType(Type enumType, EnumType cspaceEnumType, out EdmType newOSpaceType)
{
Debug.Assert(enumType != null, "enumType != null");
Debug.Assert(enumType.IsEnum, "enum type expected");
Debug.Assert(cspaceEnumType != null, "cspaceEnumType != null");
Debug.Assert(Helper.IsEnumType(cspaceEnumType), "Enum type expected");
Debug.Assert(TypesMatchByConvention(enumType, cspaceEnumType), "The types passed as parameters don't match by convention.");
newOSpaceType = null;
// Check if the OSpace and CSpace enum type match
if (!UnderlyingEnumTypesMatch(enumType, cspaceEnumType)
|| !EnumMembersMatch(enumType, cspaceEnumType))
{
return false;
}
newOSpaceType = new ClrEnumType(enumType, cspaceEnumType.NamespaceName, cspaceEnumType.Name);
SessionData.TypesInLoading.Add(enumType.FullName, newOSpaceType);
return true;
}
/// <summary>
/// Validates whether CSpace enum type and OSpace enum type match.
/// </summary>
/// <param name="edmEnumType">CSpace enum type.</param>
/// <param name="objectEnumType">OSpace enum type.</param>
private static void ValidateEnumTypeMapping(EnumType edmEnumType, EnumType objectEnumType)
{
Debug.Assert(edmEnumType != null, "edmEnumType != null");
Debug.Assert(Helper.IsPrimitiveType(edmEnumType.UnderlyingType));
Debug.Assert(Helper.IsSupportedEnumUnderlyingType(edmEnumType.UnderlyingType.PrimitiveTypeKind));
Debug.Assert(objectEnumType != null, "objectEnumType != null");
Debug.Assert(Helper.IsPrimitiveType(objectEnumType.UnderlyingType));
Debug.Assert(Helper.IsSupportedEnumUnderlyingType(objectEnumType.UnderlyingType.PrimitiveTypeKind));
if (edmEnumType.UnderlyingType.PrimitiveTypeKind
!= objectEnumType.UnderlyingType.PrimitiveTypeKind)
{
throw new MappingException(
Strings.Mapping_Enum_OCMapping_UnderlyingTypesMismatch(
edmEnumType.UnderlyingType.Name,
edmEnumType.FullName,
objectEnumType.UnderlyingType.Name,
objectEnumType.FullName));
}
// EnumMember.Value is just a number so sorting by value is faster than by the name.
// The drawback is that there can be multiple members with the same value. To break
// the tie we need to sort by name after sorting by value.
var edmEnumTypeMembersSortedEnumerator =
edmEnumType.Members.OrderBy(m => Convert.ToInt64(m.Value, CultureInfo.InvariantCulture)).ThenBy(m => m.Name).GetEnumerator();
var objectEnumTypeMembersSortedEnumerator =
objectEnumType.Members.OrderBy(m => Convert.ToInt64(m.Value, CultureInfo.InvariantCulture)).ThenBy(m => m.Name).
GetEnumerator();
if (edmEnumTypeMembersSortedEnumerator.MoveNext())
{
while (objectEnumTypeMembersSortedEnumerator.MoveNext())
{
if (edmEnumTypeMembersSortedEnumerator.Current.Name == objectEnumTypeMembersSortedEnumerator.Current.Name
&&
edmEnumTypeMembersSortedEnumerator.Current.Value.Equals(objectEnumTypeMembersSortedEnumerator.Current.Value))
{
if (!edmEnumTypeMembersSortedEnumerator.MoveNext())
{
return;
}
}
}
throw new MappingException(
Strings.Mapping_Enum_OCMapping_MemberMismatch(
objectEnumType.FullName,
edmEnumTypeMembersSortedEnumerator.Current.Name,
edmEnumTypeMembersSortedEnumerator.Current.Value,
edmEnumType.FullName));
}
}
public Type GetClrType(EnumType objectSpaceType)
{
return(GetClrType((EdmType)objectSpaceType));
}
