/// <summary>
/// Deserializes the given <paramref name="entryWrapper"/> under the given <paramref name="readContext"/>.
/// </summary>
/// <param name="entryWrapper">The OData entry to deserialize.</param>
/// <param name="entityType">The entity type of the entry to deserialize.</param>
/// <param name="readContext">The deserializer context.</param>
/// <returns>The deserialized entity.</returns>
public virtual object ReadEntry(ODataEntryWithNavigationLinks entryWrapper, IEdmEntityTypeReference entityType,
ODataDeserializerContext readContext)
{
if (entryWrapper == null)
{
throw Error.ArgumentNull("entryWrapper");
}
if (readContext == null)
{
throw Error.ArgumentNull("readContext");
}
if (!String.IsNullOrEmpty(entryWrapper.Entry.TypeName) && entityType.FullName() != entryWrapper.Entry.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);
}
IEdmEntityType actualType = model.FindType(entryWrapper.Entry.TypeName) as IEdmEntityType;
if (actualType == null)
{
throw new ODataException(Error.Format(SRResources.EntityTypeNotInModel, entryWrapper.Entry.TypeName));
}
if (actualType.IsAbstract)
{
string message = Error.Format(SRResources.CannotInstantiateAbstractEntityType, entryWrapper.Entry.TypeName);
throw new ODataException(message);
}
IEdmTypeReference actualEntityType = new EdmEntityTypeReference(actualType, isNullable: false);
ODataEdmTypeDeserializer deserializer = DeserializerProvider.GetEdmTypeDeserializer(actualEntityType);
if (deserializer == null)
{
throw new SerializationException(
Error.Format(SRResources.TypeCannotBeDeserialized, actualEntityType.FullName(), typeof(ODataMediaTypeFormatter).Name));
}
object resource = deserializer.ReadInline(entryWrapper, actualEntityType, readContext);
EdmStructuredObject structuredObject = resource as EdmStructuredObject;
if (structuredObject != null)
{
structuredObject.ExpectedEdmType = entityType.EntityDefinition();
}
return(resource);
}
else
{
object resource = CreateEntityResource(entityType, readContext);
ApplyEntityProperties(resource, entryWrapper, entityType, readContext);
return(resource);
}
}
public override object ReadInline(ODataFeed feed, ODataDeserializerContext readContext)
{
if (readContext == null)
{
throw Error.ArgumentNull("readContext");
}
if (feed == null)
{
return(null);
}
ODataEntryDeserializer deserializer = DeserializerProvider.GetODataDeserializer(_edmEntityType);
IList feedValue = CreateNewCollection(EdmLibHelpers.GetClrType(_edmEntityType, EdmModel));
ODataFeedAnnotation feedAnnotation = feed.GetAnnotation <ODataFeedAnnotation>();
Contract.Assert(feedAnnotation != null, "Each feed we create should gave annotation on it.");
foreach (ODataEntry entry in feedAnnotation)
{
ODataEntryAnnotation annotation = entry.GetAnnotation <ODataEntryAnnotation>();
Contract.Assert(annotation != null);
feedValue.Add(deserializer.ReadInline(entry, readContext));
}
return(feedValue);
}
/// <summary>
/// Deserializes the given <paramref name="collectionValue"/> under the given <paramref name="readContext"/>.
/// </summary>
/// <param name="collectionValue">The <see cref="ODataCollectionValue"/> to deserialize.</param>
/// <param name="readContext">The deserializer context.</param>
/// <returns>The deserialized collection.</returns>
public virtual IEnumerable ReadCollectionValue(ODataCollectionValue collectionValue, ODataDeserializerContext readContext)
{
if (collectionValue == null)
{
throw Error.ArgumentNull("collectionValue");
}
ODataEdmTypeDeserializer deserializer = DeserializerProvider.GetEdmTypeDeserializer(ElementType);
if (deserializer == null)
{
throw new SerializationException(
Error.Format(SRResources.TypeCannotBeDeserialized, ElementType.FullName(), typeof(ODataMediaTypeFormatter).Name));
}
foreach (object entry in collectionValue.Items)
{
if (ElementType.IsPrimitive())
{
yield return(entry);
}
else
{
yield return(deserializer.ReadInline(entry, readContext));
}
}
}
/// <summary>
/// Deserializes the given <paramref name="collectionValue"/> under the given <paramref name="readContext"/>.
/// </summary>
/// <param name="collectionValue">The <see cref="ODataCollectionValue"/> to deserialize.</param>
/// <param name="elementType">The element type of the collection to read.</param>
/// <param name="readContext">The deserializer context.</param>
/// <returns>The deserialized collection.</returns>
public virtual IEnumerable ReadCollectionValue(ODataCollectionValue collectionValue, IEdmTypeReference elementType,
ODataDeserializerContext readContext)
{
if (collectionValue == null)
{
throw Error.ArgumentNull("collectionValue");
}
if (elementType == null)
{
throw Error.ArgumentNull("elementType");
}
ODataEdmTypeDeserializer deserializer = DeserializerProvider.GetEdmTypeDeserializer(elementType);
if (deserializer == null)
{
throw new SerializationException(
Error.Format(SRResources.TypeCannotBeDeserialized, elementType.FullName()));
}
foreach (object item in collectionValue.Items)
{
if (elementType.IsPrimitive())
{
yield return(item);
}
else
{
yield return(deserializer.ReadInline(item, elementType, readContext));
}
}
}
/// <summary>
/// Deserializes the given <paramref name="resource"/> under the given <paramref name="readContext"/>.
/// The given resource could be "Added Resource", "Updated Resource" or "Deleted Resource".
/// </summary>
/// <param name="resource">The Added Updated or Deleted Resource.</param>
/// <param name="elementType">The element type.</param>
/// <param name="readContext">The deserializer context.</param>
/// <returns>The created object.</returns>
public virtual object ReadDeltaResource(ODataResourceWrapper resource, IEdmStructuredTypeReference elementType, ODataDeserializerContext readContext)
{
if (resource == null)
{
throw Error.ArgumentNull(nameof(resource));
}
if (readContext == null)
{
throw Error.ArgumentNull(nameof(readContext));
}
ODataEdmTypeDeserializer deserializer = DeserializerProvider.GetEdmTypeDeserializer(elementType);
if (deserializer == null)
{
throw new SerializationException(
Error.Format(SRResources.TypeCannotBeDeserialized, elementType.FullName()));
}
ODataDeserializerContext resourceReadContext = readContext.CloneWithoutType();
if (readContext.IsNoClrType) // check the clr type status from parent context.
{
if (resource.IsDeletedResource)
{
resourceReadContext.ResourceType = typeof(EdmDeltaDeletedResourceObject);
}
else
{
resourceReadContext.ResourceType = typeof(EdmEntityObject);
}
}
else
{
Type clrType = readContext.Model.GetClrType(elementType);
if (clrType == null)
{
throw new ODataException(
Error.Format(SRResources.MappingDoesNotContainResourceType, elementType.FullName()));
}
if (resource.IsDeletedResource)
{
resourceReadContext.ResourceType = typeof(DeltaDeletedResource <>).MakeGenericType(clrType);
}
else
{
resourceReadContext.ResourceType = typeof(Delta <>).MakeGenericType(clrType);
}
}
return(deserializer.ReadInline(resource, elementType, resourceReadContext));
}
private object CreateNestedEntityAndApplyProperties(ODataEntry entry, IEdmEntityTypeReference elementType, ODataDeserializerReadContext readContext)
{
ODataEntryAnnotation annotation = entry.GetAnnotation <ODataEntryAnnotation>();
Contract.Assert(annotation != null);
CreateEntityResource(annotation, elementType, readContext);
ODataEntryDeserializer deserializer = DeserializerProvider.GetODataDeserializer(elementType);
return(deserializer.ReadInline(entry, readContext));
}
private object ReadNestedResourceInline(ODataResourceWrapper resourceWrapper, IEdmTypeReference edmType, ODataDeserializerContext readContext)
{
Contract.Assert(edmType != null);
Contract.Assert(readContext != null);
if (resourceWrapper == null)
{
return(null);
}
ODataEdmTypeDeserializer deserializer = DeserializerProvider.GetEdmTypeDeserializer(edmType);
if (deserializer == null)
{
throw new SerializationException(Error.Format(SRResources.TypeCannotBeDeserialized,
edmType.FullName(), 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));
}
private object ReadNestedResourceInline(ODataResourceWrapper resourceWrapper, IEdmTypeReference edmType, ODataDeserializerContext readContext)
{
Contract.Assert(edmType != null);
Contract.Assert(readContext != null);
if (resourceWrapper == null)
{
return(null);
}
ODataEdmTypeDeserializer deserializer = DeserializerProvider.GetEdmTypeDeserializer(edmType);
if (deserializer == null)
{
throw new SerializationException(Error.Format(SRResources.TypeCannotBeDeserialized, edmType.FullName()));
}
IEdmStructuredTypeReference structuredType = edmType.AsStructured();
var nestedReadContext = new ODataDeserializerContext
{
Path = readContext.Path,
Model = readContext.Model,
Request = readContext.Request,
TimeZone = readContext.TimeZone
};
Type clrType;
if (readContext.IsNoClrType)
{
clrType = structuredType.IsEntity()
? typeof(EdmEntityObject)
: typeof(EdmComplexObject);
}
else
{
clrType = readContext.Model.GetClrType(structuredType);
if (clrType == null)
{
throw new ODataException(
Error.Format(SRResources.MappingDoesNotContainResourceType, structuredType.FullName()));
}
}
nestedReadContext.ResourceType = readContext.IsDeltaOfT
? typeof(Delta <>).MakeGenericType(clrType)
: clrType;
return(deserializer.ReadInline(resourceWrapper, edmType, nestedReadContext));
}
private IEnumerable ReadItems(ODataFeed feed, ODataDeserializerContext readContext)
{
ODataEntryDeserializer deserializer = DeserializerProvider.GetODataDeserializer(_edmEntityType);
ODataFeedAnnotation feedAnnotation = feed.GetAnnotation<ODataFeedAnnotation>();
Contract.Assert(feedAnnotation != null, "Each feed we create should gave annotation on it.");
foreach (ODataEntry entry in feedAnnotation)
{
ODataEntryAnnotation annotation = entry.GetAnnotation<ODataEntryAnnotation>();
Contract.Assert(annotation != null);
yield return deserializer.ReadInline(entry, readContext);
}
}
/// <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));
}
}
private void ApplyEntryInNavigationProperty(IEdmNavigationProperty navigationProperty, object entityResource, ODataEntry entry, ODataDeserializerContext readContext)
{
Contract.Assert(navigationProperty != null && navigationProperty.PropertyKind == EdmPropertyKind.Navigation, "navigationProperty != null && navigationProperty.TypeKind == ResourceTypeKind.EntityType");
Contract.Assert(entityResource != null, "entityResource != null");
ODataEntryDeserializer deserializer = DeserializerProvider.GetODataDeserializer(navigationProperty.Type);
object value = deserializer.ReadInline(entry, readContext);
if (readContext.IsPatchMode)
{
throw Error.InvalidOperation(SRResources.CannotPatchNavigationProperties, navigationProperty.Name, navigationProperty.DeclaringEntityType().FullName());
}
SetProperty(entityResource, navigationProperty.Name, isDelta: false, value: value);
}
/// <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()));
}
foreach (ODataResourceWrapper resourceWrapper in resourceSet.Resources)
{
yield return(deserializer.ReadInline(resourceWrapper, elementType, readContext));
}
}
private void ApplyFeedInNavigationProperty(IEdmNavigationProperty navigationProperty, object entityResource, ODataFeed feed, ODataDeserializerContext readContext)
{
ODataFeedAnnotation feedAnnotation = feed.GetAnnotation <ODataFeedAnnotation>();
Contract.Assert(feedAnnotation != null, "Each feed we create should gave annotation on it.");
ODataEntryDeserializer deserializer = DeserializerProvider.GetODataDeserializer(navigationProperty.Type);
object value = deserializer.ReadInline(feed, readContext);
if (readContext.IsPatchMode)
{
throw Error.InvalidOperation(SRResources.CannotPatchNavigationProperties, navigationProperty.Name, navigationProperty.DeclaringEntityType().FullName());
}
SetProperty(entityResource, navigationProperty.Name, isDelta: false, value: value);
}
private object ReadNestedResourceSetInline(ODataResourceSetWrapper resourceSetWrapper, IEdmTypeReference edmType,
ODataDeserializerContext readContext)
{
Contract.Assert(resourceSetWrapper != 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()));
}
IEdmStructuredTypeReference structuredType = edmType.AsCollection().ElementType().AsStructured();
var nestedReadContext = new ODataDeserializerContext
{
Path = readContext.Path,
Model = readContext.Model,
};
if (readContext.IsUntyped)
{
if (structuredType.IsEntity())
{
nestedReadContext.ResourceType = typeof(EdmEntityObjectCollection);
}
else
{
nestedReadContext.ResourceType = typeof(EdmComplexObjectCollection);
}
}
else
{
Type clrType = readContext.Model.GetClrType(structuredType);
if (clrType == null)
{
throw new ODataException(
Error.Format(SRResources.MappingDoesNotContainResourceType, structuredType.FullName()));
}
nestedReadContext.ResourceType = typeof(List <>).MakeGenericType(clrType);
}
return(deserializer.ReadInline(resourceSetWrapper, edmType, nestedReadContext));
}
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);
}
private void ApplyNestedDeltaResourceSet(IEdmProperty nestedProperty, object resource,
ODataDeltaResourceSetWrapper deltaResourceSetWrapper, ODataDeserializerContext readContext)
{
Contract.Assert(nestedProperty != null);
Contract.Assert(resource != null);
Contract.Assert(readContext != null);
IEdmTypeReference edmType = nestedProperty.Type;
ODataEdmTypeDeserializer deserializer = DeserializerProvider.GetEdmTypeDeserializer(edmType, true);
if (deserializer == null)
{
throw new SerializationException(Error.Format(SRResources.TypeCannotBeDeserialized, edmType.FullName()));
}
IEdmStructuredTypeReference structuredType = edmType.AsCollection().ElementType().AsStructured();
ODataDeserializerContext nestedReadContext = readContext.CloneWithoutType();
if (readContext.IsNoClrType)
{
nestedReadContext.ResourceType = typeof(EdmChangedObjectCollection);
}
else
{
Type clrType = readContext.Model.GetClrType(structuredType);
if (clrType == null)
{
throw new ODataException(
Error.Format(SRResources.MappingDoesNotContainResourceType, structuredType.FullName()));
}
nestedReadContext.ResourceType = typeof(DeltaSet <>).MakeGenericType(clrType);
}
object value = deserializer.ReadInline(deltaResourceSetWrapper, edmType, nestedReadContext);
string propertyName = readContext.Model.GetClrPropertyName(nestedProperty);
DeserializationHelpers.SetCollectionProperty(resource, nestedProperty, value, propertyName);
}
private void ApplyFeedInNavigationProperty(IEdmNavigationProperty navigationProperty, object entityResource, ODataFeedWithEntries feed, ODataDeserializerContext readContext)
{
Contract.Assert(navigationProperty != null && navigationProperty.PropertyKind == EdmPropertyKind.Navigation, "navigationProperty != null && navigationProperty.TypeKind == ResourceTypeKind.EntityType");
Contract.Assert(entityResource != null, "entityResource != null");
if (readContext.IsDeltaOfT)
{
string message = Error.Format(SRResources.CannotPatchNavigationProperties, navigationProperty.Name, navigationProperty.DeclaringEntityType().FullName());
throw new ODataException(message);
}
ODataEdmTypeDeserializer deserializer = DeserializerProvider.GetEdmTypeDeserializer(navigationProperty.Type);
if (deserializer == null)
{
throw new SerializationException(Error.Format(SRResources.TypeCannotBeDeserialized, navigationProperty.Type.FullName(), typeof(ODataMediaTypeFormatter)));
}
object value = deserializer.ReadInline(feed, navigationProperty.Type, readContext);
DeserializationHelpers.SetCollectionProperty(entityResource, navigationProperty, value);
}
/// <summary>
/// Override this method to translate property values in v3 format to v4 format.
/// We treat collections (arrays of non-entity/non-complex types) differently from resource sets because
/// there is an accessible method to override that allows us to examine each value in the collection and convert it if necessary.
/// </summary>
/// <param name="collectionValue">Each value in the collection</param>
/// <param name="elementType">The type of the value</param>
/// <param name="readContext">Context that contains model, state and HTTP request information</param>
/// <returns>Deserialized object from request body</returns>
public override IEnumerable ReadCollectionValue(ODataCollectionValue collectionValue, IEdmTypeReference elementType,
ODataDeserializerContext readContext)
{
if (collectionValue == null)
{
throw new ArgumentNullException(nameof(collectionValue));
}
if (elementType == null)
{
throw new ArgumentNullException(nameof(elementType));
}
ODataEdmTypeDeserializer deserializer = DeserializerProvider.GetEdmTypeDeserializer(elementType);
if (deserializer == null)
{
throw new SerializationException("Type " + elementType.FullName() + " cannot be deserialized");
}
foreach (object item in collectionValue.Items)
{
if (elementType.IsPrimitive())
{
if (((IEdmPrimitiveType)elementType.Definition).PrimitiveKind == EdmPrimitiveTypeKind.Int64)
{
yield return(Convert.ToInt64(item));
}
else
{
yield return(item);
}
}
else
{
yield return(deserializer.ReadInline(item, elementType, readContext));
}
}
}
private IEnumerable ReadItems(ODataCollectionValue collection, ODataDeserializerContext readContext)
{
RecurseEnter(readContext);
IEdmTypeReference elementType = _edmCollectionType.ElementType();
ODataEntryDeserializer deserializer = DeserializerProvider.GetODataDeserializer(elementType);
Contract.Assert(deserializer != null);
foreach (object entry in collection.Items)
{
if (elementType.IsPrimitive())
{
yield return(entry);
}
else
{
yield return(deserializer.ReadInline(entry, readContext));
}
}
RecurseLeave(readContext);
}
public override object ReadInline(ODataCollectionValue collection, ODataDeserializerContext readContext)
{
if (readContext == null)
{
throw Error.ArgumentNull("readContext");
}
if (collection == null)
{
return(null);
}
RecurseEnter(readContext);
IEdmTypeReference elementType = _edmCollectionType.ElementType();
ODataEntryDeserializer deserializer = DeserializerProvider.GetODataDeserializer(elementType);
Contract.Assert(deserializer != null);
IList collectionValue = CreateNewCollection(EdmLibHelpers.GetClrType(elementType, EdmModel));
foreach (object entry in collection.Items)
{
if (elementType.IsPrimitive())
{
collectionValue.Add(entry);
}
else
{
collectionValue.Add(deserializer.ReadInline(entry, readContext));
}
}
RecurseLeave(readContext);
return(collectionValue);
}
public override object ReadInline(ODataEntry entry, ODataDeserializerContext readContext)
{
if (entry == null)
{
throw Error.Argument("entry", SRResources.ItemMustBeOfType, typeof(ODataEntry).Name);
}
if (EdmEntityType.FullName() != entry.TypeName)
{
// received a derived type in a base type deserializer.
// delegate it to the appropriate derived type deserializer.
IEdmEntityType entityType = EdmModel.FindType(entry.TypeName) as IEdmEntityType;
Contract.Assert(entityType != null, "edmlib should have already validated that it knows the edm type and is the same as or derives from EdmEntityType");
if (entityType.IsAbstract)
{
throw Error.InvalidOperation(SRResources.CannotInstantiateAbstractEntityType, entry.TypeName);
}
ODataEntityDeserializer deserializer = DeserializerProvider.GetODataDeserializer(new EdmEntityTypeReference(entityType, isNullable: false)) as ODataEntityDeserializer;
return(deserializer.ReadInline(entry, readContext));
}
else
{
ODataEntryAnnotation entryAnnotation = entry.GetAnnotation <ODataEntryAnnotation>();
Contract.Assert(entryAnnotation != null);
CreateEntityResource(entryAnnotation, EdmEntityType, readContext);
RecurseEnter(readContext);
ApplyEntityProperties(entry, entryAnnotation, readContext);
RecurseLeave(readContext);
return(entryAnnotation.EntityResource);
}
}
/// <summary>
/// Deserializes the given <paramref name="deltaResourceSet"/> under the given <paramref name="readContext"/>.
/// </summary>
/// <param name="deltaResourceSet">The delta resource set to deserialize.</param>
/// <param name="elementType">The element type.</param>
/// <param name="readContext">The deserializer context.</param>
/// <returns>The deserialized resource set object.</returns>
public virtual IEnumerable ReadDeltaResourceSet(ODataDeltaResourceSetWrapper deltaResourceSet, IEdmStructuredTypeReference elementType, ODataDeserializerContext readContext)
{
if (deltaResourceSet == null)
{
throw Error.ArgumentNull(nameof(deltaResourceSet));
}
if (readContext == null)
{
throw Error.ArgumentNull(nameof(readContext));
}
// Delta Items
foreach (ODataItemWrapper itemWrapper in deltaResourceSet.DeltaItems)
{
// Deleted Link
ODataDeltaDeletedLinkWrapper deletedLinkWrapper = itemWrapper as ODataDeltaDeletedLinkWrapper;
if (deletedLinkWrapper != null)
{
yield return(ReadDeltaDeletedLink(deletedLinkWrapper, elementType, readContext));
}
// Added Link
ODataDeltaLinkWrapper deltaLinkWrapper = itemWrapper as ODataDeltaLinkWrapper;
if (deltaLinkWrapper != null)
{
yield return(ReadDeltaLink(deltaLinkWrapper, elementType, readContext));
}
// DeletedResource
ODataDeletedResourceWrapper deletedResourceWrapper = itemWrapper as ODataDeletedResourceWrapper;
if (deletedResourceWrapper != null)
{
// TODO: deleted resource
yield return(null);
}
// Added resource or updated resource
ODataResourceWrapper resourceWrapper = itemWrapper as ODataResourceWrapper;
if (resourceWrapper != null)
{
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));
}
IEdmTypeReference edmTypeReference = actualType.ToEdmTypeReference(true);
ODataEdmTypeDeserializer deserializer = DeserializerProvider.GetEdmTypeDeserializer(edmTypeReference);
if (deserializer == null)
{
throw new SerializationException(
Error.Format(SRResources.TypeCannotBeDeserialized, edmTypeReference.FullName()));
}
// TODO: normal resource
// yield return deserializer.ReadInline(resourceWrapper, edmTypeReference, readContext);
if (readContext.IsDeltaOfT)
{
Type elementClrType = readContext.Model.GetClrType(elementType);
Type deltaType = typeof(Deltas.Delta <>).MakeGenericType(elementClrType);
Deltas.IDelta delta = Activator.CreateInstance(deltaType) as Deltas.IDelta;
yield return(delta);
}
else
{
yield return(new EdmDeltaResourceObject(actualType as IEdmEntityType));
}
continue;
}
}
}
/// <summary>
/// Deserializes the given <paramref name="resourceWrapper"/> under the given <paramref name="readContext"/>.
/// </summary>
/// <param name="resourceWrapper">The OData resource to deserialize.</param>
/// <param name="structuredType">The type of the resource to deserialize.</param>
/// <param name="readContext">The deserializer context.</param>
/// <returns>The deserialized resource.</returns>
public virtual object ReadResource(ODataResourceWrapper resourceWrapper, IEdmStructuredTypeReference structuredType,
ODataDeserializerContext readContext)
{
if (resourceWrapper == null)
{
throw Error.ArgumentNull("resourceWrapper");
}
if (readContext == null)
{
throw Error.ArgumentNull("readContext");
}
if (!String.IsNullOrEmpty(resourceWrapper.Resource.TypeName) && structuredType.FullName() != resourceWrapper.Resource.TypeName)
{
// received a derived type in a base type deserializer. delegate it to the appropriate derived type deserializer.
IEdmModel model = readContext.Model;
if (model == null)
{
throw Error.Argument("readContext", SRResources.ModelMissingFromReadContext);
}
IEdmStructuredType actualType = model.FindType(resourceWrapper.Resource.TypeName) as IEdmStructuredType;
if (actualType == null)
{
throw new ODataException(Error.Format(SRResources.ResourceTypeNotInModel, resourceWrapper.Resource.TypeName));
}
if (actualType.IsAbstract)
{
string message = Error.Format(SRResources.CannotInstantiateAbstractResourceType, resourceWrapper.Resource.TypeName);
throw new ODataException(message);
}
IEdmTypeReference actualStructuredType;
IEdmEntityType actualEntityType = actualType as IEdmEntityType;
if (actualEntityType != null)
{
actualStructuredType = new EdmEntityTypeReference(actualEntityType, isNullable: false);
}
else
{
actualStructuredType = new EdmComplexTypeReference(actualType as IEdmComplexType, isNullable: false);
}
ODataEdmTypeDeserializer deserializer = DeserializerProvider.GetEdmTypeDeserializer(actualStructuredType);
if (deserializer == null)
{
throw new SerializationException(
Error.Format(SRResources.TypeCannotBeDeserialized, actualEntityType.FullName()));
}
object resource = deserializer.ReadInline(resourceWrapper, actualStructuredType, readContext);
EdmStructuredObject structuredObject = resource as EdmStructuredObject;
if (structuredObject != null)
{
structuredObject.ExpectedEdmType = structuredType.StructuredDefinition();
}
return(resource);
}
else
{
object resource = CreateResourceInstance(structuredType, readContext);
ApplyResourceProperties(resource, resourceWrapper, structuredType, readContext);
return(resource);
}
}
public static async ValueTask <T> ReadAsAsync <T>(this HttpContent content, DeserializerProvider provider)
{
if (content == null)
{
return(default);
/// <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);
}
if (!String.IsNullOrEmpty(complexValue.TypeName) && complexType.FullName() != complexValue.TypeName)
{
// received a derived complex type in a base type deserializer.
IEdmModel model = readContext.Model;
if (model == null)
{
throw Error.Argument("readContext", SRResources.ModelMissingFromReadContext);
}
IEdmComplexType actualType = model.FindType(complexValue.TypeName) as IEdmComplexType;
if (actualType == null)
{
throw new ODataException(Error.Format(SRResources.ComplexTypeNotInModel, complexValue.TypeName));
}
if (actualType.IsAbstract)
{
string message = Error.Format(SRResources.CannotInstantiateAbstractComplexType,
complexValue.TypeName);
throw new ODataException(message);
}
IEdmTypeReference actualComplexType = new EdmComplexTypeReference(actualType, isNullable: false);
ODataEdmTypeDeserializer deserializer = DeserializerProvider.GetEdmTypeDeserializer(actualComplexType);
if (deserializer == null)
{
throw new SerializationException(
Error.Format(SRResources.TypeCannotBeDeserialized, actualComplexType.FullName(),
typeof(ODataMediaTypeFormatter).Name));
}
object resource = deserializer.ReadInline(complexValue, actualComplexType, readContext);
EdmStructuredObject structuredObject = resource as EdmStructuredObject;
if (structuredObject != null)
{
structuredObject.ExpectedEdmType = complexType.ComplexDefinition();
}
return(resource);
}
else
{
object complexResource = CreateResource(complexType, readContext);
foreach (ODataProperty complexProperty in complexValue.Properties)
{
DeserializationHelpers.ApplyProperty(complexProperty, complexType, complexResource,
DeserializerProvider, readContext);
}
return(complexResource);
}
}
/// <summary>
/// Deserializes the given <paramref name="deltaResourceSet"/> under the given <paramref name="readContext"/>.
/// </summary>
/// <param name="deltaResourceSet">The delta resource set to deserialize.</param>
/// <param name="readContext">The deserializer context.</param>
/// <returns>The deserialized resource set object.</returns>
public virtual IEnumerable ReadDeltaResourceSet(ODataDeltaResourceSetWrapper deltaResourceSet, ODataDeserializerContext readContext)
{
if (deltaResourceSet == null)
{
throw Error.ArgumentNull(nameof(deltaResourceSet));
}
if (readContext == null)
{
throw Error.ArgumentNull(nameof(readContext));
}
// resource
foreach (ODataResourceBaseWrapper resourceBaseWrapper in deltaResourceSet.ResourceBases)
{
ODataResourceWrapper resourceWrapper = resourceBaseWrapper as ODataResourceWrapper;
ODataDeletedResourceWrapper deletedResourceWrapper = resourceBaseWrapper as ODataDeletedResourceWrapper;
if (resourceWrapper != null)
{
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));
}
IEdmTypeReference edmTypeReference = actualType.ToEdmTypeReference(true);
ODataEdmTypeDeserializer deserializer = DeserializerProvider.GetEdmTypeDeserializer(edmTypeReference);
if (deserializer == null)
{
throw new SerializationException(
Error.Format(SRResources.TypeCannotBeDeserialized, edmTypeReference.FullName()));
}
// TODO: normal resource
yield return(deserializer.ReadInline(resourceWrapper, edmTypeReference, readContext));
}
else
{
// TODO: deleted resource
}
}
// Delta links
foreach (ODataDeltaLinkBaseWrapper deltaLinkBaseWrapper in deltaResourceSet.DeltaLinks)
{
ODataDeltaDeletedLinkWrapper deletedLinkWrapper = deltaLinkBaseWrapper as ODataDeltaDeletedLinkWrapper;
if (deletedLinkWrapper != null)
{
yield return(ReadDeltaDeletedLink(deletedLinkWrapper, readContext));
}
else
{
yield return(ReadDeltaLink((ODataDeltaLinkWrapper)deltaLinkBaseWrapper, readContext));
}
}
}
