private object AsClrValue(IEdmValue edmValue, Type clrType, bool convertEnumValues) { TypeCode typeCode = PlatformHelper.GetTypeCode(clrType); if (typeCode == TypeCode.Object) { // First look for nullable primitives, then DateTime, DateTimeOffset and byte[] which don't have dedicated TypeCode, so they are processed here. if (clrType.IsGenericType() && clrType.GetGenericTypeDefinition() == TypeNullableOfT) { if (edmValue is IEdmNullValue) { return(null); } return(this.AsClrValue(edmValue, clrType.GetGenericArguments().Single())); } else if (clrType == typeof(DateTime)) { return(AsClrDateTime(edmValue)); } else if (clrType == typeof(DateTimeOffset)) { return(AsClrDateTimeOffset(edmValue)); } else if (clrType == typeof(TimeSpan)) { return(AsClrTime(edmValue)); } else if (clrType == typeof(byte[])) { return(AsClrByteArray(edmValue)); } else if (clrType.IsGenericType() && clrType.IsInterface() && (clrType.GetGenericTypeDefinition() == TypeICollectionOfT || clrType.GetGenericTypeDefinition() == TypeIListOfT || clrType.GetGenericTypeDefinition() == TypeIEnumerableOfT)) { // We are asked to produce an IEnumerable<T>, perform an equivalent of this.AsIEnumerable(edmValue, typeof(T)).Cast<T>().ToList() return(this.AsListOfT(edmValue, clrType)); } else { return(this.AsClrObject(edmValue, clrType)); } } else { // A CLR enum type will report some primitive type code, so we get here. // If this is the case and the value is of an edm enumeration type, we want to unbox the primitive type value, // otherwise assume the edm value is primitive and let it fail inside the converter if it's not. bool isEnum = clrType.IsEnum(); if (isEnum) { IEdmEnumValue edmEnumValue = edmValue as IEdmEnumValue; if (edmEnumValue != null) { edmValue = edmEnumValue.Value; } } object clrValue; if (!TryConvertAsPrimitiveType(PlatformHelper.GetTypeCode(clrType), edmValue, out clrValue)) { throw new InvalidCastException(Strings.EdmToClr_UnsupportedTypeCode(typeCode)); } // In case of enums, because the converter returns a primitive type value we want to convert it to the CLR enum type. return((isEnum && convertEnumValues) ? this.GetEnumValue(clrValue, clrType) : clrValue); } }
private object AsClrValue(IEdmValue edmValue, Type clrType, bool convertEnumValues) { object obj = null; TypeCode typeCode = PlatformHelper.GetTypeCode(clrType); if (typeCode != TypeCode.Object) { bool flag = clrType.IsEnum(); if (flag) { IEdmEnumValue edmEnumValue = edmValue as IEdmEnumValue; if (edmEnumValue != null) { edmValue = edmEnumValue.Value; } } if (EdmToClrConverter.TryConvertAsPrimitiveType(PlatformHelper.GetTypeCode(clrType), edmValue, out obj)) { if (!flag || !convertEnumValues) { return(obj); } else { return(this.GetEnumValue(obj, clrType)); } } else { throw new InvalidCastException(Strings.EdmToClr_UnsupportedTypeCode(typeCode)); } } else { if (!clrType.IsGenericType() || !(clrType.GetGenericTypeDefinition() == EdmToClrConverter.TypeNullableOfT)) { if (clrType != typeof(DateTime)) { if (clrType != typeof(DateTimeOffset)) { if (clrType != typeof(TimeSpan)) { if (clrType != typeof(byte[])) { if (!clrType.IsGenericType() || !clrType.IsInterface() || !(clrType.GetGenericTypeDefinition() == EdmToClrConverter.TypeICollectionOfT) && !(clrType.GetGenericTypeDefinition() == EdmToClrConverter.TypeIListOfT) && !(clrType.GetGenericTypeDefinition() == EdmToClrConverter.TypeIEnumerableOfT)) { return(this.AsClrObject(edmValue, clrType)); } else { return(this.AsListOfT(edmValue, clrType)); } } else { return(EdmToClrConverter.AsClrByteArray(edmValue)); } } else { return(EdmToClrConverter.AsClrTime(edmValue)); } } else { return(EdmToClrConverter.AsClrDateTimeOffset(edmValue)); } } else { return(EdmToClrConverter.AsClrDateTime(edmValue)); } } else { if (edmValue as IEdmNullValue == null) { return(this.AsClrValue(edmValue, clrType.GetGenericArguments().Single <Type>())); } else { return(null); } } } }