/// <summary>
/// Deserializes the given <paramref name="complexValue"/> under the given <paramref name="readContext"/>.
/// </summary>
/// <param name="complexValue">The complex value to deserialize.</param>
/// <param name="complexType">The EDM type of the complex value to read.</param>
/// <param name="readContext">The deserializer context.</param>
/// <returns>The deserialized complex value.</returns>
public virtual object ReadComplexValue(ODataComplexValue complexValue, IEdmComplexTypeReference complexType,
ODataDeserializerContext readContext)
{
if (complexValue == null)
{
throw Error.ArgumentNull("complexValue");
}
if (readContext == null)
{
throw Error.ArgumentNull("readContext");
}
if (readContext.Model == null)
{
throw Error.Argument("readContext", SRResources.ModelMissingFromReadContext);
}
object complexResource = CreateResource(complexType, readContext);
foreach (ODataProperty complexProperty in complexValue.Properties)
{
DeserializationHelpers.ApplyProperty(complexProperty, complexType, complexResource, DeserializerProvider, readContext);
}
return complexResource;
}
public void Read_RoundTrips()
{
// Arrange
IEdmModel model = CreateModel();
var deserializer = new ODataEntityReferenceLinkDeserializer();
MockODataRequestMessage requestMessage = new MockODataRequestMessage();
ODataMessageWriterSettings settings = new ODataMessageWriterSettings()
{
ODataUri = new ODataUri { ServiceRoot = new Uri("http://any/") }
};
settings.SetContentType(ODataFormat.Json);
ODataMessageWriter messageWriter = new ODataMessageWriter(requestMessage, settings);
messageWriter.WriteEntityReferenceLink(new ODataEntityReferenceLink { Url = new Uri("http://localhost/samplelink") });
ODataMessageReaderSettings readSettings = new ODataMessageReaderSettings();
ODataMessageReader messageReader = new ODataMessageReader(new MockODataRequestMessage(requestMessage), readSettings, model);
ODataDeserializerContext context = new ODataDeserializerContext
{
Request = new HttpRequestMessage(),
Path = new ODataPath(new NavigationPathSegment(GetNavigationProperty(model)))
};
// Act
Uri uri = deserializer.Read(messageReader, typeof(Uri), context) as Uri;
// Assert
Assert.NotNull(uri);
Assert.Equal("http://localhost/samplelink", uri.AbsoluteUri);
}
/// <inheritdoc />
public override object Read(
ODataMessageReader messageReader,
Type type,
ODataDeserializerContext readContext)
{
return enumDeserializer.Read(messageReader, type, readContext);
}
/// <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() || !edmType.AsCollection().ElementType().IsEntity())
{
throw Error.Argument("edmType", SRResources.TypeMustBeEntityCollection, edmType.ToTraceString(), typeof(IEdmEntityType).Name);
}
IEdmEntityTypeReference elementType = edmType.AsCollection().ElementType().AsEntity();
ODataFeedWithEntries feed = item as ODataFeedWithEntries;
if (feed == null)
{
throw Error.Argument("item", SRResources.ArgumentMustBeOfType, typeof(ODataFeedWithEntries).Name);
}
// Recursion guard to avoid stack overflows
RuntimeHelpers.EnsureSufficientExecutionStack();
return ReadFeed(feed, elementType, readContext);
}
/// <inheritdoc />
public sealed override object ReadInline(object item, IEdmTypeReference edmType, ODataDeserializerContext readContext)
{
if (item == null)
{
throw Error.ArgumentNull("item");
}
if (edmType == null)
{
throw Error.ArgumentNull("edmType");
}
if (!edmType.IsEntity())
{
throw Error.Argument("edmType", SRResources.ArgumentMustBeOfType, EdmTypeKind.Entity);
}
ODataEntryWithNavigationLinks entryWrapper = item as ODataEntryWithNavigationLinks;
if (entryWrapper == null)
{
throw Error.Argument("item", SRResources.ArgumentMustBeOfType, typeof(ODataEntry).Name);
}
// Recursion guard to avoid stack overflows
RuntimeHelpers.EnsureSufficientExecutionStack();
return ReadEntry(entryWrapper, edmType.AsEntity(), readContext);
}
public ODataSingletonDeserializerTest()
{
EdmModel model = new EdmModel();
var employeeType = new EdmEntityType("NS", "Employee");
employeeType.AddStructuralProperty("EmployeeId", EdmPrimitiveTypeKind.Int32);
employeeType.AddStructuralProperty("EmployeeName", EdmPrimitiveTypeKind.String);
model.AddElement(employeeType);
EdmEntityContainer defaultContainer = new EdmEntityContainer("NS", "Default");
model.AddElement(defaultContainer);
_singleton = new EdmSingleton(defaultContainer, "CEO", employeeType);
defaultContainer.AddElement(_singleton);
model.SetAnnotationValue<ClrTypeAnnotation>(employeeType, new ClrTypeAnnotation(typeof(EmployeeModel)));
_edmModel = model;
_edmContainer = defaultContainer;
_readContext = new ODataDeserializerContext
{
Path = new ODataPath(new SingletonPathSegment(_singleton)),
Model = _edmModel,
ResourceType = typeof(EmployeeModel)
};
_deserializerProvider = new DefaultODataDeserializerProvider();
}
internal static object ConvertValue(
object odataValue,
string parameterName,
Type expectedReturnType,
IEdmTypeReference propertyType,
IEdmModel model,
HttpRequestMessage request,
IServiceProvider serviceProvider)
{
var readContext = new ODataDeserializerContext
{
Model = model,
Request = request
};
// Enum logic can be removed after RestierEnumDeserializer extends ODataEnumDeserializer
var deserializerProvider = serviceProvider.GetService<ODataDeserializerProvider>();
var enumValue = odataValue as ODataEnumValue;
if (enumValue != null)
{
ODataEdmTypeDeserializer deserializer
= deserializerProvider.GetEdmTypeDeserializer(propertyType.AsEnum());
return deserializer.ReadInline(enumValue, propertyType, readContext);
}
var returnValue = ODataModelBinderConverter.Convert(
odataValue, propertyType, expectedReturnType, parameterName, readContext, serviceProvider);
if (!propertyType.IsCollection())
{
return returnValue;
}
return ConvertCollectionType(returnValue, expectedReturnType);
}
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));
}
else if (propertyKind == EdmTypeKind.Enum)
{
propertyValue = EnumDeserializationHelpers.ConvertEnumValue(propertyValue,
GetPropertyType(resource, propertyName));
}
}
SetProperty(resource, propertyName, propertyValue);
}
}
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)
{
if (messageReader == null)
{
throw Error.ArgumentNull("messageReader");
}
if (readContext == null)
{
throw Error.ArgumentNull("readContext");
}
IEdmNavigationProperty navigationProperty = GetNavigationProperty(readContext.Path);
if (navigationProperty == null)
{
throw new SerializationException(SRResources.NavigationPropertyMissingDuringDeserialization);
}
ODataEntityReferenceLink entityReferenceLink = messageReader.ReadEntityReferenceLink(navigationProperty);
if (entityReferenceLink != null)
{
return ResolveContentId(entityReferenceLink.Url, readContext);
}
return null;
}
/// <inheritdoc />
public sealed override object ReadInline(object item, IEdmTypeReference edmType, ODataDeserializerContext readContext)
{
if (readContext == null)
{
throw Error.ArgumentNull("readContext");
}
if (item == null)
{
return null;
}
ODataComplexValue complexValue = item as ODataComplexValue;
if (complexValue == null)
{
throw Error.Argument("item", SRResources.ArgumentMustBeOfType, typeof(ODataComplexValue).Name);
}
if (!edmType.IsComplex())
{
throw Error.Argument("edmType", SRResources.ArgumentMustBeOfType, EdmTypeKind.Complex);
}
// Recursion guard to avoid stack overflows
RuntimeHelpers.EnsureSufficientExecutionStack();
return ReadComplexValue(complexValue, edmType.AsComplex(), readContext);
}
/// <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(), typeof(ODataMediaTypeFormatter)));
}
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.IsComplex())
{
EdmComplexObjectCollection complexCollection = new EdmComplexObjectCollection(collectionType);
foreach (EdmComplexObject complexObject in result)
{
complexCollection.Add(complexObject);
}
return complexCollection;
}
else if (readContext.IsUntyped && elementType.IsEnum())
{
EdmEnumObjectCollection enumCollection = new EdmEnumObjectCollection(collectionType);
foreach (EdmEnumObject enumObject in result)
{
enumCollection.Add(enumObject);
}
return enumCollection;
}
else
{
Type elementClrType = EdmLibHelpers.GetClrType(elementType, readContext.Model);
IEnumerable castedResult = _castMethodInfo.MakeGenericMethod(elementClrType).Invoke(null, new object[] { result }) as IEnumerable;
return castedResult;
}
}
return null;
}
/// <summary>
/// Deserializes the primitive from the given <paramref name="primitiveProperty"/> under the given <paramref name="readContext"/>.
/// </summary>
/// <param name="primitiveProperty">The primitive property to deserialize.</param>
/// <param name="readContext">The deserializer context.</param>
/// <returns>The deserialized OData primitive value.</returns>
public virtual object ReadPrimitive(ODataProperty primitiveProperty, ODataDeserializerContext readContext)
{
if (primitiveProperty == null)
{
throw Error.ArgumentNull("primitiveProperty");
}
return primitiveProperty.Value;
}
/// <inheritdoc />
public sealed override object ReadInline(object item, IEdmTypeReference edmType, ODataDeserializerContext readContext)
{
if (item == null)
{
return null;
}
Type clrType = EdmLibHelpers.GetClrType(edmType, readContext.Model);
return EnumDeserializationHelpers.ConvertEnumValue(item, clrType);
}
public void Throws_Serialization_WhenPathNotFound()
{
// Arrange
ODataDeserializerContext context = new ODataDeserializerContext { Path = null };
// Act & Assert
Assert.Throws<SerializationException>(() =>
{
IEdmAction action = ODataActionPayloadDeserializer.GetAction(context);
}, "The operation cannot be completed because no ODataPath is available for the request.");
}
/// <inheritdoc />
public override object Read(ODataMessageReader messageReader, Type type, ODataDeserializerContext readContext)
{
if (messageReader == null)
{
throw Error.ArgumentNull("messageReader");
}
IEdmTypeReference edmType = readContext.GetEdmType(type);
Contract.Assert(edmType != null);
ODataProperty property = messageReader.ReadProperty();
return ReadInline(property, edmType, readContext);
}
public void ReadFeed_Throws_TypeCannotBeDeserialized()
{
Mock<ODataDeserializerProvider> deserializerProvider = new Mock<ODataDeserializerProvider>();
ODataFeedDeserializer deserializer = new ODataFeedDeserializer(deserializerProvider.Object);
ODataFeedWithEntries feedWrapper = new ODataFeedWithEntries(new ODataFeed());
ODataDeserializerContext readContext = new ODataDeserializerContext();
deserializerProvider.Setup(p => p.GetEdmTypeDeserializer(_customerType)).Returns<ODataEdmTypeDeserializer>(null);
Assert.Throws<SerializationException>(
() => deserializer.ReadFeed(feedWrapper, _customerType, readContext).GetEnumerator().MoveNext(),
"'System.Web.OData.TestCommon.Models.Customer' cannot be deserialized using the ODataMediaTypeFormatter.");
}
/// <summary>
/// Deserializes the given <paramref name="feed"/> under the given <paramref name="readContext"/>.
/// </summary>
/// <param name="feed">The feed to deserialize.</param>
/// <param name="readContext">The deserializer context.</param>
/// <param name="elementType">The element type of the feed being read.</param>
/// <returns>The deserialized feed object.</returns>
public virtual IEnumerable ReadFeed(ODataFeedWithEntries feed, IEdmEntityTypeReference elementType, ODataDeserializerContext readContext)
{
ODataEdmTypeDeserializer deserializer = DeserializerProvider.GetEdmTypeDeserializer(elementType);
if (deserializer == null)
{
throw new SerializationException(
Error.Format(SRResources.TypeCannotBeDeserialized, elementType.FullName(), typeof(ODataMediaTypeFormatter).Name));
}
foreach (ODataEntryWithNavigationLinks entry in feed.Entries)
{
yield return deserializer.ReadInline(entry, elementType, readContext);
}
}
public ODataEntityDeserializerTests()
{
_edmModel = EdmTestHelpers.GetModel();
IEdmEntitySet entitySet = _edmModel.EntityContainer.FindEntitySet("Products");
_readContext = new ODataDeserializerContext
{
Path = new ODataPath(new EntitySetPathSegment(entitySet)),
Model = _edmModel,
ResourceType = typeof(Product)
};
_productEdmType = _edmModel.GetEdmTypeReference(typeof(Product)).AsEntity();
_supplierEdmType = _edmModel.GetEdmTypeReference(typeof(Supplier)).AsEntity();
_deserializerProvider = new DefaultODataDeserializerProvider();
}
internal static void ApplyProperty(ODataProperty property, IEdmStructuredTypeReference resourceType, object resource,
ODataDeserializerProvider deserializerProvider, ODataDeserializerContext readContext)
{
IEdmProperty edmProperty = resourceType.FindProperty(property.Name);
// try to deserializer the dynamic properties for open type.
if (edmProperty == null)
{
// the logic here works for open complex type and open entity type.
IEdmStructuredType structuredType = resourceType.StructuredDefinition();
if (structuredType != null && structuredType.IsOpen)
{
if (ApplyDynamicProperty(property, structuredType, resource, deserializerProvider, readContext))
{
return;
}
}
}
string propertyName = property.Name;
if (edmProperty != null)
{
propertyName = EdmLibHelpers.GetClrPropertyName(edmProperty, readContext.Model);
}
IEdmTypeReference propertyType = edmProperty != null ? edmProperty.Type : null; // open properties have null values
EdmTypeKind propertyKind;
object value = ConvertValue(property.Value, ref propertyType, deserializerProvider, readContext, out propertyKind);
if (propertyKind == EdmTypeKind.Collection)
{
SetCollectionProperty(resource, edmProperty, value, propertyName);
}
else
{
if (!readContext.IsUntyped)
{
if (propertyKind == EdmTypeKind.Primitive)
{
value = EdmPrimitiveHelpers.ConvertPrimitiveValue(value, GetPropertyType(resource, propertyName));
}
else if (propertyKind == EdmTypeKind.Enum)
{
value = EnumDeserializationHelpers.ConvertEnumValue(value, GetPropertyType(resource, propertyName));
}
}
SetProperty(resource, propertyName, value);
}
}
public void ParserThrows_SerializationException_UnqualifiedBoundAction(string url)
{
// Arrange
IEdmModel model = GetModel();
// Act
ODataPath path = new DefaultODataPathHandler().Parse(model, url);
Assert.NotNull(path); // Guard
ODataDeserializerContext context = new ODataDeserializerContext { Path = path, Model = model };
// Assert
Assert.Throws<SerializationException>(() => ODataActionPayloadDeserializer.GetAction(context),
"The last segment of the request URI '" + url + "' was not recognized as an OData action.");
}
/// <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);
}
public void Can_Find_Action_QualifiedActionName(string actionName, string url)
{
// Arrange
IEdmModel model = GetModel();
// Act
ODataPath path = new DefaultODataPathHandler().Parse(model, _serviceRoot, url);
Assert.NotNull(path); // Guard
ODataDeserializerContext context = new ODataDeserializerContext { Path = path, Model = model };
IEdmAction action = ODataActionPayloadDeserializer.GetAction(context);
// Assert
Assert.NotNull(action);
Assert.Equal(actionName, action.Name);
}
public void Can_find_action_overload_using_bindingparameter_type(string url)
{
// Arrange
IEdmModel model = GetModel();
ODataPath path = new DefaultODataPathHandler().Parse(model, _serviceRoot, url);
Assert.NotNull(path); // Guard
ODataDeserializerContext context = new ODataDeserializerContext { Path = path, Model = model };
// Act
IEdmAction action = ODataActionPayloadDeserializer.GetAction(context);
// Assert
Assert.NotNull(action);
Assert.Equal("Wash", action.Name);
}
/// <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;
}
/// <inheritdoc />
public sealed override object ReadInline(object item, IEdmTypeReference edmType, ODataDeserializerContext readContext)
{
if (item == null)
{
return null;
}
if (readContext.IsUntyped)
{
Contract.Assert(edmType.TypeKind() == EdmTypeKind.Enum);
return new EdmEnumObject((IEdmEnumTypeReference)edmType, ((ODataEnumValue)item).Value);
}
Type clrType = EdmLibHelpers.GetClrType(edmType, readContext.Model);
return EnumDeserializationHelpers.ConvertEnumValue(item, clrType);
}
public void Can_find_action_overload_using_bindingparameter_type()
{
// Arrange
IEdmModel model = GetModel();
string url = "Vehicles(8)/System.Web.OData.Builder.TestModels.Car/Wash";
ODataPath path = new DefaultODataPathHandler().Parse(model, url);
Assert.NotNull(path); // Guard
ODataDeserializerContext context = new ODataDeserializerContext { Path = path, Model = model };
// Act
IEdmAction action = ODataActionPayloadDeserializer.GetAction(context);
// Assert
Assert.NotNull(action);
Assert.Equal("Wash", action.Name);
}
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);
}
}
public void ReadInline_Calls_ReadPrimitive()
{
// Arrange
IEdmPrimitiveTypeReference primitiveType = EdmCoreModel.Instance.GetInt32(isNullable: true);
Mock<ODataPrimitiveDeserializer> deserializer = new Mock<ODataPrimitiveDeserializer>();
ODataProperty property = new ODataProperty();
ODataDeserializerContext readContext = new ODataDeserializerContext();
deserializer.Setup(d => d.ReadPrimitive(property, readContext)).Returns(42).Verifiable();
// Act
var result = deserializer.Object.ReadInline(property, primitiveType, readContext);
// Assert
deserializer.Verify();
Assert.Equal(42, result);
}
public void ReadInline_Calls_ReadComplexValue()
{
// Arrange
ODataDeserializerProvider deserializerProvider = new DefaultODataDeserializerProvider();
Mock<ODataComplexTypeDeserializer> deserializer = new Mock<ODataComplexTypeDeserializer>(deserializerProvider);
ODataComplexValue item = new ODataComplexValue();
ODataDeserializerContext readContext = new ODataDeserializerContext();
deserializer.CallBase = true;
deserializer.Setup(d => d.ReadComplexValue(item, _addressEdmType, readContext)).Returns(42).Verifiable();
// Act
object result = deserializer.Object.ReadInline(item, _addressEdmType, readContext);
// Assert
deserializer.Verify();
Assert.Equal(42, result);
}
public void ReadComplexValue_CanReadDynamicCollectionPropertiesForOpenComplexType()
{
// Arrange
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.ComplexType <SimpleOpenAddress>();
builder.EnumType <SimpleEnum>();
IEdmModel model = builder.GetEdmModel();
IEdmComplexTypeReference addressTypeReference =
model.GetEdmTypeReference(typeof(SimpleOpenAddress)).AsComplex();
var deserializerProvider = new DefaultODataDeserializerProvider();
var deserializer = new ODataComplexTypeDeserializer(deserializerProvider);
ODataEnumValue enumValue = new ODataEnumValue("Third", typeof(SimpleEnum).FullName);
ODataCollectionValue collectionValue = new ODataCollectionValue
{
TypeName = "Collection(" + typeof(SimpleEnum).FullName + ")",
Items = new[] { enumValue, enumValue }
};
ODataComplexValue complexValue = new ODataComplexValue
{
Properties = new[]
{
// declared properties
new ODataProperty {
Name = "Street", Value = "My Way #599"
},
// dynamic properties
new ODataProperty {
Name = "CollectionProperty", Value = collectionValue
}
},
TypeName = typeof(SimpleOpenAddress).FullName
};
ODataDeserializerContext readContext = new ODataDeserializerContext()
{
Model = model
};
// Act
SimpleOpenAddress address = deserializer.ReadComplexValue(complexValue, addressTypeReference, readContext)
as SimpleOpenAddress;
// Assert
Assert.NotNull(address);
// Verify the declared properties
Assert.Equal("My Way #599", address.Street);
Assert.Null(address.City);
// Verify the dynamic properties
Assert.NotNull(address.Properties);
Assert.Equal(1, address.Properties.Count());
var collectionValues = Assert.IsType <List <SimpleEnum> >(address.Properties["CollectionProperty"]);
Assert.NotNull(collectionValues);
Assert.Equal(2, collectionValues.Count());
Assert.Equal(SimpleEnum.Third, collectionValues[0]);
Assert.Equal(SimpleEnum.Third, collectionValues[1]);
}
/// <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(), typeof(ODataMediaTypeFormatter).Name));
}
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);
}
}
/// <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() || !edmType.AsCollection().ElementType().IsStructured())
{
throw Error.Argument("edmType", SRResources.TypeMustBeResourceSet, edmType.ToTraceString());
}
ODataResourceSetWrapper resourceSet = item as ODataResourceSetWrapper;
if (resourceSet == null)
{
throw Error.Argument("item", SRResources.ArgumentMustBeOfType, typeof(ODataResourceSetWrapper).Name);
}
// Recursion guard to avoid stack overflows
RuntimeHelpers.EnsureSufficientExecutionStack();
IEdmStructuredTypeReference elementType = edmType.AsCollection().ElementType().AsStructured();
IEnumerable result = ReadResourceSet(resourceSet, elementType, readContext);
if (result != null && elementType.IsComplex())
{
if (readContext.IsUntyped)
{
EdmComplexObjectCollection complexCollection = new EdmComplexObjectCollection(edmType.AsCollection());
foreach (EdmComplexObject complexObject in result)
{
complexCollection.Add(complexObject);
}
return(complexCollection);
}
else
{
Type elementClrType = EdmLibHelpers.GetClrType(elementType, readContext.Model);
IEnumerable castedResult =
CastMethodInfo.MakeGenericMethod(elementClrType).Invoke(null, new object[] { result }) as
IEnumerable;
return(castedResult);
}
}
else
{
return(result);
}
}
public void ReadEntry_CanReadDynamicPropertiesForInheritanceOpenEntityType()
{
// Arrange
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.EntityType <SimpleOpenCustomer>();
builder.EnumType <SimpleEnum>();
IEdmModel model = builder.GetEdmModel();
IEdmEntityTypeReference vipCustomerTypeReference = model.GetEdmTypeReference(typeof(SimpleVipCustomer)).AsEntity();
var deserializerProvider = new DefaultODataDeserializerProvider();
var deserializer = new ODataEntityDeserializer(deserializerProvider);
ODataEntry odataEntry = new ODataEntry
{
Properties = new[]
{
// declared properties
new ODataProperty {
Name = "CustomerId", Value = 121
},
new ODataProperty {
Name = "Name", Value = "VipName #121"
},
new ODataProperty {
Name = "VipNum", Value = "Vip Num 001"
},
// dynamic properties
new ODataProperty {
Name = "GuidProperty", Value = new Guid("181D3A20-B41A-489F-9F15-F91F0F6C9ECA")
},
},
TypeName = typeof(SimpleVipCustomer).FullName
};
ODataDeserializerContext readContext = new ODataDeserializerContext()
{
Model = model
};
ODataEntryWithNavigationLinks entry = new ODataEntryWithNavigationLinks(odataEntry);
// Act
SimpleVipCustomer customer = deserializer.ReadEntry(entry, vipCustomerTypeReference, readContext)
as SimpleVipCustomer;
// Assert
Assert.NotNull(customer);
// Verify the declared properties
Assert.Equal(121, customer.CustomerId);
Assert.Equal("VipName #121", customer.Name);
Assert.Equal("Vip Num 001", customer.VipNum);
// Verify the dynamic properties
Assert.NotNull(customer.CustomerProperties);
Assert.Equal(1, customer.CustomerProperties.Count());
Assert.Equal(new Guid("181D3A20-B41A-489F-9F15-F91F0F6C9ECA"), customer.CustomerProperties["GuidProperty"]);
}
/// <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);
}
}
public void ReadComplexValue_CanReadNestedOpenComplexType()
{
// Arrange
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.ComplexType <SimpleOpenAddress>();
builder.ComplexType <SimpleOpenZipCode>();
IEdmModel model = builder.GetEdmModel();
IEdmComplexTypeReference addressTypeReference = model.GetEdmTypeReference(typeof(SimpleOpenAddress)).AsComplex();
var deserializerProvider = new DefaultODataDeserializerProvider();
var deserializer = new ODataComplexTypeDeserializer(deserializerProvider);
ODataComplexValue zipCodeComplexValue = new ODataComplexValue
{
Properties = new[]
{
// declared property
new ODataProperty {
Name = "Code", Value = 101
},
// dynamic property
new ODataProperty {
Name = "DateTimeProperty", Value = new DateTimeOffset(new DateTime(2014, 4, 22))
}
},
TypeName = typeof(SimpleOpenZipCode).FullName
};
ODataComplexValue addressComplexValue = new ODataComplexValue
{
Properties = new[]
{
// declared properties
new ODataProperty {
Name = "Street", Value = "TopStreet"
},
new ODataProperty {
Name = "City", Value = "TopCity"
},
// dynamic properties
new ODataProperty {
Name = "DoubleProperty", Value = 1.179
},
new ODataProperty {
Name = "ZipCodeProperty", Value = zipCodeComplexValue
}
},
TypeName = typeof(SimpleOpenAddress).FullName
};
ODataDeserializerContext readContext = new ODataDeserializerContext()
{
Model = model
};
// Act
SimpleOpenAddress address = deserializer.ReadComplexValue(addressComplexValue, addressTypeReference, readContext)
as SimpleOpenAddress;
// Assert
Assert.NotNull(address);
// Verify the declared properties
Assert.Equal("TopStreet", address.Street);
Assert.Equal("TopCity", address.City);
// Verify the dynamic properties
Assert.NotNull(address.Properties);
Assert.Equal(2, address.Properties.Count());
Assert.Equal(1.179, address.Properties["DoubleProperty"]);
// nested open complex type
SimpleOpenZipCode zipCode = Assert.IsType <SimpleOpenZipCode>(address.Properties["ZipCodeProperty"]);
Assert.Equal(101, zipCode.Code);
Assert.Equal(1, zipCode.Properties.Count());
Assert.Equal(new DateTimeOffset(new DateTime(2014, 4, 22)), zipCode.Properties["DateTimeProperty"]);
}
public void ReadComplexValue_CanReadDynamicPropertiesForOpenComplexType()
{
// Arrange
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.ComplexType <SimpleOpenAddress>();
builder.EnumType <SimpleEnum>();
IEdmModel model = builder.GetEdmModel();
IEdmComplexTypeReference addressTypeReference = model.GetEdmTypeReference(typeof(SimpleOpenAddress)).AsComplex();
var deserializerProvider = new Mock <ODataDeserializerProvider>().Object;
var deserializer = new ODataComplexTypeDeserializer(deserializerProvider);
ODataEnumValue enumValue = new ODataEnumValue("Third", typeof(SimpleEnum).FullName);
ODataComplexValue complexValue = new ODataComplexValue
{
Properties = new[]
{
// declared properties
new ODataProperty {
Name = "Street", Value = "My Way #599"
},
new ODataProperty {
Name = "City", Value = "Redmond & Shanghai"
},
// dynamic properties
new ODataProperty {
Name = "GuidProperty", Value = new Guid("181D3A20-B41A-489F-9F15-F91F0F6C9ECA")
},
new ODataProperty {
Name = "EnumValue", Value = enumValue
},
new ODataProperty {
Name = "DateTimeProperty", Value = new DateTimeOffset(new DateTime(1992, 1, 1))
}
},
TypeName = typeof(SimpleOpenAddress).FullName
};
ODataDeserializerContext readContext = new ODataDeserializerContext()
{
Model = model
};
// Act
SimpleOpenAddress address = deserializer.ReadComplexValue(complexValue, addressTypeReference, readContext)
as SimpleOpenAddress;
// Assert
Assert.NotNull(address);
// Verify the declared properties
Assert.Equal("My Way #599", address.Street);
Assert.Equal("Redmond & Shanghai", address.City);
// Verify the dynamic properties
Assert.NotNull(address.Properties);
Assert.Equal(3, address.Properties.Count());
Assert.Equal(new Guid("181D3A20-B41A-489F-9F15-F91F0F6C9ECA"), address.Properties["GuidProperty"]);
Assert.Equal(SimpleEnum.Third, address.Properties["EnumValue"]);
Assert.Equal(new DateTimeOffset(new DateTime(1992, 1, 1)), address.Properties["DateTimeProperty"]);
}
/// <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(), typeof(ODataMediaTypeFormatter)));
}
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.IsComplex())
{
EdmComplexObjectCollection complexCollection = new EdmComplexObjectCollection(collectionType);
foreach (EdmComplexObject complexObject in result)
{
complexCollection.Add(complexObject);
}
return(complexCollection);
}
else if (readContext.IsUntyped && elementType.IsEnum())
{
EdmEnumObjectCollection enumCollection = new EdmEnumObjectCollection(collectionType);
foreach (EdmEnumObject enumObject in result)
{
enumCollection.Add(enumObject);
}
return(enumCollection);
}
else
{
Type elementClrType = EdmLibHelpers.GetClrType(elementType, readContext.Model);
IEnumerable castedResult = _castMethodInfo.MakeGenericMethod(elementClrType).Invoke(null, new object[] { result }) as IEnumerable;
return(castedResult);
}
}
return(null);
}
/// <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));
}
internal static object CreateResource(IEdmComplexTypeReference edmComplexType, ODataDeserializerContext readContext)
{
Contract.Assert(edmComplexType != null);
if (readContext.IsUntyped)
{
return(new EdmComplexObject(edmComplexType));
}
else
{
Type clrType = EdmLibHelpers.GetClrType(edmComplexType, readContext.Model);
if (clrType == null)
{
throw Error.InvalidOperation(SRResources.MappingDoesNotContainEntityType, edmComplexType.FullName());
}
return(Activator.CreateInstance(clrType));
}
}
/// <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)
{
item = property.Value;
}
if (readContext.IsUntyped)
{
Contract.Assert(edmType.TypeKind() == EdmTypeKind.Enum);
return(new EdmEnumObject((IEdmEnumTypeReference)edmType, ((ODataEnumValue)item).Value));
}
Type clrType = EdmLibHelpers.GetClrType(edmType, readContext.Model);
return(EnumDeserializationHelpers.ConvertEnumValue(item, clrType));
}
/// <inheritdoc />
public sealed override object ReadInline(object item, IEdmTypeReference edmType, ODataDeserializerContext readContext)
{
if (readContext == null)
{
throw Error.ArgumentNull("readContext");
}
if (item == null)
{
return(null);
}
ODataComplexValue complexValue = item as ODataComplexValue;
if (complexValue == null)
{
throw Error.Argument("item", SRResources.ArgumentMustBeOfType, typeof(ODataComplexValue).Name);
}
if (!edmType.IsComplex())
{
throw Error.Argument("edmType", SRResources.ArgumentMustBeOfType, EdmTypeKind.Complex);
}
// Recursion guard to avoid stack overflows
RuntimeHelpers.EnsureSufficientExecutionStack();
return(ReadComplexValue(complexValue, edmType.AsComplex(), readContext));
}
/// <inheritdoc />
public sealed override object ReadInline(object item, IEdmTypeReference edmType, ODataDeserializerContext readContext)
{
if (item == null)
{
return(null);
}
Type clrType = EdmLibHelpers.GetClrType(edmType, readContext.Model);
return(EnumDeserializationHelpers.ConvertEnumValue(item, clrType));
}
private object ReadNestedResourceInline(ODataResourceWrapper resourceWrapper, IEdmTypeReference edmType, ODataDeserializerContext readContext)
{
Contract.Assert(resourceWrapper != null);
Contract.Assert(edmType != null);
Contract.Assert(readContext != null);
ODataEdmTypeDeserializer deserializer = DeserializerProvider.GetEdmTypeDeserializer(edmType);
if (deserializer == null)
{
throw new SerializationException(Error.Format(SRResources.TypeCannotBeDeserialized,
edmType.FullName(), typeof(ODataMediaTypeFormatter)));
}
IEdmStructuredTypeReference structuredType = edmType.AsStructured();
var nestedReadContext = new ODataDeserializerContext
{
Path = readContext.Path,
Model = readContext.Model,
};
if (readContext.IsUntyped)
{
if (structuredType.IsEntity())
{
nestedReadContext.ResourceType = typeof(EdmEntityObject);
}
else
{
nestedReadContext.ResourceType = typeof(EdmComplexObject);
}
}
else
{
Type clrType = EdmLibHelpers.GetClrType(structuredType, readContext.Model);
if (clrType == null)
{
throw new ODataException(
Error.Format(SRResources.MappingDoesNotContainResourceType, structuredType.FullName()));
}
nestedReadContext.ResourceType = clrType;
}
return(deserializer.ReadInline(resourceWrapper, edmType, nestedReadContext));
}
/// <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 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));
}
else if (propertyKind == EdmTypeKind.Enum)
{
propertyValue = EnumDeserializationHelpers.ConvertEnumValue(propertyValue,
GetPropertyType(resource, propertyName));
}
}
SetProperty(resource, propertyName, propertyValue);
}
}
/// <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);
}
}
private void ApplyDynamicResourceInNestedProperty(string propertyName, object resource, IEdmStructuredTypeReference resourceStructuredType,
ODataResourceWrapper resourceWrapper, ODataDeserializerContext readContext)
{
Contract.Assert(resource != null);
Contract.Assert(readContext != null);
IEdmSchemaType elementType = readContext.Model.FindDeclaredType(resourceWrapper.Resource.TypeName);
IEdmTypeReference edmTypeReference = elementType.ToEdmTypeReference(true);
object value = ReadNestedResourceInline(resourceWrapper, edmTypeReference, readContext);
DeserializationHelpers.SetDynamicProperty(resource, propertyName, value,
resourceStructuredType.StructuredDefinition(), readContext.Model);
}
/// <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)
{
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);
}
}
}
}
/// <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 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);
}
/// <summary>
/// Deserializes the given <paramref name="resourceSet"/> under the given <paramref name="readContext"/>.
/// </summary>
/// <param name="resourceSet">The resource set to deserialize.</param>
/// <param name="readContext">The deserializer context.</param>
/// <param name="elementType">The element type of the resource set being read.</param>
/// <returns>The deserialized resource set object.</returns>
public virtual IEnumerable ReadResourceSet(ODataResourceSetWrapper resourceSet, IEdmStructuredTypeReference elementType, ODataDeserializerContext readContext)
{
ODataEdmTypeDeserializer deserializer = DeserializerProvider.GetEdmTypeDeserializer(elementType);
if (deserializer == null)
{
throw new SerializationException(
Error.Format(SRResources.TypeCannotBeDeserialized, elementType.FullName(), typeof(ODataMediaTypeFormatter).Name));
}
foreach (ODataResourceWrapper resourceWrapper in resourceSet.Resources)
{
yield return(deserializer.ReadInline(resourceWrapper, elementType, readContext));
}
}
public void ReadEntry_CanReadDynamicPropertiesForOpenEntityType()
{
// Arrange
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.EntityType <SimpleOpenCustomer>();
builder.EnumType <SimpleEnum>();
IEdmModel model = builder.GetEdmModel();
IEdmEntityTypeReference customerTypeReference = model.GetEdmTypeReference(typeof(SimpleOpenCustomer)).AsEntity();
var deserializerProvider = new DefaultODataDeserializerProvider();
var deserializer = new ODataEntityDeserializer(deserializerProvider);
ODataEnumValue enumValue = new ODataEnumValue("Third", typeof(SimpleEnum).FullName);
ODataComplexValue[] complexValues =
{
new ODataComplexValue
{
TypeName = typeof(SimpleOpenAddress).FullName,
Properties = new[]
{
// declared properties
new ODataProperty {
Name = "Street", Value = "Street 1"
},
new ODataProperty {
Name = "City", Value = "City 1"
},
// dynamic properties
new ODataProperty
{
Name = "DateTimeProperty",
Value = new DateTimeOffset(new DateTime(2014, 5, 6))
}
}
},
new ODataComplexValue
{
TypeName = typeof(SimpleOpenAddress).FullName,
Properties = new[]
{
// declared properties
new ODataProperty {
Name = "Street", Value = "Street 2"
},
new ODataProperty {
Name = "City", Value = "City 2"
},
// dynamic properties
new ODataProperty
{
Name = "ArrayProperty",
Value = new ODataCollectionValue{
TypeName = "Collection(Edm.Int32)", Items = new[]{ 1, 2, 3, 4 }
}
}
}
}
};
ODataCollectionValue collectionValue = new ODataCollectionValue
{
TypeName = "Collection(" + typeof(SimpleOpenAddress).FullName + ")",
Items = complexValues
};
ODataEntry odataEntry = new ODataEntry
{
Properties = new[]
{
// declared properties
new ODataProperty {
Name = "CustomerId", Value = 991
},
new ODataProperty {
Name = "Name", Value = "Name #991"
},
// dynamic properties
new ODataProperty {
Name = "GuidProperty", Value = new Guid("181D3A20-B41A-489F-9F15-F91F0F6C9ECA")
},
new ODataProperty {
Name = "EnumValue", Value = enumValue
},
new ODataProperty {
Name = "CollectionProperty", Value = collectionValue
}
},
TypeName = typeof(SimpleOpenCustomer).FullName
};
ODataDeserializerContext readContext = new ODataDeserializerContext()
{
Model = model
};
ODataEntryWithNavigationLinks entry = new ODataEntryWithNavigationLinks(odataEntry);
// Act
SimpleOpenCustomer customer = deserializer.ReadEntry(entry, customerTypeReference, readContext)
as SimpleOpenCustomer;
// Assert
Assert.NotNull(customer);
// Verify the declared properties
Assert.Equal(991, customer.CustomerId);
Assert.Equal("Name #991", customer.Name);
// Verify the dynamic properties
Assert.NotNull(customer.CustomerProperties);
Assert.Equal(3, customer.CustomerProperties.Count());
Assert.Equal(new Guid("181D3A20-B41A-489F-9F15-F91F0F6C9ECA"), customer.CustomerProperties["GuidProperty"]);
Assert.Equal(SimpleEnum.Third, customer.CustomerProperties["EnumValue"]);
// Verify the dynamic collection property
var collectionValues = Assert.IsType <List <SimpleOpenAddress> >(customer.CustomerProperties["CollectionProperty"]);
Assert.NotNull(collectionValues);
Assert.Equal(2, collectionValues.Count());
Assert.Equal(new DateTimeOffset(new DateTime(2014, 5, 6)), collectionValues[0].Properties["DateTimeProperty"]);
Assert.Equal(new List <int> {
1, 2, 3, 4
}, collectionValues[1].Properties["ArrayProperty"]);
}
private void ApplyResourceProperties(object resource, ODataResourceWrapper resourceWrapper,
IEdmStructuredTypeReference structuredType, ODataDeserializerContext readContext)
{
ApplyStructuralProperties(resource, resourceWrapper, structuredType, readContext);
ApplyNestedProperties(resource, resourceWrapper, structuredType, readContext);
}
/// <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));
}
}
}
/// <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);
}
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);
}
}
/// <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);
}
private static object ConvertComplexValue(ODataComplexValue complexValue, ref IEdmTypeReference propertyType,
ODataDeserializerProvider deserializerProvider, ODataDeserializerContext readContext)
{
IEdmComplexTypeReference edmComplexType;
if (propertyType == null)
{
// open complex property
Contract.Assert(!String.IsNullOrEmpty(complexValue.TypeName),
"ODataLib should have verified that open complex value has a type name since we provided metadata.");
IEdmModel model = readContext.Model;
IEdmType edmType = model.FindType(complexValue.TypeName);
Contract.Assert(edmType.TypeKind == EdmTypeKind.Complex, "ODataLib should have verified that complex value has a complex resource type.");
edmComplexType = new EdmComplexTypeReference(edmType as IEdmComplexType, isNullable: true);
propertyType = edmComplexType;
}
else
{
edmComplexType = propertyType.AsComplex();
}
ODataEdmTypeDeserializer deserializer = deserializerProvider.GetEdmTypeDeserializer(edmComplexType);
return(deserializer.ReadInline(complexValue, 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(), typeof(ODataMediaTypeFormatter)));
}
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);
}
