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); }