internal static void ApplyProperty(ODataProperty property, IEdmStructuredTypeReference resourceType, object resource,
ODataDeserializerProvider deserializerProvider, ODataDeserializerContext readContext)
{
IEdmProperty edmProperty = resourceType.FindProperty(property.Name);
bool isDynamicProperty = false;
string propertyName = property.Name;
if (edmProperty != null)
{
propertyName = EdmLibHelpers.GetClrPropertyName(edmProperty, readContext.Model);
}
else
{
IEdmStructuredType structuredType = resourceType.StructuredDefinition();
isDynamicProperty = structuredType != null && structuredType.IsOpen;
}
// dynamic properties have null values
IEdmTypeReference propertyType = edmProperty != null ? edmProperty.Type : null;
EdmTypeKind propertyKind;
object value = ConvertValue(property.Value, ref propertyType, deserializerProvider, readContext,
out propertyKind);
if (isDynamicProperty)
{
SetDynamicProperty(resource, resourceType, propertyKind, propertyName, value, propertyType,
readContext);
}
else
{
SetDeclaredProperty(resource, propertyKind, propertyName, value, edmProperty, readContext);
}
}
/// <inheritdoc />
public override object Read(
ODataMessageReader messageReader,
Type type,
ODataDeserializerContext readContext)
{
//return enumDeserializer.Read(messageReader, type, readContext);
return base.Read(messageReader, type, readContext);
}
internal static void SetDynamicProperty(object resource, IEdmStructuredTypeReference resourceType,
EdmTypeKind propertyKind, string propertyName, object propertyValue, IEdmTypeReference propertyType,
ODataDeserializerContext readContext)
{
if (propertyKind == EdmTypeKind.Collection && propertyValue.GetType() != typeof(EdmComplexObjectCollection)
&& propertyValue.GetType() != typeof(EdmEnumObjectCollection))
{
SetDynamicCollectionProperty(resource, propertyName, propertyValue, propertyType.AsCollection(),
resourceType.StructuredDefinition(), readContext);
}
else
{
SetDynamicProperty(resource, propertyName, propertyValue, resourceType.StructuredDefinition(),
readContext);
}
}
/// <inheritdoc />
public override object ReadInline(
object item,
IEdmTypeReference edmType,
ODataDeserializerContext readContext)
{
//var result = enumDeserializer.ReadInline(item, edmType, readContext);
//var edmEnumObject = result as EdmEnumObject;
//if (edmEnumObject != null)
//{
// return edmEnumObject.Value;
//}
//return result;
return base.ReadInline(item, edmType, readContext);
}
internal static void SetDeclaredProperty(object resource, EdmTypeKind propertyKind, string propertyName,
object propertyValue, IEdmProperty edmProperty, ODataDeserializerContext readContext)
{
if (propertyKind == EdmTypeKind.Collection)
{
SetCollectionProperty(resource, edmProperty, propertyValue, propertyName);
}
else
{
if (!readContext.IsUntyped)
{
if (propertyKind == EdmTypeKind.Primitive)
{
propertyValue = EdmPrimitiveHelpers.ConvertPrimitiveValue(propertyValue,
GetPropertyType(resource, propertyName));
}
}
SetProperty(resource, propertyName, propertyValue);
}
}
/// <inheritdoc />
public sealed override object ReadInline(object item, IEdmTypeReference edmType, ODataDeserializerContext readContext)
{
if (item == null)
{
return(null);
}
ODataProperty property = item as ODataProperty;
if (property == null)
{
throw Error.Argument("item", SRResources.ArgumentMustBeOfType, typeof(ODataProperty).Name);
}
return(ReadPrimitive(property, readContext));
}
private static async Task ReadCollectionAsync(IEdmAction action, ODataParameterReader reader, ODataDeserializerContext readContext, ODataDeserializerProvider deserializerProvider, Dictionary <string, object> payload)
{
string parameterName;
IEdmCollectionTypeReference collectionType = GetCollectionParameterType(action, reader, out parameterName);
ODataCollectionValue value = await ODataCollectionDeserializer.ReadCollectionAsync(reader.CreateCollectionReader());
ODataCollectionDeserializer collectionDeserializer = (ODataCollectionDeserializer)deserializerProvider.GetEdmTypeDeserializer(collectionType);
payload[parameterName] = collectionDeserializer.ReadInline(value, collectionType, readContext);
}
internal static void SetDeclaredProperty(object resource, EdmTypeKind propertyKind, string propertyName,
object propertyValue, IEdmProperty edmProperty, ODataDeserializerContext readContext)
{
if (propertyKind == EdmTypeKind.Collection)
{
SetCollectionProperty(resource, edmProperty, propertyValue, propertyName);
}
else
{
if (!readContext.IsUntyped)
{
if (propertyKind == EdmTypeKind.Primitive)
{
propertyValue = EdmPrimitiveHelpers.ConvertPrimitiveValue(propertyValue,
GetPropertyType(resource, propertyName));
}
}
SetProperty(resource, propertyName, propertyValue);
}
}
/// <inheritdoc />
public sealed override object ReadInline(object item, IEdmTypeReference edmType, ODataDeserializerContext readContext)
{
if (item == null)
{
return(null);
}
if (edmType == null)
{
throw Error.ArgumentNull("edmType");
}
if (!edmType.IsCollection())
{
throw new SerializationException(
Error.Format(SRResources.TypeCannotBeDeserialized, edmType.ToTraceString()));
}
IEdmCollectionTypeReference collectionType = edmType.AsCollection();
IEdmTypeReference elementType = collectionType.ElementType();
ODataCollectionValue collection = item as ODataCollectionValue;
if (collection == null)
{
throw Error.Argument("item", SRResources.ArgumentMustBeOfType, typeof(ODataCollectionValue).Name);
}
// Recursion guard to avoid stack overflows
RuntimeHelpers.EnsureSufficientExecutionStack();
IEnumerable result = ReadCollectionValue(collection, elementType, readContext);
if (result != null)
{
if (readContext.IsUntyped && elementType.IsEnum())
{
return(result.ConvertToEdmObject(collectionType));
}
else
{
Type elementClrType = EdmLibHelpers.GetClrType(elementType, readContext.Model);
IEnumerable castedResult = _castMethodInfo.MakeGenericMethod(elementClrType).Invoke(null, new object[] { result }) as IEnumerable;
return(castedResult);
}
}
return(null);
}
internal static void SetInstanceAnnotations(ODataResource oDataResource, IODataInstanceAnnotationContainer instanceAnnotationContainer,
ODataDeserializerProvider deserializerProvider, ODataDeserializerContext readContext)
{
if (oDataResource.InstanceAnnotations != null)
{
foreach (ODataInstanceAnnotation annotation in oDataResource.InstanceAnnotations)
{
AddInstanceAnnotationToContainer(instanceAnnotationContainer, deserializerProvider, readContext, annotation, string.Empty);
}
}
foreach (ODataProperty property in oDataResource.Properties)
{
if (property.InstanceAnnotations != null)
{
foreach (ODataInstanceAnnotation annotation in property.InstanceAnnotations)
{
AddInstanceAnnotationToContainer(instanceAnnotationContainer, deserializerProvider, readContext, annotation, property.Name);
}
}
}
}
private static object ConvertEnumValue(ODataEnumValue enumValue, ref IEdmTypeReference propertyType,
ODataDeserializerProvider deserializerProvider, ODataDeserializerContext readContext)
{
IEdmEnumTypeReference edmEnumType;
if (propertyType == null)
{
// dynamic enum property
Contract.Assert(!String.IsNullOrEmpty(enumValue.TypeName),
"ODataLib should have verified that dynamic enum value has a type name since we provided metadata.");
IEdmModel model = readContext.Model;
IEdmType edmType = model.FindType(enumValue.TypeName);
Contract.Assert(edmType.TypeKind == EdmTypeKind.Enum, "ODataLib should have verified that enum value has a enum resource type.");
edmEnumType = new EdmEnumTypeReference(edmType as IEdmEnumType, isNullable: true);
propertyType = edmEnumType;
}
else
{
edmEnumType = propertyType.AsEnum();
}
ODataEdmTypeDeserializer deserializer = deserializerProvider.GetEdmTypeDeserializer(edmEnumType);
return(deserializer.ReadInline(enumValue, propertyType, readContext));
}
/// <summary>
/// Deserializes the nested properties from <paramref name="resourceWrapper"/> into <paramref name="resource"/>.
/// </summary>
/// <param name="resource">The object into which the nested properties should be read.</param>
/// <param name="resourceWrapper">The resource object containing the nested properties.</param>
/// <param name="structuredType">The type of the resource.</param>
/// <param name="readContext">The deserializer context.</param>
public virtual void ApplyNestedProperties(object resource, ODataResourceWrapper resourceWrapper,
IEdmStructuredTypeReference structuredType, ODataDeserializerContext readContext)
{
if (resourceWrapper == null)
{
throw Error.ArgumentNull("resourceWrapper");
}
foreach (ODataNestedResourceInfoWrapper nestedResourceInfo in resourceWrapper.NestedResourceInfos)
{
ApplyNestedProperty(resource, nestedResourceInfo, structuredType, readContext);
}
}
/// <summary>
/// Deserializes the item into a new object of type corresponding to <paramref name="edmType"/>.
/// </summary>
/// <param name="item">The item to deserialize.</param>
/// <param name="edmType">The EDM type of the object to read into.</param>
/// <param name="readContext">The <see cref="ODataDeserializerContext"/>.</param>
/// <returns>The deserialized object.</returns>
public virtual object ReadInline(object item, IEdmTypeReference edmType, ODataDeserializerContext readContext)
{
throw Error.NotSupported(SRResources.DoesNotSupportReadInLine, GetType().Name);
}
/// <summary>
/// Deserializes the given <paramref name="resourceWrapper"/> under the given <paramref name="readContext"/>.
/// </summary>
/// <param name="resourceWrapper">The OData resource to deserialize.</param>
/// <param name="structuredType">The type of the resource to deserialize.</param>
/// <param name="readContext">The deserializer context.</param>
/// <returns>The deserialized resource.</returns>
public virtual object ReadResource(ODataResourceWrapper resourceWrapper, IEdmStructuredTypeReference structuredType,
ODataDeserializerContext readContext)
{
if (resourceWrapper == null)
{
throw Error.ArgumentNull("resourceWrapper");
}
if (readContext == null)
{
throw Error.ArgumentNull("readContext");
}
if (!String.IsNullOrEmpty(resourceWrapper.Resource.TypeName) && structuredType.FullName() != resourceWrapper.Resource.TypeName)
{
// received a derived type in a base type deserializer. delegate it to the appropriate derived type deserializer.
IEdmModel model = readContext.Model;
if (model == null)
{
throw Error.Argument("readContext", SRResources.ModelMissingFromReadContext);
}
IEdmStructuredType actualType = model.FindType(resourceWrapper.Resource.TypeName) as IEdmStructuredType;
if (actualType == null)
{
throw new ODataException(Error.Format(SRResources.ResourceTypeNotInModel, resourceWrapper.Resource.TypeName));
}
if (actualType.IsAbstract)
{
string message = Error.Format(SRResources.CannotInstantiateAbstractResourceType, resourceWrapper.Resource.TypeName);
throw new ODataException(message);
}
IEdmTypeReference actualStructuredType;
IEdmEntityType actualEntityType = actualType as IEdmEntityType;
if (actualEntityType != null)
{
actualStructuredType = new EdmEntityTypeReference(actualEntityType, isNullable: false);
}
else
{
actualStructuredType = new EdmComplexTypeReference(actualType as IEdmComplexType, isNullable: false);
}
ODataEdmTypeDeserializer deserializer = DeserializerProvider.GetEdmTypeDeserializer(actualStructuredType);
if (deserializer == null)
{
throw new SerializationException(
Error.Format(SRResources.TypeCannotBeDeserialized, actualEntityType.FullName()));
}
object resource = deserializer.ReadInline(resourceWrapper, actualStructuredType, readContext);
EdmStructuredObject structuredObject = resource as EdmStructuredObject;
if (structuredObject != null)
{
structuredObject.ExpectedEdmType = structuredType.StructuredDefinition();
}
return(resource);
}
else
{
object resource = CreateResourceInstance(structuredType, readContext);
ApplyResourceProperties(resource, resourceWrapper, structuredType, readContext);
return(resource);
}
}
/// <summary>
/// Creates a new instance of the backing CLR object for the given resource type.
/// </summary>
/// <param name="structuredType">The EDM type of the resource to create.</param>
/// <param name="readContext">The deserializer context.</param>
/// <returns>The created CLR object.</returns>
public virtual object CreateResourceInstance(IEdmStructuredTypeReference structuredType, ODataDeserializerContext readContext)
{
if (readContext == null)
{
throw Error.ArgumentNull("readContext");
}
if (structuredType == null)
{
throw Error.ArgumentNull("structuredType");
}
IEdmModel model = readContext.Model;
if (model == null)
{
throw Error.Argument("readContext", SRResources.ModelMissingFromReadContext);
}
if (readContext.IsUntyped)
{
if (structuredType.IsEntity())
{
return(new EdmEntityObject(structuredType.AsEntity()));
}
return(new EdmComplexObject(structuredType.AsComplex()));
}
else
{
Type clrType = EdmLibHelpers.GetClrType(structuredType, model);
if (clrType == null)
{
throw new ODataException(
Error.Format(SRResources.MappingDoesNotContainResourceType, structuredType.FullName()));
}
if (readContext.IsDeltaOfT)
{
IEnumerable <string> structuralProperties = structuredType.StructuralProperties()
.Select(edmProperty => EdmLibHelpers.GetClrPropertyName(edmProperty, model));
if (structuredType.IsOpen())
{
PropertyInfo dynamicDictionaryPropertyInfo = EdmLibHelpers.GetDynamicPropertyDictionary(
structuredType.StructuredDefinition(), model);
return(Activator.CreateInstance(readContext.ResourceType, clrType, structuralProperties,
dynamicDictionaryPropertyInfo));
}
else
{
return(Activator.CreateInstance(readContext.ResourceType, clrType, structuralProperties));
}
}
else
{
return(Activator.CreateInstance(clrType));
}
}
}
private static void ProcessResourceSet(object feed, IEdmCollectionTypeReference resourceSetType, ODataDeserializerContext readContext, ODataDeserializerProvider deserializerProvider, Dictionary <string, object> payload, string parameterName)
{
ODataResourceSetDeserializer resourceSetDeserializer = (ODataResourceSetDeserializer)deserializerProvider.GetEdmTypeDeserializer(resourceSetType);
object result = resourceSetDeserializer.ReadInline(feed, resourceSetType, readContext);
IEdmTypeReference elementTypeReference = resourceSetType.ElementType();
Contract.Assert(elementTypeReference.IsStructured());
IEnumerable enumerable = result as IEnumerable;
if (enumerable != null)
{
if (readContext.IsUntyped)
{
payload[parameterName] = enumerable.ConvertToEdmObject(resourceSetType);
}
else
{
Type elementClrType = EdmLibHelpers.GetClrType(elementTypeReference, readContext.Model);
IEnumerable castedResult =
_castMethodInfo.MakeGenericMethod(elementClrType)
.Invoke(null, new[] { result }) as IEnumerable;
payload[parameterName] = castedResult;
}
}
}
private static async Task ReadResourceSetAsync(IEdmAction action, ODataParameterReader reader, ODataDeserializerContext readContext, ODataDeserializerProvider deserializerProvider, Dictionary <string, object> payload)
{
string parameterName;
IEdmCollectionTypeReference resourceSetType = GetCollectionParameterType(action, reader, out parameterName);
object feed = await reader.CreateResourceSetReader().ReadResourceOrResourceSetAsync();
ProcessResourceSet(feed, resourceSetType, readContext, deserializerProvider, payload, parameterName);
}
private static async Task ReadResourceAsync(IEdmAction action, ODataParameterReader reader, ODataDeserializerContext readContext, ODataDeserializerProvider deserializerProvider, Dictionary <string, object> payload)
{
string parameterName;
IEdmOperationParameter parameter = GetParameter(action, reader, out parameterName);
Contract.Assert(parameter.Type.IsStructured());
object item = await reader.CreateResourceReader().ReadResourceOrResourceSetAsync();
ODataResourceDeserializer resourceDeserializer = (ODataResourceDeserializer)deserializerProvider.GetEdmTypeDeserializer(parameter.Type);
payload[parameterName] = resourceDeserializer.ReadInline(item, parameter.Type, readContext);
}
/// <summary>
/// Deserializes the item into a new object of type corresponding to <paramref name="edmType"/>.
/// </summary>
/// <param name="item">The item to deserialize.</param>
/// <param name="edmType">The EDM type of the object to read into.</param>
/// <param name="readContext">The <see cref="ODataDeserializerContext"/>.</param>
/// <returns>The deserialized object.</returns>
public virtual object ReadInline(object item, IEdmTypeReference edmType, ODataDeserializerContext readContext)
{
throw Error.NotSupported(SRResources.DoesNotSupportReadInLine, GetType().Name);
}
/// <summary>
/// Deserializes the nested property from <paramref name="resourceInfoWrapper"/> into <paramref name="resource"/>.
/// </summary>
/// <param name="resource">The object into which the nested property should be read.</param>
/// <param name="resourceInfoWrapper">The nested resource info.</param>
/// <param name="structuredType">The type of the resource.</param>
/// <param name="readContext">The deserializer context.</param>
public virtual void ApplyNestedProperty(object resource, ODataNestedResourceInfoWrapper resourceInfoWrapper,
IEdmStructuredTypeReference structuredType, ODataDeserializerContext readContext)
{
if (resource == null)
{
throw Error.ArgumentNull("resource");
}
if (resourceInfoWrapper == null)
{
throw Error.ArgumentNull("resourceInfoWrapper");
}
IEdmProperty edmProperty = structuredType.FindProperty(resourceInfoWrapper.NestedResourceInfo.Name);
if (edmProperty == null)
{
if (!structuredType.IsOpen())
{
throw new ODataException(
Error.Format(SRResources.NestedPropertyNotfound, resourceInfoWrapper.NestedResourceInfo.Name,
structuredType.FullName()));
}
}
foreach (ODataItemBase childItem in resourceInfoWrapper.NestedItems)
{
// it maybe null.
if (childItem == null)
{
if (edmProperty == null)
{
// for the dynamic, OData.net has a bug. see https://github.com/OData/odata.net/issues/977
ApplyDynamicResourceInNestedProperty(resourceInfoWrapper.NestedResourceInfo.Name, resource,
structuredType, null, readContext);
}
else
{
ApplyResourceInNestedProperty(edmProperty, resource, null, readContext);
}
}
ODataEntityReferenceLinkBase entityReferenceLink = childItem as ODataEntityReferenceLinkBase;
if (entityReferenceLink != null)
{
// ignore entity reference links.
continue;
}
ODataResourceSetWrapper resourceSetWrapper = childItem as ODataResourceSetWrapper;
if (resourceSetWrapper != null)
{
if (edmProperty == null)
{
ApplyDynamicResourceSetInNestedProperty(resourceInfoWrapper.NestedResourceInfo.Name,
resource, structuredType, resourceSetWrapper, readContext);
}
else
{
ApplyResourceSetInNestedProperty(edmProperty, resource, resourceSetWrapper, readContext);
}
continue;
}
// It must be resource by now.
ODataResourceWrapper resourceWrapper = (ODataResourceWrapper)childItem;
if (resourceWrapper != null)
{
if (edmProperty == null)
{
ApplyDynamicResourceInNestedProperty(resourceInfoWrapper.NestedResourceInfo.Name, resource,
structuredType, resourceWrapper, readContext);
}
else
{
ApplyResourceInNestedProperty(edmProperty, resource, resourceWrapper, readContext);
}
}
}
}
private void ApplyResourceProperties(object resource, ODataResourceWrapper resourceWrapper,
IEdmStructuredTypeReference structuredType, ODataDeserializerContext readContext)
{
var typeMappingHandler = readContext.Model.GetAnnotationValue <IEdmModelClrTypeMappingHandler>(readContext.Model);
if (typeMappingHandler != null)
{
typeMappingHandler.InitializeClrInstanceForDeserialization(readContext.Model, structuredType, resource);
}
ApplyStructuralProperties(resource, resourceWrapper, structuredType, readContext);
ApplyNestedProperties(resource, resourceWrapper, structuredType, readContext);
}
/// <summary>
/// Deserializes the structural properties from <paramref name="resourceWrapper"/> into <paramref name="resource"/>.
/// </summary>
/// <param name="resource">The object into which the structural properties should be read.</param>
/// <param name="resourceWrapper">The resource object containing the structural properties.</param>
/// <param name="structuredType">The type of the resource.</param>
/// <param name="readContext">The deserializer context.</param>
public virtual void ApplyStructuralProperties(object resource, ODataResourceWrapper resourceWrapper,
IEdmStructuredTypeReference structuredType, ODataDeserializerContext readContext)
{
if (resourceWrapper == null)
{
throw Error.ArgumentNull("resourceWrapper");
}
foreach (ODataProperty property in resourceWrapper.Resource.Properties)
{
ApplyStructuralProperty(resource, property, structuredType, readContext);
}
}
internal static void ApplyProperty(ODataProperty property, IEdmStructuredTypeReference resourceType, object resource,
ODataDeserializerProvider deserializerProvider, ODataDeserializerContext readContext)
{
IEdmProperty edmProperty = resourceType.FindProperty(property.Name);
bool isDynamicProperty = false;
string propertyName = property.Name;
if (edmProperty != null)
{
propertyName = EdmLibHelpers.GetClrPropertyName(edmProperty, readContext.Model);
}
else
{
IEdmStructuredType structuredType = resourceType.StructuredDefinition();
isDynamicProperty = structuredType != null && structuredType.IsOpen;
}
if (!isDynamicProperty && edmProperty == null)
{
throw new ODataException(
Error.Format(SRResources.CannotDeserializeUnknownProperty, property.Name, resourceType.Definition));
}
// dynamic properties have null values
IEdmTypeReference propertyType = edmProperty != null ? edmProperty.Type : null;
EdmTypeKind propertyKind;
object value = ConvertValue(property.Value, ref propertyType, deserializerProvider, readContext,
out propertyKind);
if (isDynamicProperty)
{
SetDynamicProperty(resource, resourceType, propertyKind, propertyName, value, propertyType,
readContext.Model);
}
else
{
SetDeclaredProperty(resource, propertyKind, propertyName, value, edmProperty, readContext);
}
}
/// <summary>
/// Deserializes the given <paramref name="structuralProperty"/> into <paramref name="resource"/>.
/// </summary>
/// <param name="resource">The object into which the structural property should be read.</param>
/// <param name="structuralProperty">The structural property.</param>
/// <param name="structuredType">The type of the resource.</param>
/// <param name="readContext">The deserializer context.</param>
public virtual void ApplyStructuralProperty(object resource, ODataProperty structuralProperty,
IEdmStructuredTypeReference structuredType, ODataDeserializerContext readContext)
{
if (resource == null)
{
throw Error.ArgumentNull("resource");
}
if (structuralProperty == null)
{
throw Error.ArgumentNull("structuralProperty");
}
DeserializationHelpers.ApplyProperty(structuralProperty, structuredType, resource, DeserializerProvider, readContext);
}
internal static object ConvertAnnotationValue(object oDataValue, ref IEdmTypeReference propertyType, ODataDeserializerProvider deserializerProvider,
ODataDeserializerContext readContext)
{
if (oDataValue == null)
{
return(null);
}
ODataEnumValue enumValue = oDataValue as ODataEnumValue;
if (enumValue != null)
{
return(ConvertEnumValue(enumValue, ref propertyType, deserializerProvider, readContext));
}
ODataCollectionValue collection = oDataValue as ODataCollectionValue;
if (collection != null)
{
return(ConvertCollectionValue(collection, ref propertyType, deserializerProvider, readContext));
}
ODataUntypedValue untypedValue = oDataValue as ODataUntypedValue;
if (untypedValue != null)
{
Contract.Assert(!String.IsNullOrEmpty(untypedValue.RawValue));
if (untypedValue.RawValue.StartsWith("[", StringComparison.Ordinal) ||
untypedValue.RawValue.StartsWith("{", StringComparison.Ordinal))
{
throw new ODataException(Error.Format(SRResources.InvalidODataUntypedValue, untypedValue.RawValue));
}
oDataValue = ConvertPrimitiveValue(untypedValue.RawValue);
}
ODataResourceValue annotationVal = oDataValue as ODataResourceValue;
if (annotationVal != null)
{
var annotationType = readContext.Model.FindDeclaredType(annotationVal.TypeName).ToEdmTypeReference(true) as IEdmStructuredTypeReference;
ODataResourceDeserializer deserializer = new ODataResourceDeserializer(deserializerProvider);
object resource = deserializer.CreateResourceInstance(annotationType, readContext);
if (resource != null)
{
foreach (var prop in annotationVal.Properties)
{
deserializer.ApplyStructuralProperty(resource, prop, annotationType, readContext);
}
}
return(resource);
}
ODataPrimitiveValue primitiveValue = oDataValue as ODataPrimitiveValue;
if (primitiveValue != null)
{
return(EdmPrimitiveHelpers.ConvertPrimitiveValue(primitiveValue.Value, primitiveValue.Value.GetType()));
}
return(oDataValue);
}
private void ApplyResourceProperties(object resource, ODataResourceWrapper resourceWrapper,
IEdmStructuredTypeReference structuredType, ODataDeserializerContext readContext)
{
ApplyStructuralProperties(resource, resourceWrapper, structuredType, readContext);
ApplyNestedProperties(resource, resourceWrapper, structuredType, readContext);
}
internal static void ApplyInstanceAnnotations(object resource, IEdmStructuredTypeReference structuredType, ODataResource oDataResource,
ODataDeserializerProvider deserializerProvider, ODataDeserializerContext readContext)
{
PropertyInfo propertyInfo = EdmLibHelpers.GetInstanceAnnotationsContainer(structuredType.StructuredDefinition(), readContext.Model);
if (propertyInfo == null)
{
return;
}
IODataInstanceAnnotationContainer instanceAnnotationContainer = GetAnnotationContainer(propertyInfo, resource);
SetInstanceAnnotations(oDataResource, instanceAnnotationContainer, deserializerProvider, readContext);
}
internal static void SetDynamicCollectionProperty(object resource, string propertyName, object value,
IEdmCollectionTypeReference edmPropertyType, IEdmStructuredType structuredType,
ODataDeserializerContext readContext)
{
Contract.Assert(value != null);
Contract.Assert(readContext != null);
Contract.Assert(readContext.Model != null);
IEnumerable collection = value as IEnumerable;
Contract.Assert(collection != null);
Type resourceType = resource.GetType();
Type elementType = EdmLibHelpers.GetClrType(edmPropertyType.ElementType(), readContext.Model);
Type propertyType = typeof(ICollection<>).MakeGenericType(elementType);
IEnumerable newCollection;
if (CollectionDeserializationHelpers.TryCreateInstance(propertyType, edmPropertyType, elementType,
out newCollection))
{
collection.AddToCollection(newCollection, elementType, resourceType, propertyName, propertyType);
SetDynamicProperty(resource, propertyName, newCollection, structuredType, readContext);
}
}
/// <inheritdoc />
public override async Task <object> ReadAsync(ODataMessageReader messageReader, Type type, ODataDeserializerContext readContext)
{
if (messageReader == null)
{
throw Error.ArgumentNull("messageReader");
}
IEdmTypeReference edmType = GetElementType(type, readContext);
IEdmTypeReference elementType = edmType.AsCollection().ElementType();
ODataCollectionReader reader = await messageReader.CreateODataCollectionReaderAsync(elementType);
return(ReadInline(await ReadCollectionAsync(reader), edmType, readContext));
}
public override async Task <object> ReadAsync(ODataMessageReader messageReader, Type type, ODataDeserializerContext readContext)
{
if (messageReader == null)
{
throw Error.ArgumentNull("messageReader");
}
IEdmAction action = GetAction(readContext);
Contract.Assert(action != null);
// Create the correct resource type;
Dictionary <string, object> payload = GetPayload(type, action);
ODataParameterReader reader = await messageReader.CreateODataParameterReaderAsync(action);
while (await reader.ReadAsync())
{
switch (reader.State)
{
case ODataParameterReaderState.Value:
ReadValue(action, reader, readContext, DeserializerProvider, payload);
break;
case ODataParameterReaderState.Collection:
await ReadCollectionAsync(action, reader, readContext, DeserializerProvider, payload);
break;
case ODataParameterReaderState.Resource:
await ReadResourceAsync(action, reader, readContext, DeserializerProvider, payload);
break;
case ODataParameterReaderState.ResourceSet:
await ReadResourceSetAsync(action, reader, readContext, DeserializerProvider, payload);
break;
}
}
return(payload);
}
/// <inheritdoc />
public override async Task <object> ReadAsync(ODataMessageReader messageReader, Type type, ODataDeserializerContext readContext)
{
if (messageReader == null)
{
throw Error.ArgumentNull("messageReader");
}
if (readContext == null)
{
throw Error.ArgumentNull("readContext");
}
ODataEntityReferenceLink entityReferenceLink = await messageReader.ReadEntityReferenceLinkAsync();
if (entityReferenceLink != null)
{
return(ResolveContentId(entityReferenceLink.Url, readContext));
}
return(null);
}
private static object ConvertCollectionValue(ODataCollectionValue collection,
ref IEdmTypeReference propertyType, ODataDeserializerProvider deserializerProvider,
ODataDeserializerContext readContext)
{
IEdmCollectionTypeReference collectionType;
if (propertyType == null)
{
// dynamic collection property
Contract.Assert(!String.IsNullOrEmpty(collection.TypeName),
"ODataLib should have verified that dynamic collection value has a type name " +
"since we provided metadata.");
string elementTypeName = GetCollectionElementTypeName(collection.TypeName, isNested: false);
IEdmModel model = readContext.Model;
IEdmSchemaType elementType = model.FindType(elementTypeName);
Contract.Assert(elementType != null);
collectionType =
new EdmCollectionTypeReference(
new EdmCollectionType(elementType.ToEdmTypeReference(isNullable: false)));
propertyType = collectionType;
}
else
{
collectionType = propertyType as IEdmCollectionTypeReference;
Contract.Assert(collectionType != null, "The type for collection must be a IEdmCollectionType.");
}
ODataEdmTypeDeserializer deserializer = deserializerProvider.GetEdmTypeDeserializer(collectionType);
return deserializer.ReadInline(collection, collectionType, readContext);
}
private void ApplyDynamicResourceInNestedProperty(string propertyName, object resource, IEdmStructuredTypeReference resourceStructuredType,
ODataResourceWrapper resourceWrapper, ODataDeserializerContext readContext)
{
Contract.Assert(resource != null);
Contract.Assert(readContext != null);
object value = null;
if (resourceWrapper != null)
{
IEdmSchemaType elementType = readContext.Model.FindDeclaredType(resourceWrapper.Resource.TypeName);
IEdmTypeReference edmTypeReference = elementType.ToEdmTypeReference(true);
value = ReadNestedResourceInline(resourceWrapper, edmTypeReference, readContext);
}
DeserializationHelpers.SetDynamicProperty(resource, propertyName, value,
resourceStructuredType.StructuredDefinition(), readContext.Model);
}
private static void ReadValue(IEdmAction action, ODataParameterReader reader, ODataDeserializerContext readContext, ODataDeserializerProvider deserializerProvider, Dictionary <string, object> payload)
{
string parameterName;
IEdmOperationParameter parameter = GetParameter(action, reader, out parameterName);
if (parameter.Type.IsPrimitive())
{
payload[parameterName] = reader.Value;
}
else
{
ODataEdmTypeDeserializer deserializer = deserializerProvider.GetEdmTypeDeserializer(parameter.Type);
payload[parameterName] = deserializer.ReadInline(reader.Value, parameter.Type, readContext);
}
}
internal static void SetDynamicProperty(object resource, string propertyName, object value,
IEdmStructuredType structuredType, ODataDeserializerContext readContext)
{
IDelta delta = resource as IDelta;
if (delta != null)
{
delta.TrySetPropertyValue(propertyName, value);
}
else
{
PropertyInfo propertyInfo = EdmLibHelpers.GetDynamicPropertyDictionary(structuredType,
readContext.Model);
if (propertyInfo == null)
{
return;
}
IDictionary<string, object> dynamicPropertyDictionary;
object dynamicDictionaryObject = propertyInfo.GetValue(resource);
if (dynamicDictionaryObject == null)
{
if (!propertyInfo.CanWrite)
{
throw Error.InvalidOperation(SRResources.CannotSetDynamicPropertyDictionary, propertyName,
resource.GetType().FullName);
}
dynamicPropertyDictionary = new Dictionary<string, object>();
propertyInfo.SetValue(resource, dynamicPropertyDictionary);
}
else
{
dynamicPropertyDictionary = (IDictionary<string, object>)dynamicDictionaryObject;
}
if (dynamicPropertyDictionary.ContainsKey(propertyName))
{
throw Error.InvalidOperation(SRResources.DuplicateDynamicPropertyNameFound,
propertyName, structuredType.FullTypeName());
}
dynamicPropertyDictionary.Add(propertyName, value);
}
}
private object ReadNestedResourceInline(ODataResourceWrapper resourceWrapper, IEdmTypeReference edmType, ODataDeserializerContext readContext)
{
Contract.Assert(edmType != null);
Contract.Assert(readContext != null);
if (resourceWrapper == null)
{
return(null);
}
ODataEdmTypeDeserializer deserializer = DeserializerProvider.GetEdmTypeDeserializer(edmType);
if (deserializer == null)
{
throw new SerializationException(Error.Format(SRResources.TypeCannotBeDeserialized, edmType.FullName()));
}
IEdmStructuredTypeReference structuredType = edmType.AsStructured();
var nestedReadContext = new ODataDeserializerContext
{
Path = readContext.Path,
Model = readContext.Model,
};
Type clrType = null;
if (readContext.IsUntyped)
{
clrType = structuredType.IsEntity()
? typeof(EdmEntityObject)
: typeof(EdmComplexObject);
}
else
{
clrType = EdmLibHelpers.GetClrType(structuredType, readContext.Model);
if (clrType == null)
{
throw new ODataException(
Error.Format(SRResources.MappingDoesNotContainResourceType, structuredType.FullName()));
}
}
nestedReadContext.ResourceType = readContext.IsDeltaOfT
? typeof(Delta <>).MakeGenericType(clrType)
: clrType;
return(deserializer.ReadInline(resourceWrapper, edmType, nestedReadContext));
}
internal static object ConvertValue(object oDataValue, ref IEdmTypeReference propertyType, ODataDeserializerProvider deserializerProvider,
ODataDeserializerContext readContext, out EdmTypeKind typeKind)
{
if (oDataValue == null)
{
typeKind = EdmTypeKind.None;
return null;
}
ODataComplexValue complexValue = oDataValue as ODataComplexValue;
if (complexValue != null)
{
typeKind = EdmTypeKind.Complex;
return ConvertComplexValue(complexValue, ref propertyType, deserializerProvider, readContext);
}
ODataEnumValue enumValue = oDataValue as ODataEnumValue;
if (enumValue != null)
{
typeKind = EdmTypeKind.Enum;
return ConvertEnumValue(enumValue, ref propertyType, deserializerProvider, readContext);
}
ODataCollectionValue collection = oDataValue as ODataCollectionValue;
if (collection != null)
{
typeKind = EdmTypeKind.Collection;
return ConvertCollectionValue(collection, ref propertyType, deserializerProvider, readContext);
}
typeKind = EdmTypeKind.Primitive;
return oDataValue;
}
private void ApplyResourceSetInNestedProperty(IEdmProperty nestedProperty, object resource,
ODataResourceSetWrapper resourceSetWrapper, ODataDeserializerContext readContext)
{
Contract.Assert(nestedProperty != null);
Contract.Assert(resource != null);
Contract.Assert(readContext != null);
if (readContext.IsDeltaOfT)
{
IEdmNavigationProperty navigationProperty = nestedProperty as IEdmNavigationProperty;
if (navigationProperty != null)
{
string message = Error.Format(SRResources.CannotPatchNavigationProperties, navigationProperty.Name,
navigationProperty.DeclaringEntityType().FullName());
throw new ODataException(message);
}
}
object value = ReadNestedResourceSetInline(resourceSetWrapper, nestedProperty.Type, readContext);
string propertyName = EdmLibHelpers.GetClrPropertyName(nestedProperty, readContext.Model);
DeserializationHelpers.SetCollectionProperty(resource, nestedProperty, value, propertyName);
}
private static object ConvertEnumValue(ODataEnumValue enumValue, ref IEdmTypeReference propertyType,
ODataDeserializerProvider deserializerProvider, ODataDeserializerContext readContext)
{
IEdmEnumTypeReference edmEnumType;
if (propertyType == null)
{
// dynamic enum property
Contract.Assert(!String.IsNullOrEmpty(enumValue.TypeName),
"ODataLib should have verified that dynamic enum value has a type name since we provided metadata.");
IEdmModel model = readContext.Model;
IEdmType edmType = model.FindType(enumValue.TypeName);
Contract.Assert(edmType.TypeKind == EdmTypeKind.Enum, "ODataLib should have verified that enum value has a enum resource type.");
edmEnumType = new EdmEnumTypeReference(edmType as IEdmEnumType, isNullable: true);
propertyType = edmEnumType;
}
else
{
edmEnumType = propertyType.AsEnum();
}
ODataEdmTypeDeserializer deserializer = deserializerProvider.GetEdmTypeDeserializer(edmEnumType);
return deserializer.ReadInline(enumValue, propertyType, readContext);
}
private void ApplyDynamicResourceSetInNestedProperty(string propertyName, object resource, IEdmStructuredTypeReference structuredType,
ODataResourceSetWrapper resourceSetWrapper, ODataDeserializerContext readContext)
{
Contract.Assert(resource != null);
Contract.Assert(readContext != null);
if (String.IsNullOrEmpty(resourceSetWrapper.ResourceSet.TypeName))
{
string message = Error.Format(SRResources.DynamicResourceSetTypeNameIsRequired, propertyName);
throw new ODataException(message);
}
string elementTypeName =
DeserializationHelpers.GetCollectionElementTypeName(resourceSetWrapper.ResourceSet.TypeName,
isNested: false);
IEdmSchemaType elementType = readContext.Model.FindDeclaredType(elementTypeName);
IEdmTypeReference edmTypeReference = elementType.ToEdmTypeReference(true);
EdmCollectionTypeReference collectionType = new EdmCollectionTypeReference(new EdmCollectionType(edmTypeReference));
ODataEdmTypeDeserializer deserializer = DeserializerProvider.GetEdmTypeDeserializer(collectionType);
if (deserializer == null)
{
throw new SerializationException(Error.Format(SRResources.TypeCannotBeDeserialized, collectionType.FullName()));
}
IEnumerable value = ReadNestedResourceSetInline(resourceSetWrapper, collectionType, readContext) as IEnumerable;
object result = value;
if (value != null)
{
if (readContext.IsUntyped)
{
result = value.ConvertToEdmObject(collectionType);
}
}
DeserializationHelpers.SetDynamicProperty(resource, structuredType, EdmTypeKind.Collection, propertyName,
result, collectionType, readContext.Model);
}
/// <inheritdoc />
public sealed override object ReadInline(object item, IEdmTypeReference edmType, ODataDeserializerContext readContext)
{
if (edmType == null)
{
throw Error.ArgumentNull("edmType");
}
if (edmType.IsComplex() && item == null)
{
return(null);
}
if (item == null)
{
throw Error.ArgumentNull("item");
}
if (!edmType.IsStructured())
{
throw Error.Argument("edmType", SRResources.ArgumentMustBeOfType, "Entity or Complex");
}
ODataResourceWrapper resourceWrapper = item as ODataResourceWrapper;
if (resourceWrapper == null)
{
throw Error.Argument("item", SRResources.ArgumentMustBeOfType, typeof(ODataResource).Name);
}
// Recursion guard to avoid stack overflows
RuntimeHelpers.EnsureSufficientExecutionStack();
return(ReadResource(resourceWrapper, edmType.AsStructured(), readContext));
}
/// <summary>
/// Reads an <see cref="IODataRequestMessage"/> using messageReader.
/// </summary>
/// <param name="messageReader">The messageReader to use.</param>
/// <param name="type">The type of the object to read into.</param>
/// <param name="readContext">The read context.</param>
/// <returns>The deserialized object.</returns>
public virtual object Read(ODataMessageReader messageReader, Type type, ODataDeserializerContext readContext)
{
throw Error.NotSupported(SRResources.DeserializerDoesNotSupportRead, GetType().Name);
}