private void PopulateObjectProperties(IEdmStructuredValue edmValue, object clrObject, Type clrObjectType)
{
HashSetInternal <string> strs = new HashSetInternal <string>();
foreach (IEdmPropertyValue propertyValue in edmValue.PropertyValues)
{
PropertyInfo propertyInfo = EdmToClrConverter.FindProperty(clrObjectType, propertyValue.Name);
if (propertyInfo == null)
{
continue;
}
if (!strs.Contains(propertyValue.Name))
{
if (!this.TrySetCollectionProperty(propertyInfo, clrObject, propertyValue))
{
object obj = this.AsClrValue(propertyValue.Value, propertyInfo.PropertyType);
propertyInfo.SetValue(clrObject, obj, null);
}
strs.Add(propertyValue.Name);
}
else
{
throw new InvalidCastException(Strings.EdmToClr_StructuredPropertyDuplicateValue(propertyValue.Name));
}
}
}
private bool TrySetCollectionProperty(PropertyInfo clrProperty, object clrObject, IEdmPropertyValue propertyValue)
{
Type type;
Type propertyType = clrProperty.PropertyType;
if (propertyType.IsGenericType() && propertyType.IsInterface())
{
Type genericTypeDefinition = propertyType.GetGenericTypeDefinition();
bool typeIEnumerableOfT = genericTypeDefinition == EdmToClrConverter.TypeIEnumerableOfT;
if (typeIEnumerableOfT || genericTypeDefinition == EdmToClrConverter.TypeICollectionOfT || genericTypeDefinition == EdmToClrConverter.TypeIListOfT)
{
object value = clrProperty.GetValue(clrObject, null);
Type type1 = propertyType.GetGenericArguments().Single <Type>();
if (value != null)
{
if (!typeIEnumerableOfT)
{
type = value.GetType();
}
else
{
throw new InvalidCastException(Strings.EdmToClr_IEnumerableOfTPropertyAlreadyHasValue(clrProperty.Name, clrProperty.DeclaringType.FullName));
}
}
else
{
Type[] typeArray = new Type[1];
typeArray[0] = type1;
type = EdmToClrConverter.TypeListOfT.MakeGenericType(typeArray);
value = Activator.CreateInstance(type);
clrProperty.SetValue(clrObject, value, null);
}
MethodInfo methodInfo = EdmToClrConverter.FindICollectionOfElementTypeAddMethod(type, type1);
foreach (object obj in this.AsIEnumerable(propertyValue.Value, type1))
{
try
{
object[] objArray = new object[1];
objArray[0] = obj;
methodInfo.Invoke(value, objArray);
}
catch (TargetInvocationException targetInvocationException1)
{
TargetInvocationException targetInvocationException = targetInvocationException1;
if (targetInvocationException.InnerException == null || targetInvocationException.InnerException as InvalidCastException == null)
{
throw;
}
else
{
throw targetInvocationException.InnerException;
}
}
}
return(true);
}
}
return(false);
}
internal static char AsClrChar(IEdmValue edmValue)
{
return(Convert.ToChar(EdmToClrConverter.AsClrInt64(edmValue)));
}
internal static byte AsClrByte(IEdmValue edmValue)
{
return((byte)EdmToClrConverter.AsClrInt64(edmValue));
}
private static bool TryConvertAsPrimitiveType(TypeCode typeCode, IEdmValue edmValue, out object clrValue)
{
TypeCode typeCode1 = typeCode;
switch (typeCode1)
{
case TypeCode.Boolean:
{
clrValue = EdmToClrConverter.AsClrBoolean(edmValue);
return(true);
}
case TypeCode.Char:
{
clrValue = EdmToClrConverter.AsClrChar(edmValue);
return(true);
}
case TypeCode.SByte:
{
clrValue = (sbyte)EdmToClrConverter.AsClrInt64(edmValue);
return(true);
}
case TypeCode.Byte:
{
clrValue = EdmToClrConverter.AsClrByte(edmValue);
return(true);
}
case TypeCode.Int16:
{
clrValue = EdmToClrConverter.AsClrInt16(edmValue);
return(true);
}
case TypeCode.UInt16:
{
clrValue = (ushort)EdmToClrConverter.AsClrInt64(edmValue);
return(true);
}
case TypeCode.Int32:
{
clrValue = EdmToClrConverter.AsClrInt32(edmValue);
return(true);
}
case TypeCode.UInt32:
{
clrValue = (uint)EdmToClrConverter.AsClrInt64(edmValue);
return(true);
}
case TypeCode.Int64:
{
clrValue = EdmToClrConverter.AsClrInt64(edmValue);
return(true);
}
case TypeCode.UInt64:
{
clrValue = (ulong)EdmToClrConverter.AsClrInt64(edmValue);
return(true);
}
case TypeCode.Single:
{
clrValue = EdmToClrConverter.AsClrSingle(edmValue);
return(true);
}
case TypeCode.Double:
{
clrValue = EdmToClrConverter.AsClrDouble(edmValue);
return(true);
}
case TypeCode.Decimal:
{
clrValue = EdmToClrConverter.AsClrDecimal(edmValue);
return(true);
}
case TypeCode.DateTime:
{
clrValue = EdmToClrConverter.AsClrDateTime(edmValue);
return(true);
}
case TypeCode.Object | TypeCode.DateTime:
{
clrValue = null;
return(false);
}
case TypeCode.String:
{
clrValue = EdmToClrConverter.AsClrString(edmValue);
return(true);
}
default:
{
clrValue = null;
return(false);
}
}
}
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);
}
}
}
}
internal static float AsClrSingle(IEdmValue edmValue)
{
return((float)EdmToClrConverter.AsClrDouble(edmValue));
}
private object AsClrObject(IEdmValue edmValue, Type clrObjectType)
{
object obj = null;
bool flag;
EdmUtil.CheckArgumentNull <IEdmValue>(edmValue, "edmValue");
EdmUtil.CheckArgumentNull <Type>(clrObjectType, "clrObjectType");
if (edmValue as IEdmNullValue == null)
{
IEdmStructuredValue edmStructuredValue = edmValue as IEdmStructuredValue;
if (edmStructuredValue != null)
{
if (!this.convertedObjects.TryGetValue(edmStructuredValue, out obj))
{
if (clrObjectType.IsClass())
{
if (this.tryCreateObjectInstanceDelegate == null || !this.tryCreateObjectInstanceDelegate(edmStructuredValue, clrObjectType, this, out obj, out flag))
{
obj = Activator.CreateInstance(clrObjectType);
flag = false;
}
else
{
if (obj != null)
{
Type type = obj.GetType();
if (clrObjectType.IsAssignableFrom(type))
{
clrObjectType = type;
}
else
{
throw new InvalidCastException(Strings.EdmToClr_TryCreateObjectInstanceReturnedWrongObject(type.FullName, clrObjectType.FullName));
}
}
}
this.convertedObjects[edmStructuredValue] = obj;
if (!flag && obj != null)
{
this.PopulateObjectProperties(edmStructuredValue, obj, clrObjectType);
}
return(obj);
}
else
{
throw new InvalidCastException(Strings.EdmToClr_StructuredValueMappedToNonClass);
}
}
else
{
return(obj);
}
}
else
{
if (edmValue as IEdmCollectionValue == null)
{
throw new InvalidCastException(Strings.EdmToClr_CannotConvertEdmValueToClrType(EdmToClrConverter.GetEdmValueInterfaceName(edmValue), clrObjectType.FullName));
}
else
{
throw new InvalidCastException(Strings.EdmToClr_CannotConvertEdmCollectionValueToClrType(clrObjectType.FullName));
}
}
}
else
{
return(null);
}
}
internal static int AsClrInt32(IEdmValue edmValue)
{
return((int)EdmToClrConverter.AsClrInt64(edmValue));
}
internal static short AsClrInt16(IEdmValue edmValue)
{
return((short)EdmToClrConverter.AsClrInt64(edmValue));
}
