/// <summary>
/// Initializes a new instance of the <see cref="ODataMediaTypeFormatter"/> class.
/// </summary>
/// <param name="deserializerProvider">The <see cref="ODataDeserializerProvider"/> to use.</param>
/// <param name="serializerProvider">The <see cref="ODataSerializerProvider"/> to use.</param>
/// <param name="payloadKinds">The kind of payloads this formatter supports.</param>
public ODataMediaTypeFormatter(ODataDeserializerProvider deserializerProvider, ODataSerializerProvider serializerProvider,
IEnumerable<ODataPayloadKind> payloadKinds)
{
if (deserializerProvider == null)
{
throw Error.ArgumentNull("deserializerProvider");
}
if (serializerProvider == null)
{
throw Error.ArgumentNull("serializerProvider");
}
if (payloadKinds == null)
{
throw Error.ArgumentNull("payloadKinds");
}
_deserializerProvider = deserializerProvider;
_serializerProvider = serializerProvider;
_payloadKinds = payloadKinds;
// Maxing out the received message size as we depend on the hosting layer to enforce this limit.
MessageWriterSettings = new ODataMessageWriterSettings
{
Indent = true,
DisableMessageStreamDisposal = true,
MessageQuotas = new ODataMessageQuotas { MaxReceivedMessageSize = Int64.MaxValue }
};
MessageReaderSettings = new ODataMessageReaderSettings
{
DisableMessageStreamDisposal = true,
MessageQuotas = new ODataMessageQuotas { MaxReceivedMessageSize = Int64.MaxValue },
};
_version = DefaultODataVersion;
}
internal static void ApplyProperty(ODataProperty property, IEdmStructuredTypeReference resourceType, object resource,
ODataDeserializerProvider deserializerProvider, ODataDeserializerContext readContext)
{
IEdmProperty edmProperty = resourceType.FindProperty(property.Name);
string propertyName = property.Name;
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);
}
else
{
if (propertyKind == EdmTypeKind.Primitive && !readContext.IsUntyped)
{
value = EdmPrimitiveHelpers.ConvertPrimitiveValue(value, GetPropertyType(resource, propertyName));
}
SetProperty(resource, propertyName, value);
}
}
internal static void ApplyProperty(ODataProperty property, IEdmStructuredTypeReference resourceType, object resource, ODataDeserializerProvider deserializerProvider, ODataDeserializerContext readContext)
{
IEdmProperty edmProperty = resourceType.FindProperty(property.Name);
string propertyName = property.Name;
IEdmTypeReference propertyType = edmProperty != null ? edmProperty.Type : null; // open properties have null values
// If we are in patch mode and we are deserializing an entity object then we are updating Delta<T> and not T.
bool isDelta = readContext.IsPatchMode && resourceType.IsEntity();
EdmTypeKind propertyKind;
object value = ConvertValue(property.Value, ref propertyType, deserializerProvider, readContext, out propertyKind);
if (propertyKind == EdmTypeKind.Collection)
{
SetCollectionProperty(resource, propertyName, isDelta, value);
}
else
{
if (propertyKind == EdmTypeKind.Primitive)
{
value = EdmPrimitiveHelpers.ConvertPrimitiveValue(value, GetPropertyType(resource, propertyName, isDelta));
}
SetProperty(resource, propertyName, isDelta, value);
}
}
private static ODataMediaTypeFormatter CreateRawValue(ODataSerializerProvider serializerProvider, ODataDeserializerProvider deserializerProvider)
{
ODataMediaTypeFormatter formatter = CreateFormatterWithoutMediaTypes(serializerProvider, deserializerProvider, ODataPayloadKind.Value);
formatter.MediaTypeMappings.Add(new ODataPrimitiveValueMediaTypeMapping());
formatter.MediaTypeMappings.Add(new ODataBinaryValueMediaTypeMapping());
return formatter;
}
private static ODataMediaTypeFormatter CreateApplicationJson(ODataSerializerProvider serializerProvider, ODataDeserializerProvider deserializerProvider)
{
ODataMediaTypeFormatter formatter = CreateFormatterWithoutMediaTypes(
serializerProvider,
deserializerProvider,
ODataPayloadKind.Feed,
ODataPayloadKind.Entry,
ODataPayloadKind.Property,
ODataPayloadKind.EntityReferenceLink,
ODataPayloadKind.EntityReferenceLinks,
ODataPayloadKind.Collection,
ODataPayloadKind.ServiceDocument,
ODataPayloadKind.Error,
ODataPayloadKind.Parameter);
// Add minimal metadata as the first media type so it gets used when the request doesn't
// ask for a specific content type
formatter.SupportedMediaTypes.Add(ODataMediaTypes.ApplicationJsonODataMinimalMetadataStreamingTrue);
formatter.SupportedMediaTypes.Add(ODataMediaTypes.ApplicationJsonODataMinimalMetadataStreamingFalse);
formatter.SupportedMediaTypes.Add(ODataMediaTypes.ApplicationJsonODataMinimalMetadata);
formatter.SupportedMediaTypes.Add(ODataMediaTypes.ApplicationJsonODataFullMetadataStreamingTrue);
formatter.SupportedMediaTypes.Add(ODataMediaTypes.ApplicationJsonODataFullMetadataStreamingFalse);
formatter.SupportedMediaTypes.Add(ODataMediaTypes.ApplicationJsonODataFullMetadata);
formatter.SupportedMediaTypes.Add(ODataMediaTypes.ApplicationJsonODataNoMetadataStreamingTrue);
formatter.SupportedMediaTypes.Add(ODataMediaTypes.ApplicationJsonODataNoMetadataStreamingFalse);
formatter.SupportedMediaTypes.Add(ODataMediaTypes.ApplicationJsonODataNoMetadata);
formatter.SupportedMediaTypes.Add(ODataMediaTypes.ApplicationJsonODataVerbose);
formatter.SupportedMediaTypes.Add(ODataMediaTypes.ApplicationJsonStreamingTrue);
formatter.SupportedMediaTypes.Add(ODataMediaTypes.ApplicationJsonStreamingFalse);
formatter.SupportedMediaTypes.Add(ODataMediaTypes.ApplicationJson);
return formatter;
}
private static ODataMediaTypeFormatter CreateApplicationAtomXmlTypeFeed(ODataSerializerProvider serializerProvider, ODataDeserializerProvider deserializerProvider)
{
ODataMediaTypeFormatter formatter = CreateFormatterWithoutMediaTypes(serializerProvider, deserializerProvider, ODataPayloadKind.Feed);
formatter.SupportedMediaTypes.Add(ODataMediaTypes.ApplicationAtomXmlTypeFeed);
formatter.SupportedMediaTypes.Add(ODataMediaTypes.ApplicationAtomXml);
return formatter;
}
public ODataActionPayloadDeserializer(Type payloadType, ODataDeserializerProvider provider)
: base(ODataPayloadKind.Parameter)
{
Contract.Assert(payloadType != null);
Contract.Assert(provider != null);
_payloadType = payloadType;
_provider = provider;
}
private static ODataMediaTypeFormatter CreateApplicationAtomSvcXml(ODataSerializerProvider serializerProvider, ODataDeserializerProvider deserializerProvider)
{
ODataMediaTypeFormatter formatter = CreateFormatterWithoutMediaTypes(serializerProvider, deserializerProvider, ODataPayloadKind.ServiceDocument);
formatter.SupportedMediaTypes.Add(ODataMediaTypes.ApplicationAtomSvcXml);
formatter.AddDollarFormatQueryStringMappings();
return formatter;
}
/// <summary>
/// Initializes a new instance of the <see cref="ODataEdmTypeDeserializer"/> class.
/// </summary>
/// <param name="payloadKind">The kind of OData payload this deserializer handles.</param>
/// <param name="deserializerProvider">The <see cref="ODataDeserializerProvider"/>.</param>
protected ODataEdmTypeDeserializer(ODataPayloadKind payloadKind, ODataDeserializerProvider deserializerProvider)
: this(payloadKind)
{
if (deserializerProvider == null)
{
throw Error.ArgumentNull("deserializerProvider");
}
DeserializerProvider = deserializerProvider;
}
/// <summary>
/// Initializes a new instance of the <see cref="ODataActionPayloadDeserializer"/> class.
/// </summary>
/// <param name="deserializerProvider">The deserializer provider to use to read inner objects.</param>
public ODataActionPayloadDeserializer(ODataDeserializerProvider deserializerProvider)
: base(ODataPayloadKind.Parameter)
{
if (deserializerProvider == null)
{
throw Error.ArgumentNull("deserializerProvider");
}
DeserializerProvider = deserializerProvider;
}
/// <summary>
/// Initializes a new instance of the <see cref="ODataFeedDeserializer"/> class.
/// </summary>
/// <param name="edmType">The entity collection type that this deserializer can read.</param>
/// <param name="deserializerProvider">The deserializer provider to use to read inner objects.</param>
public ODataFeedDeserializer(IEdmCollectionTypeReference edmType, ODataDeserializerProvider deserializerProvider)
: base(edmType, ODataPayloadKind.Feed, deserializerProvider)
{
CollectionType = edmType;
if (!edmType.ElementType().IsEntity())
{
throw Error.Argument("edmType", SRResources.TypeMustBeEntityCollection, edmType.ElementType().FullName(), typeof(IEdmEntityType).Name);
}
EntityType = CollectionType.ElementType().AsEntity();
}
private static object ConvertCollectionValue(ODataCollectionValue collection, IEdmTypeReference propertyType,
ODataDeserializerProvider deserializerProvider, ODataDeserializerContext readContext)
{
IEdmCollectionTypeReference 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, readContext));
}
/// <summary>
/// Initializes a new instance of the <see cref="ODataFeedDeserializer"/> class.
/// </summary>
/// <param name="edmType">The entity collection type that this deserializer can read.</param>
/// <param name="deserializerProvider">The deserializer provider to use to read inner objects.</param>
public ODataFeedDeserializer(IEdmCollectionTypeReference edmType, ODataDeserializerProvider deserializerProvider)
: base(edmType, ODataPayloadKind.Feed, deserializerProvider)
{
CollectionType = edmType;
if (!edmType.ElementType().IsEntity())
{
throw Error.Argument("edmType", SRResources.TypeMustBeEntityCollection, edmType.ElementType().FullName(), typeof(IEdmEntityType).Name);
}
EntityType = CollectionType.ElementType().AsEntity();
}
private static ODataMediaTypeFormatter CreateApplicationAtomXmlTypeEntry(ODataSerializerProvider serializerProvider, ODataDeserializerProvider deserializerProvider)
{
ODataMediaTypeFormatter formatter = CreateFormatterWithoutMediaTypes(serializerProvider, deserializerProvider, ODataPayloadKind.Entry);
formatter.SupportedMediaTypes.Add(ODataMediaTypes.ApplicationAtomXmlTypeEntry);
formatter.SupportedMediaTypes.Add(ODataMediaTypes.ApplicationAtomXml);
formatter.AddDollarFormatQueryStringMappings();
formatter.AddQueryStringMapping(DollarFormat, AtomFormat, ODataMediaTypes.ApplicationAtomXml);
return formatter;
}
internal ODataMediaTypeFormatter(ODataDeserializerProvider oDataDeserializerProvider, ODataSerializerProvider oDataSerializerProvider)
{
ODataDeserializerProvider = oDataDeserializerProvider;
Model = oDataDeserializerProvider.EdmModel;
ODataSerializerProvider = oDataSerializerProvider;
SupportedMediaTypes.Add(ODataFormatterConstants.ApplicationAtomXmlMediaType);
SupportedMediaTypes.Add(ODataFormatterConstants.ApplicationJsonMediaType);
SupportedMediaTypes.Add(ODataFormatterConstants.ApplicationXmlMediaType);
SupportedEncodings.Add(new UnicodeEncoding(bigEndian: false, byteOrderMark: true, throwOnInvalidBytes: true));
SupportedEncodings.Add(new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true));
}
public ODataEntityDeserializerTests()
{
_edmModel = EdmTestHelpers.GetModel();
IEdmEntitySet entitySet = _edmModel.EntityContainers().Single().FindEntitySet("Products");
_readContext = new ODataDeserializerContext
{
Path = new ODataPath(new EntitySetPathSegment(entitySet)),
Model = _edmModel
};
_productEdmType = _edmModel.GetEdmTypeReference(typeof(Product)).AsEntity();
_supplierEdmType = _edmModel.GetEdmTypeReference(typeof(Supplier)).AsEntity();
_deserializerProvider = new DefaultODataDeserializerProvider();
}
public ODataEntityDeserializerTests()
{
_edmModel = EdmTestHelpers.GetModel();
IEdmEntitySet entitySet = _edmModel.EntityContainers().Single().FindEntitySet("Products");
_readContext = new ODataDeserializerContext
{
Path = new ODataPath(new EntitySetPathSegment(entitySet)),
Model = _edmModel
};
_productEdmType = _edmModel.GetEdmTypeReference(typeof(Product)).AsEntity();
_supplierEdmType = _edmModel.GetEdmTypeReference(typeof(Supplier)).AsEntity();
_deserializerProvider = new DefaultODataDeserializerProvider();
}
/// <summary>
/// Creates a list of media type formatters to handle OData.
/// </summary>
/// <param name="serializerProvider">The serializer provider to use.</param>
/// <param name="deserializerProvider">The deserializer provider to use.</param>
/// <returns>A list of media type formatters to handle OData.</returns>
public static IList<ODataMediaTypeFormatter> Create(ODataSerializerProvider serializerProvider, ODataDeserializerProvider deserializerProvider)
{
return new List<ODataMediaTypeFormatter>()
{
// Create atomsvc+xml formatter first to handle service document requests without an Accept header in an XML format
CreateApplicationAtomSvcXml(serializerProvider, deserializerProvider),
// Create JSON formatter next so it gets used when the request doesn't ask for a specific content type
CreateApplicationJson(serializerProvider, deserializerProvider),
CreateApplicationAtomXmlTypeFeed(serializerProvider, deserializerProvider),
CreateApplicationAtomXmlTypeEntry(serializerProvider, deserializerProvider),
CreateApplicationXml(serializerProvider, deserializerProvider),
CreateTextXml(serializerProvider, deserializerProvider)
};
}
private ODataMediaTypeFormatter(ODataDeserializerProvider deserializerProvider,
ODataSerializerProvider serializerProvider,
IEnumerable<ODataPayloadKind> payloadKinds,
ODataVersion version,
HttpRequestMessage request)
{
Contract.Assert(deserializerProvider != null);
Contract.Assert(deserializerProvider.EdmModel != null);
Contract.Assert(serializerProvider != null);
Contract.Assert(payloadKinds != null);
_deserializerProvider = deserializerProvider;
_model = deserializerProvider.EdmModel;
_serializerProvider = serializerProvider;
_payloadKinds = payloadKinds;
_version = version;
_request = request;
}
internal static void ApplyProperty(ODataProperty property, IEdmStructuredTypeReference resourceType, object resource, ODataDeserializerProvider deserializerProvider, ODataDeserializerReadContext readContext)
{
IEdmProperty edmProperty = resourceType.FindProperty(property.Name);
string propertyName = property.Name;
IEdmTypeReference propertyType = edmProperty != null ? edmProperty.Type : null; // open properties have null values
object value = ConvertValue(property.Value, ref propertyType, deserializerProvider, readContext);
// If we are in patch mode and we are deserializing an entity object then we are updating Delta<T> and not T.
if (!readContext.IsPatchMode || !resourceType.IsEntity())
{
resource.GetType().GetProperty(propertyName).SetValue(resource, value, index: null);
}
else
{
(resource as IDelta).TrySetPropertyValue(propertyName, value);
}
}
internal ODataMediaTypeFormatter(ODataDeserializerProvider deserializerProvider,
ODataSerializerProvider serializerProvider,
IEnumerable<ODataPayloadKind> payloadKinds,
ODataVersion version,
HttpRequestMessage request)
{
Contract.Assert(deserializerProvider != null);
Contract.Assert(serializerProvider != null);
Contract.Assert(payloadKinds != null);
_deserializerProvider = deserializerProvider;
_serializerProvider = serializerProvider;
_payloadKinds = payloadKinds;
_version = version;
_request = request;
// Maxing out the received message size as we depend on the hosting layer to enforce this limit.
MessageReaderQuotas = new ODataMessageQuotas { MaxReceivedMessageSize = Int64.MaxValue };
MessageWriterQuotas = new ODataMessageQuotas { MaxReceivedMessageSize = Int64.MaxValue };
}
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);
}
else
{
edmComplexType = propertyType.AsComplex();
}
ODataEdmTypeDeserializer deserializer = deserializerProvider.GetEdmTypeDeserializer(edmComplexType);
return(deserializer.ReadInline(complexValue, readContext));
}
internal static void ApplyProperty(ODataProperty property, IEdmStructuredTypeReference resourceType, object resource, ODataDeserializerProvider deserializerProvider, ODataDeserializerReadContext readContext)
{
IEdmProperty edmProperty = resourceType.FindProperty(property.Name);
string propertyName = property.Name;
IEdmTypeReference propertyType = edmProperty != null ? edmProperty.Type : null; // open properties have null values
object value = ConvertValue(property.Value, ref propertyType, deserializerProvider, readContext);
// If we are in patch mode and we are deserializing an entity object then we are updating Delta<T> and not T.
if (!readContext.IsPatchMode || !resourceType.IsEntity())
{
resource.GetType().GetProperty(propertyName).SetValue(resource, value, index: null);
}
else
{
(resource as IDelta).TrySetPropertyValue(propertyName, value);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ODataCollectionDeserializer"/> class.
/// </summary>
/// <param name="deserializerProvider">The deserializer provider to use to read inner objects.</param>
public ODataCollectionDeserializer(ODataDeserializerProvider deserializerProvider)
: base(ODataPayloadKind.Collection, deserializerProvider)
{
}
private ODataMediaTypeFormatter(ODataMediaTypeFormatter formatter, ODataVersion version,
HttpRequestMessage request)
{
Contract.Assert(formatter._serializerProvider != null);
Contract.Assert(formatter._deserializerProvider != null);
Contract.Assert(formatter._payloadKinds != null);
Contract.Assert(request != null);
// Parameter 1: formatter
// Execept for the other two parameters, this constructor is a copy constructor, and we need to copy
// everything on the other instance.
// Parameter 1A: Copy this class's private fields and internal properties.
_serializerProvider = formatter._serializerProvider;
_deserializerProvider = formatter._deserializerProvider;
_payloadKinds = formatter._payloadKinds;
MessageReaderQuotas = formatter.MessageReaderQuotas;
MessageWriterQuotas = formatter.MessageWriterQuotas;
// Parameter 1B: Copy the base class's properties.
foreach (MediaTypeMapping mediaTypeMapping in formatter.MediaTypeMappings)
{
// MediaTypeMapping doesn't support clone, and its public surface area is immutable anyway.
MediaTypeMappings.Add(mediaTypeMapping);
}
RequiredMemberSelector = formatter.RequiredMemberSelector;
foreach (Encoding supportedEncoding in formatter.SupportedEncodings)
{
// Per-request formatters share the encoding instances with the parent formatter
SupportedEncodings.Add(supportedEncoding);
}
foreach (MediaTypeHeaderValue supportedMediaType in formatter.SupportedMediaTypes)
{
// Per-request formatters share the media type instances with the parent formatter
SupportedMediaTypes.Add(supportedMediaType);
}
// Parameter 2: version
_version = version;
// Parameter 3: request
_request = request;
}
private static ODataMediaTypeFormatter CreateFormatterWithoutMediaTypes(ODataSerializerProvider serializerProvider, ODataDeserializerProvider deserializerProvider, params ODataPayloadKind[] payloadKinds)
{
ODataMediaTypeFormatter formatter = new ODataMediaTypeFormatter(deserializerProvider, serializerProvider, payloadKinds);
AddSupportedEncodings(formatter);
return formatter;
}
public ODataCollectionDeserializer(IEdmCollectionTypeReference edmCollectionType, ODataDeserializerProvider deserializerProvider)
: base(edmCollectionType, ODataPayloadKind.Collection, deserializerProvider)
{
_edmCollectionType = edmCollectionType;
}
internal ODataMediaTypeFormatter(ODataDeserializerProvider deserializerProvider,
ODataSerializerProvider serializerProvider, IEnumerable<ODataPayloadKind> payloadKinds)
: this(deserializerProvider, serializerProvider, payloadKinds, DefaultODataVersion, request: null)
{
}
public ODataEntityDeserializer(IEdmEntityTypeReference edmEntityType, ODataDeserializerProvider deserializerProvider)
: base(edmEntityType, ODataPayloadKind.Entry, deserializerProvider)
{
EdmEntityType = edmEntityType;
}
protected ODataEntryDeserializer(IEdmTypeReference edmType, ODataPayloadKind payloadKind, ODataDeserializerProvider deserializerProvider)
: base(edmType, payloadKind, deserializerProvider)
{
}
protected ODataEntryDeserializer(IEdmTypeReference edmType, ODataPayloadKind payloadKind, ODataDeserializerProvider deserializerProvider)
: this(edmType, payloadKind)
{
DeserializerProvider = deserializerProvider;
}
/// <summary>
/// Initializes a new instance of the <see cref="ODataEntityDeserializer"/> class.
/// </summary>
/// <param name="deserializerProvider">The deserializer provider to use to read inner objects.</param>
public ODataEntityDeserializer(ODataDeserializerProvider deserializerProvider)
: base(ODataPayloadKind.Entry, deserializerProvider)
{
}
internal static void ApplyProperty(ODataProperty property, IEdmStructuredTypeReference resourceType, object resource, ODataDeserializerProvider deserializerProvider, ODataDeserializerContext readContext)
{
IEdmProperty edmProperty = resourceType.FindProperty(property.Name);
string propertyName = property.Name;
IEdmTypeReference propertyType = edmProperty != null ? edmProperty.Type : null; // open properties have null values
// If we are in patch mode and we are deserializing an entity object then we are updating Delta<T> and not T.
bool isDelta = readContext.IsPatchMode && resourceType.IsEntity();
if (isDelta && resourceType.AsEntity().Key().Select(key => key.Name).Contains(propertyName))
{
return;
}
EdmTypeKind propertyKind;
object value = ConvertValue(property.Value, ref propertyType, deserializerProvider, readContext, out propertyKind);
if (propertyKind == EdmTypeKind.Collection)
{
SetCollectionProperty(resource, propertyName, isDelta, value);
}
else
{
if (propertyKind == EdmTypeKind.Primitive)
{
value = EdmPrimitiveHelpers.ConvertPrimitiveValue(value, GetPropertyType(resource, propertyName, isDelta));
}
SetProperty(resource, propertyName, isDelta, value);
}
}
private static object ConvertCollectionValue(ODataCollectionValue collection, IEdmTypeReference propertyType, ODataDeserializerProvider deserializerProvider, ODataDeserializerReadContext readContext)
{
IEdmCollectionType collectionType = propertyType as IEdmCollectionType;
Contract.Assert(collectionType != null, "The type for collection must be a IEdmCollectionType.");
IList collectionList = CreateNewCollection();
RecurseEnter(readContext);
Contract.Assert(collection.Items != null, "The ODataLib reader should always populate the ODataCollectionValue.Items collection.");
foreach (object odataItem in collection.Items)
{
IEdmTypeReference itemType = collectionType.ElementType;
collectionList.Add(ConvertValue(odataItem, ref itemType, deserializerProvider, readContext));
}
RecurseLeave(readContext);
return(collectionList);
}
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));
}
ODataCollectionValue collection = oDataValue as ODataCollectionValue;
if (collection != null)
{
typeKind = EdmTypeKind.Collection;
Contract.Assert(propertyType != null, "Open collection properties are not supported.");
return(ConvertCollectionValue(collection, propertyType, deserializerProvider, readContext));
}
typeKind = EdmTypeKind.Primitive;
return(oDataValue);
}
internal static void ApplyProperty(ODataProperty property, IEdmStructuredTypeReference resourceType, object resource, ODataDeserializerProvider deserializerProvider, ODataDeserializerContext readContext)
{
IEdmProperty edmProperty = resourceType.FindProperty(property.Name);
string propertyName = property.Name;
IEdmTypeReference propertyType = edmProperty != null ? edmProperty.Type : null; // open properties have null values
bool isDelta = readContext.IsPatchMode && resourceType.IsEntity();
if (isDelta && resourceType.AsEntity().Key().Select(key => key.Name).Contains(propertyName))
{
// we are patching a key property.
if (readContext.PatchKeyMode == PatchKeyMode.Ignore)
{
return;
}
else if (readContext.PatchKeyMode == PatchKeyMode.Throw)
{
throw Error.InvalidOperation(SRResources.CannotPatchKeyProperty, propertyName, resourceType.FullName(), typeof(PatchKeyMode).Name, PatchKeyMode.Throw);
}
}
EdmTypeKind propertyKind;
object value = ConvertValue(property.Value, ref propertyType, deserializerProvider, readContext, out propertyKind);
if (propertyKind == EdmTypeKind.Primitive)
{
value = ConvertPrimitiveValue(value, GetPropertyType(resource, propertyName, isDelta), propertyName, resource.GetType().FullName);
}
SetProperty(resource, propertyName, isDelta, value);
}
public ODataComplexTypeDeserializer(IEdmComplexTypeReference edmComplexType, ODataDeserializerProvider deserializerProvider)
: base(edmComplexType, ODataPayloadKind.Property, deserializerProvider)
{
EdmComplexType = edmComplexType;
}
private ODataDeserializer GetDeserializer(Type type, ODataPath path, IEdmModel model,
ODataDeserializerProvider deserializerProvider, out IEdmTypeReference expectedPayloadType)
{
expectedPayloadType = GetExpectedPayloadType(type, path, model);
// Get the deserializer using the CLR type first from the deserializer provider.
ODataDeserializer deserializer = deserializerProvider.GetODataDeserializer(model, type, Request);
if (deserializer == null && expectedPayloadType != null)
{
// we are in typeless mode, get the deserializer using the edm type from the path.
deserializer = deserializerProvider.GetEdmTypeDeserializer(expectedPayloadType);
}
return deserializer;
}
/// <summary>
/// Initializes a new instance of the <see cref="ODataComplexTypeDeserializer"/> class.
/// </summary>
/// <param name="deserializerProvider">The deserializer provider to use to read inner objects.</param>
public ODataComplexTypeDeserializer(ODataDeserializerProvider deserializerProvider)
: base(ODataPayloadKind.Property, deserializerProvider)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="ODataMediaTypeFormatter"/> class.
/// </summary>
/// <param name="formatter">The <see cref="ODataMediaTypeFormatter"/> to copy settings from.</param>
/// <param name="version">The OData version that this formatter supports.</param>
/// <param name="request">The <see cref="HttpRequestMessage"/> for the per-request formatter instance.</param>
/// <remarks>This is a copy constructor to be used in <see cref="GetPerRequestFormatterInstance"/>.</remarks>
internal ODataMediaTypeFormatter(ODataMediaTypeFormatter formatter, ODataVersion version, HttpRequestMessage request)
: base(formatter)
{
if (request == null)
{
throw Error.ArgumentNull("request");
}
Contract.Assert(formatter._serializerProvider != null);
Contract.Assert(formatter._deserializerProvider != null);
Contract.Assert(formatter._payloadKinds != null);
// Parameter 1: formatter
// Execept for the other two parameters, this constructor is a copy constructor, and we need to copy
// everything on the other instance.
// Copy this class's private fields and internal properties.
_serializerProvider = formatter._serializerProvider;
_deserializerProvider = formatter._deserializerProvider;
_payloadKinds = formatter._payloadKinds;
MessageWriterSettings = formatter.MessageWriterSettings;
MessageReaderSettings = formatter.MessageReaderSettings;
// Parameter 2: version
_version = version;
// Parameter 3: request
Request = request;
}
/// <summary>
/// Initializes a new instance of the <see cref="ODataFeedDeserializer"/> class.
/// </summary>
/// <param name="deserializerProvider">The deserializer provider to use to read inner objects.</param>
public ODataFeedDeserializer(ODataDeserializerProvider deserializerProvider)
: base(ODataPayloadKind.Feed, deserializerProvider)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="ODataComplexTypeDeserializer"/> class.
/// </summary>
/// <param name="deserializerProvider">The deserializer provider to use to read inner objects.</param>
public ODataComplexTypeDeserializer(ODataDeserializerProvider deserializerProvider)
: base(ODataPayloadKind.Property, deserializerProvider)
{
}
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);
}
ODataCollectionValue collection = oDataValue as ODataCollectionValue;
if (collection != null)
{
typeKind = EdmTypeKind.Collection;
Contract.Assert(propertyType != null, "Open collection properties are not supported.");
return ConvertCollectionValue(collection, propertyType, deserializerProvider, readContext);
}
typeKind = EdmTypeKind.Primitive;
return oDataValue;
}
/// <summary>
/// Initializes a new instance of the <see cref="ODataEdmTypeDeserializer"/> class.
/// </summary>
/// <param name="edmType">The EDM type.</param>
/// <param name="payloadKind">The kind of OData payload this deserializer handles.</param>
/// <param name="deserializerProvider">The <see cref="ODataDeserializerProvider"/>.</param>
protected ODataEdmTypeDeserializer(IEdmTypeReference edmType, ODataPayloadKind payloadKind, ODataDeserializerProvider deserializerProvider)
: this(edmType, payloadKind)
{
if (deserializerProvider == null)
{
throw Error.ArgumentNull("deserializerProvider");
}
DeserializerProvider = deserializerProvider;
}
private static object ConvertCollectionValue(ODataCollectionValue collection, IEdmTypeReference propertyType, ODataDeserializerProvider deserializerProvider, ODataDeserializerContext readContext)
{
IEdmCollectionTypeReference collectionType = propertyType as IEdmCollectionTypeReference;
Contract.Assert(collectionType != null, "The type for collection must be a IEdmCollectionType.");
IList collectionList = CreateNewCollection(EdmLibHelpers.GetClrType(collectionType.ElementType(), deserializerProvider.EdmModel));
RecurseEnter(readContext);
Contract.Assert(collection.Items != null, "The ODataLib reader should always populate the ODataCollectionValue.Items collection.");
foreach (object odataItem in collection.Items)
{
IEdmTypeReference itemType = collectionType.ElementType();
EdmTypeKind propertyKind;
collectionList.Add(ConvertValue(odataItem, ref itemType, deserializerProvider, readContext, out propertyKind));
Contract.Assert(propertyKind != EdmTypeKind.Primitive, "no collection property support yet.");
}
RecurseLeave(readContext);
return(collectionList);
}
private static ODataMediaTypeFormatter CreateApplicationXml(ODataSerializerProvider serializerProvider, ODataDeserializerProvider deserializerProvider)
{
ODataMediaTypeFormatter formatter = CreateFormatterWithoutMediaTypes(
serializerProvider,
deserializerProvider,
ODataPayloadKind.Property,
ODataPayloadKind.EntityReferenceLink,
ODataPayloadKind.EntityReferenceLinks,
ODataPayloadKind.Collection,
ODataPayloadKind.ServiceDocument,
ODataPayloadKind.MetadataDocument,
ODataPayloadKind.Error);
formatter.SupportedMediaTypes.Add(ODataMediaTypes.ApplicationXml);
return formatter;
}
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);
}
else
{
edmComplexType = propertyType.AsComplex();
}
ODataEdmTypeDeserializer deserializer = deserializerProvider.GetEdmTypeDeserializer(edmComplexType);
return deserializer.ReadInline(complexValue, propertyType, readContext);
}
private static ODataMediaTypeFormatter CreateTextXml(ODataSerializerProvider serializerProvider, ODataDeserializerProvider deserializerProvider)
{
ODataMediaTypeFormatter formatter = CreateFormatterWithoutMediaTypes(
serializerProvider,
deserializerProvider,
ODataPayloadKind.Property,
ODataPayloadKind.EntityReferenceLink,
ODataPayloadKind.EntityReferenceLinks,
ODataPayloadKind.Collection);
formatter.SupportedMediaTypes.Add(ODataMediaTypes.TextXml);
return formatter;
}
private static object ConvertCollectionValue(ODataCollectionValue collection, IEdmTypeReference propertyType,
ODataDeserializerProvider deserializerProvider, ODataDeserializerContext readContext)
{
IEdmCollectionTypeReference 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);
}
internal static object ConvertValue(object oDataValue, ref IEdmTypeReference propertyType, ODataDeserializerProvider deserializerProvider, ODataDeserializerReadContext readContext)
{
if (oDataValue == null)
{
return(null);
}
ODataComplexValue complexValue = oDataValue as ODataComplexValue;
if (complexValue != null)
{
return(ConvertComplexValue(complexValue, ref propertyType, deserializerProvider, readContext));
}
ODataCollectionValue collection = oDataValue as ODataCollectionValue;
if (collection != null)
{
Contract.Assert(propertyType != null, "Open collection properties are not supported.");
return(ConvertCollectionValue(collection, propertyType, deserializerProvider, readContext));
}
return(ConvertPrimitiveValue(oDataValue, ref propertyType));
}
public ODataComplexTypeDeserializer(IEdmComplexTypeReference edmComplexType, ODataDeserializerProvider deserializerProvider)
: base(edmComplexType, ODataPayloadKind.Property, deserializerProvider)
{
EdmComplexType = edmComplexType;
}