private object ReadNonEntityValueImplementation(IEdmTypeReference expectedTypeReference, DuplicatePropertyNamesChecker duplicatePropertyNamesChecker, CollectionWithoutExpectedTypeValidator collectionValidator, bool validateNullValue)
{
object obj2;
SerializationTypeNameAnnotation annotation;
EdmTypeKind kind;
JsonNodeType nodeType = base.JsonReader.NodeType;
if (nodeType == JsonNodeType.StartArray)
{
throw new ODataException(Microsoft.Data.OData.Strings.ODataJsonPropertyAndValueDeserializer_CannotReadPropertyValue(nodeType));
}
if (this.TryReadNullValue(expectedTypeReference, validateNullValue))
{
return null;
}
string payloadTypeName = this.FindTypeNameInPayload();
IEdmTypeReference type = ReaderValidationUtils.ResolvePayloadTypeNameAndComputeTargetType(EdmTypeKind.None, null, expectedTypeReference, payloadTypeName, base.Model, base.MessageReaderSettings, base.Version, new Func<EdmTypeKind>(this.GetNonEntityValueKind), out kind, out annotation);
switch (kind)
{
case EdmTypeKind.Primitive:
{
IEdmPrimitiveTypeReference reference2 = (type == null) ? null : type.AsPrimitive();
if ((payloadTypeName != null) && !reference2.IsSpatial())
{
throw new ODataException(Microsoft.Data.OData.Strings.ODataJsonPropertyAndValueDeserializer_InvalidPrimitiveTypeName(payloadTypeName));
}
obj2 = this.ReadPrimitiveValueImplementation(reference2, validateNullValue);
break;
}
case EdmTypeKind.Complex:
obj2 = this.ReadComplexValueImplementation((type == null) ? null : type.AsComplex(), payloadTypeName, annotation, duplicatePropertyNamesChecker);
break;
case EdmTypeKind.Collection:
{
IEdmCollectionTypeReference collectionValueTypeReference = ValidationUtils.ValidateCollectionType(type);
obj2 = this.ReadCollectionValueImplementation(collectionValueTypeReference, payloadTypeName, annotation);
break;
}
default:
throw new ODataException(Microsoft.Data.OData.Strings.General_InternalError(InternalErrorCodes.ODataJsonPropertyAndValueDeserializer_ReadPropertyValue));
}
if (collectionValidator != null)
{
string collectionItemTypeName = ODataJsonReaderUtils.GetPayloadTypeName(obj2);
collectionValidator.ValidateCollectionItem(collectionItemTypeName, kind);
}
return obj2;
}
internal void WriteComplexValue(ODataComplexValue complexValue, IEdmTypeReference propertyTypeReference, bool isOpenPropertyType, DuplicatePropertyNamesChecker duplicatePropertyNamesChecker, CollectionWithoutExpectedTypeValidator collectionValidator)
{
this.IncreaseRecursionDepth();
base.JsonWriter.StartObjectScope();
string typeName = complexValue.TypeName;
if (collectionValidator != null)
{
collectionValidator.ValidateCollectionItem(typeName, EdmTypeKind.Complex);
}
IEdmComplexTypeReference type = WriterValidationUtils.ResolveTypeNameForWriting(base.Model, propertyTypeReference, ref typeName, EdmTypeKind.Complex, isOpenPropertyType).AsComplexOrNull();
if (((typeName != null) && (collectionValidator != null)) && (string.CompareOrdinal(collectionValidator.ItemTypeNameFromCollection, typeName) == 0))
{
typeName = null;
}
SerializationTypeNameAnnotation annotation = complexValue.GetAnnotation<SerializationTypeNameAnnotation>();
if (annotation != null)
{
typeName = annotation.TypeName;
}
if (typeName != null)
{
base.JsonWriter.WriteName("__metadata");
base.JsonWriter.StartObjectScope();
base.JsonWriter.WriteName("type");
base.JsonWriter.WriteValue(typeName);
base.JsonWriter.EndObjectScope();
}
this.WriteProperties((type == null) ? null : type.ComplexDefinition(), complexValue.Properties, true, duplicatePropertyNamesChecker, null);
base.JsonWriter.EndObjectScope();
this.DecreaseRecursionDepth();
}
/// <summary>
/// Reads a primitive, complex or collection value.
/// </summary>
/// <param name="expectedTypeReference">The expected type reference of the property value.</param>
/// <param name="duplicatePropertyNamesChecker">The duplicate property names checker to use - if null the method should create a new one if necessary.</param>
/// <param name="collectionValidator">The collection validator instance if no expected item type has been specified; otherwise null.</param>
/// <param name="validateNullValue">true to validate null values; otherwise false.</param>
/// <returns>The value of the property read.</returns>
/// <remarks>
/// Pre-Condition: JsonNodeType.PrimitiveValue - the value of the property is a primitive value
/// JsonNodeType.StartObject - the value of the property is an object
/// JsonNodeType.StartArray - the value of the property is an array - method will fail in this case.
/// Post-Condition: almost anything - the node after the property value.
///
/// Returns the value of the property read, which can be one of:
/// - null
/// - primitive value
/// - <see cref="ODataComplexValue"/>
/// - <see cref="ODataCollectionValue"/>
/// </remarks>
private object ReadNonEntityValueImplementation(
IEdmTypeReference expectedTypeReference,
DuplicatePropertyNamesChecker duplicatePropertyNamesChecker,
CollectionWithoutExpectedTypeValidator collectionValidator,
bool validateNullValue)
{
// TODO: can we ever get a non-null collection validator here? That would mean that we don't have
// an expected type; double-check
DebugUtils.CheckNoExternalCallers();
Debug.Assert(
this.JsonReader.NodeType == JsonNodeType.PrimitiveValue || this.JsonReader.NodeType == JsonNodeType.StartObject || this.JsonReader.NodeType == JsonNodeType.StartArray,
"Pre-Condition: expected JsonNodeType.PrimitiveValue or JsonNodeType.StartObject or JsonNodeType.StartArray");
Debug.Assert(
expectedTypeReference == null || !expectedTypeReference.IsODataEntityTypeKind(),
"Only primitive, complex or collection types can be read by this method.");
Debug.Assert(
expectedTypeReference == null || collectionValidator == null,
"If an expected value type reference is specified, no collection validator must be provided.");
this.JsonReader.AssertNotBuffering();
// Property values can be only primitives or objects. No property can have a JSON array value.
JsonNodeType nodeType = this.JsonReader.NodeType;
if (nodeType == JsonNodeType.StartArray)
{
throw new ODataException(o.Strings.ODataJsonPropertyAndValueDeserializer_CannotReadPropertyValue(nodeType));
}
// Try to read a null value
object result;
if (this.TryReadNullValue(expectedTypeReference, validateNullValue))
{
result = null;
}
else
{
// Read the payload type name
string payloadTypeName = this.FindTypeNameInPayload();
SerializationTypeNameAnnotation serializationTypeNameAnnotation;
EdmTypeKind targetTypeKind;
IEdmTypeReference targetTypeReference = ReaderValidationUtils.ResolvePayloadTypeNameAndComputeTargetType(
EdmTypeKind.None,
/*defaultPrimitivePayloadType*/ null,
expectedTypeReference,
payloadTypeName,
this.Model,
this.MessageReaderSettings,
this.Version,
this.GetNonEntityValueKind,
out targetTypeKind,
out serializationTypeNameAnnotation);
switch (targetTypeKind)
{
case EdmTypeKind.Primitive:
Debug.Assert(targetTypeReference == null || targetTypeReference.IsODataPrimitiveTypeKind(), "Expected an OData primitive type.");
IEdmPrimitiveTypeReference primitiveTargetTypeReference = targetTypeReference == null ? null : targetTypeReference.AsPrimitive();
if (payloadTypeName != null && !primitiveTargetTypeReference.IsSpatial())
{
throw new ODataException(o.Strings.ODataJsonPropertyAndValueDeserializer_InvalidPrimitiveTypeName(payloadTypeName));
}
result = this.ReadPrimitiveValueImplementation(
primitiveTargetTypeReference,
validateNullValue);
break;
case EdmTypeKind.Complex:
Debug.Assert(targetTypeReference == null || targetTypeReference.IsComplex(), "Expected a complex type.");
result = this.ReadComplexValueImplementation(
targetTypeReference == null ? null : targetTypeReference.AsComplex(),
payloadTypeName,
serializationTypeNameAnnotation,
duplicatePropertyNamesChecker);
break;
case EdmTypeKind.Collection:
Debug.Assert(this.Version >= ODataVersion.V3, "Type resolution should already fail if we would decide to read a collection value in V1/V2 payload.");
IEdmCollectionTypeReference collectionTypeReference = ValidationUtils.ValidateCollectionType(targetTypeReference);
result = this.ReadCollectionValueImplementation(
collectionTypeReference,
payloadTypeName,
serializationTypeNameAnnotation);
break;
default:
throw new ODataException(o.Strings.General_InternalError(InternalErrorCodes.ODataJsonPropertyAndValueDeserializer_ReadPropertyValue));
}
// If we have no expected type make sure the collection items are of the same kind and specify the same name.
if (collectionValidator != null)
{
string payloadTypeNameFromResult = ODataJsonReaderUtils.GetPayloadTypeName(result);
Debug.Assert(expectedTypeReference == null, "If a collection validator is specified there must not be an expected value type reference.");
collectionValidator.ValidateCollectionItem(payloadTypeNameFromResult, targetTypeKind);
}
}
this.JsonReader.AssertNotBuffering();
return result;
}
/// <summary>
/// Writes out the value of a complex property.
/// </summary>
/// <param name="complexValue">The complex value to write.</param>
/// <param name="propertyTypeReference">The metadata type for the complex value.</param>
/// <param name="isOpenPropertyType">true if the type name belongs to an open property.</param>
/// <param name="duplicatePropertyNamesChecker">The checker instance for duplicate property names.</param>
/// <param name="collectionValidator">The collection validator instance to validate the type names and type kinds of collection items; null if no validation is needed.</param>
/// <remarks>The current recursion depth should be a value, measured by the number of complex and collection values between
/// this complex value and the top-level payload, not including this one.</remarks>
internal void WriteComplexValue(
ODataComplexValue complexValue,
IEdmTypeReference propertyTypeReference,
bool isOpenPropertyType,
DuplicatePropertyNamesChecker duplicatePropertyNamesChecker,
CollectionWithoutExpectedTypeValidator collectionValidator)
{
DebugUtils.CheckNoExternalCallers();
Debug.Assert(complexValue != null, "complexValue != null");
this.IncreaseRecursionDepth();
// Start the object scope which will represent the entire complex instance
this.JsonWriter.StartObjectScope();
// Write the "__metadata" : { "type": "typename" }
// But only if we actually have a typename to write, otherwise we need the __metadata to be omitted entirely
string typeName = complexValue.TypeName;
if (collectionValidator != null)
{
collectionValidator.ValidateCollectionItem(typeName, EdmTypeKind.Complex);
}
// resolve the type name to the type; if no type name is specified we will use the
// type inferred from metadata
IEdmComplexTypeReference complexValueTypeReference =
WriterValidationUtils.ResolveTypeNameForWriting(this.Model, propertyTypeReference, ref typeName, EdmTypeKind.Complex, isOpenPropertyType).AsComplexOrNull();
// If the type is the same as the one specified by the parent collection, omit the type name, since it's not needed.
if (typeName != null && collectionValidator != null)
{
string expectedItemTypeName = collectionValidator.ItemTypeNameFromCollection;
if (string.CompareOrdinal(expectedItemTypeName, typeName) == 0)
{
typeName = null;
}
}
SerializationTypeNameAnnotation serializationTypeNameAnnotation = complexValue.GetAnnotation<SerializationTypeNameAnnotation>();
if (serializationTypeNameAnnotation != null)
{
typeName = serializationTypeNameAnnotation.TypeName;
}
if (typeName != null)
{
// Write the __metadata object
this.JsonWriter.WriteName(JsonConstants.ODataMetadataName);
this.JsonWriter.StartObjectScope();
// "type": "typename"
this.JsonWriter.WriteName(JsonConstants.ODataMetadataTypeName);
this.JsonWriter.WriteValue(typeName);
// End the __metadata
this.JsonWriter.EndObjectScope();
}
// Write the properties of the complex value as usual. Note we do not allow complex types to contain named stream properties.
this.WriteProperties(
complexValueTypeReference == null ? null : complexValueTypeReference.ComplexDefinition(),
complexValue.Properties,
true /* isComplexValue */,
duplicatePropertyNamesChecker,
null /*projectedProperties */);
// End the object scope which represents the complex instance
this.JsonWriter.EndObjectScope();
this.DecreaseRecursionDepth();
}
internal void WritePrimitiveValue(object value, CollectionWithoutExpectedTypeValidator collectionValidator, IEdmTypeReference expectedTypeReference)
{
IEdmPrimitiveTypeReference primitiveTypeReference = EdmLibraryExtensions.GetPrimitiveTypeReference(value.GetType());
if (collectionValidator != null)
{
if (primitiveTypeReference == null)
{
throw new ODataException(Microsoft.Data.OData.Strings.ValidationUtils_UnsupportedPrimitiveType(value.GetType().FullName));
}
collectionValidator.ValidateCollectionItem(primitiveTypeReference.FullName(), EdmTypeKind.Primitive);
}
if (expectedTypeReference != null)
{
ValidationUtils.ValidateIsExpectedPrimitiveType(value, primitiveTypeReference, expectedTypeReference);
}
if ((primitiveTypeReference != null) && primitiveTypeReference.IsSpatial())
{
string typeName = primitiveTypeReference.FullName();
PrimitiveConverter.Instance.WriteJson(value, base.JsonWriter, typeName, base.Version);
}
else
{
base.JsonWriter.WritePrimitiveValue(value, base.Version);
}
}
/// <summary>
/// Reads the primitive, complex or collection value.
/// </summary>
/// <param name="expectedTypeReference">The expected type reference of the value.</param>
/// <param name="duplicatePropertyNamesChecker">The duplicate property names checker to use (cached), or null if new one should be created.</param>
/// <param name="collectionValidator">The collection validator instance if no expected item type has been specified; otherwise null.</param>
/// <param name="validateNullValue">true to validate a null value; otherwise false.</param>
/// <param name="epmPresent">Whether any EPM mappings exist.</param>
/// <returns>The value read (null, primitive CLR value, ODataComplexValue or ODataCollectionValue).</returns>
/// <remarks>
/// Pre-Condition: XmlNodeType.Element - The XML element containing the value to read (also the attributes will be read from it)
/// Post-Condition: XmlNodeType.EndElement - The end tag of the element.
/// XmlNodeType.Element - The empty element node.
/// </remarks>
private object ReadNonEntityValueImplementation(
IEdmTypeReference expectedTypeReference,
DuplicatePropertyNamesChecker duplicatePropertyNamesChecker,
CollectionWithoutExpectedTypeValidator collectionValidator,
bool validateNullValue,
bool epmPresent)
{
this.AssertXmlCondition(XmlNodeType.Element);
Debug.Assert(
expectedTypeReference == null || !expectedTypeReference.IsODataEntityTypeKind(),
"Only primitive, complex or collection types can be read by this method.");
Debug.Assert(
expectedTypeReference == null || collectionValidator == null,
"If an expected value type reference is specified, no collection validator must be provided.");
this.XmlReader.AssertNotBuffering();
// Read the attributes looking for m:type and m:null
string payloadTypeName;
bool isNull;
this.ReadNonEntityValueAttributes(out payloadTypeName, out isNull);
object result;
if (isNull)
{
result = this.ReadNullValue(expectedTypeReference, validateNullValue);
}
else
{
// If we could derive the item type name from the collection's type name and no type name was specified in the payload
// fill it in now.
EdmTypeKind payloadTypeKind;
bool derivedItemTypeNameFromCollectionTypeName = false;
if (collectionValidator != null && payloadTypeName == null)
{
payloadTypeName = collectionValidator.ItemTypeNameFromCollection;
payloadTypeKind = collectionValidator.ItemTypeKindFromCollection;
derivedItemTypeNameFromCollectionTypeName = payloadTypeKind != EdmTypeKind.None;
}
// Resolve the payload type name and compute the target type kind and target type reference.
SerializationTypeNameAnnotation serializationTypeNameAnnotation;
EdmTypeKind targetTypeKind;
IEdmTypeReference targetTypeReference = ReaderValidationUtils.ResolvePayloadTypeNameAndComputeTargetType(
EdmTypeKind.None,
/*defaultPrimitivePayloadType*/ edmStringType,
expectedTypeReference,
payloadTypeName,
this.Model,
this.MessageReaderSettings,
this.Version,
this.GetNonEntityValueKind,
out targetTypeKind,
out serializationTypeNameAnnotation);
if (derivedItemTypeNameFromCollectionTypeName)
{
Debug.Assert(
serializationTypeNameAnnotation == null,
"If we derived the item type name from the collection type name we must not have created a serialization type name annotation.");
serializationTypeNameAnnotation = new SerializationTypeNameAnnotation { TypeName = null };
}
// If we have no expected type make sure the collection items are of the same kind and specify the same name.
if (collectionValidator != null)
{
Debug.Assert(expectedTypeReference == null, "If a collection validator is specified there must not be an expected value type reference.");
collectionValidator.ValidateCollectionItem(payloadTypeName, targetTypeKind);
}
switch (targetTypeKind)
{
case EdmTypeKind.Primitive:
Debug.Assert(targetTypeReference != null && targetTypeReference.IsODataPrimitiveTypeKind(), "Expected an OData primitive type.");
result = this.ReadPrimitiveValue(targetTypeReference.AsPrimitive());
break;
case EdmTypeKind.Complex:
Debug.Assert(targetTypeReference == null || targetTypeReference.IsComplex(), "Expected a complex type.");
result = this.ReadComplexValue(
targetTypeReference == null ? null : targetTypeReference.AsComplex(),
payloadTypeName,
serializationTypeNameAnnotation,
duplicatePropertyNamesChecker,
epmPresent);
break;
case EdmTypeKind.Collection:
IEdmCollectionTypeReference collectionTypeReference = ValidationUtils.ValidateCollectionType(targetTypeReference);
result = this.ReadCollectionValue(
collectionTypeReference,
payloadTypeName,
serializationTypeNameAnnotation);
break;
default:
throw new ODataException(o.Strings.General_InternalError(InternalErrorCodes.ODataAtomPropertyAndValueDeserializer_ReadNonEntityValue));
}
}
this.AssertXmlCondition(true, XmlNodeType.EndElement);
this.XmlReader.AssertNotBuffering();
return result;
}
/// <summary>
/// Writes a primitive value.
/// Uses a registered primitive type converter to write the value if one is registered for the type, otherwise directly writes the value.
/// </summary>
/// <param name="value">The value to write.</param>
/// <param name="collectionValidator">The collection validator instance.</param>
/// <param name="expectedTypeReference">The expected type reference of the primitive value.</param>
internal void WritePrimitiveValue(
object value,
CollectionWithoutExpectedTypeValidator collectionValidator,
IEdmTypeReference expectedTypeReference)
{
DebugUtils.CheckNoExternalCallers();
Debug.Assert(value != null, "value != null");
IEdmPrimitiveTypeReference actualTypeReference = EdmLibraryExtensions.GetPrimitiveTypeReference(value.GetType());
if (collectionValidator != null)
{
if (actualTypeReference == null)
{
throw new ODataException(o.Strings.ValidationUtils_UnsupportedPrimitiveType(value.GetType().FullName));
}
collectionValidator.ValidateCollectionItem(actualTypeReference.FullName(), EdmTypeKind.Primitive);
}
if (expectedTypeReference != null)
{
ValidationUtils.ValidateIsExpectedPrimitiveType(value, actualTypeReference, expectedTypeReference);
}
if (actualTypeReference != null && actualTypeReference.IsSpatial())
{
// For spatial types, we will always write the type name. This is consistent with complex types.
string typeName = actualTypeReference.FullName();
PrimitiveConverter.Instance.WriteJson(value, this.JsonWriter, typeName, this.Version);
}
else
{
this.JsonWriter.WritePrimitiveValue(value, this.Version);
}
}
internal void WritePrimitiveValue(object value, CollectionWithoutExpectedTypeValidator collectionValidator, IEdmTypeReference expectedTypeReference)
{
IEdmPrimitiveTypeReference primitiveTypeReference = EdmLibraryExtensions.GetPrimitiveTypeReference(value.GetType());
if (primitiveTypeReference == null)
{
throw new ODataException(Microsoft.Data.OData.Strings.ValidationUtils_UnsupportedPrimitiveType(value.GetType().FullName));
}
string collectionItemTypeName = primitiveTypeReference.FullName();
if (collectionValidator != null)
{
collectionValidator.ValidateCollectionItem(collectionItemTypeName, EdmTypeKind.Primitive);
if (string.CompareOrdinal(collectionValidator.ItemTypeNameFromCollection, collectionItemTypeName) == 0)
{
collectionItemTypeName = null;
}
}
if (expectedTypeReference != null)
{
ValidationUtils.ValidateIsExpectedPrimitiveType(value, primitiveTypeReference, expectedTypeReference);
}
if ((collectionItemTypeName != null) && (collectionItemTypeName != "Edm.String"))
{
this.WritePropertyTypeAttribute(collectionItemTypeName);
}
AtomValueUtils.WritePrimitiveValue(base.XmlWriter, value);
}
internal bool WriteComplexValue(ODataComplexValue complexValue, IEdmTypeReference metadataTypeReference, bool isOpenPropertyType, bool isWritingCollection, Action beforeValueAction, Action afterValueAction, DuplicatePropertyNamesChecker duplicatePropertyNamesChecker, CollectionWithoutExpectedTypeValidator collectionValidator, EpmValueCache epmValueCache, EpmSourcePathSegment epmSourcePathSegment, ProjectedPropertiesAnnotation projectedProperties)
{
Action action2 = null;
string typeName = complexValue.TypeName;
if (collectionValidator != null)
{
collectionValidator.ValidateCollectionItem(typeName, EdmTypeKind.Complex);
}
this.IncreaseRecursionDepth();
IEdmComplexTypeReference reference = WriterValidationUtils.ResolveTypeNameForWriting(base.Model, metadataTypeReference, ref typeName, EdmTypeKind.Complex, isOpenPropertyType).AsComplexOrNull();
if (((typeName != null) && (collectionValidator != null)) && (string.CompareOrdinal(collectionValidator.ItemTypeNameFromCollection, typeName) == 0))
{
typeName = null;
}
SerializationTypeNameAnnotation annotation = complexValue.GetAnnotation<SerializationTypeNameAnnotation>();
if (annotation != null)
{
typeName = annotation.TypeName;
}
Action beforePropertiesAction = beforeValueAction;
if (typeName != null)
{
if (beforeValueAction != null)
{
if (action2 == null)
{
action2 = delegate {
beforeValueAction();
this.WritePropertyTypeAttribute(typeName);
};
}
beforePropertiesAction = action2;
}
else
{
this.WritePropertyTypeAttribute(typeName);
}
}
if (((base.MessageWriterSettings.WriterBehavior != null) && base.MessageWriterSettings.WriterBehavior.UseV1ProviderBehavior) && !object.ReferenceEquals(projectedProperties, ProjectedPropertiesAnnotation.EmptyProjectedPropertiesMarker))
{
IEdmComplexType definition = (IEdmComplexType) reference.Definition;
if (base.Model.EpmCachedKeepPrimitiveInContent(definition) == null)
{
List<string> keptInContentPropertyNames = null;
foreach (IEdmProperty property in from p in definition.Properties()
where p.Type.IsODataPrimitiveTypeKind()
select p)
{
EntityPropertyMappingAttribute entityPropertyMapping = EpmWriterUtils.GetEntityPropertyMapping(epmSourcePathSegment, property.Name);
if ((entityPropertyMapping != null) && entityPropertyMapping.KeepInContent)
{
if (keptInContentPropertyNames == null)
{
keptInContentPropertyNames = new List<string>();
}
keptInContentPropertyNames.Add(property.Name);
}
}
base.Model.SetAnnotationValue<CachedPrimitiveKeepInContentAnnotation>(definition, new CachedPrimitiveKeepInContentAnnotation(keptInContentPropertyNames));
}
}
bool flag = this.WriteProperties((reference == null) ? null : reference.ComplexDefinition(), EpmValueCache.GetComplexValueProperties(epmValueCache, complexValue, true), isWritingCollection, beforePropertiesAction, afterValueAction, duplicatePropertyNamesChecker, epmValueCache, epmSourcePathSegment, projectedProperties);
this.DecreaseRecursionDepth();
return flag;
}
private object ReadNonEntityValueImplementation(IEdmTypeReference expectedTypeReference, DuplicatePropertyNamesChecker duplicatePropertyNamesChecker, CollectionWithoutExpectedTypeValidator collectionValidator, bool validateNullValue, bool epmPresent)
{
string itemTypeNameFromCollection;
bool flag;
SerializationTypeNameAnnotation annotation;
EdmTypeKind kind2;
this.ReadNonEntityValueAttributes(out itemTypeNameFromCollection, out flag);
if (flag)
{
return this.ReadNullValue(expectedTypeReference, validateNullValue);
}
bool flag2 = false;
if ((collectionValidator != null) && (itemTypeNameFromCollection == null))
{
itemTypeNameFromCollection = collectionValidator.ItemTypeNameFromCollection;
flag2 = collectionValidator.ItemTypeKindFromCollection != EdmTypeKind.None;
}
IEdmTypeReference type = ReaderValidationUtils.ResolvePayloadTypeNameAndComputeTargetType(EdmTypeKind.None, edmStringType, expectedTypeReference, itemTypeNameFromCollection, base.Model, base.MessageReaderSettings, base.Version, new Func<EdmTypeKind>(this.GetNonEntityValueKind), out kind2, out annotation);
if (flag2)
{
annotation = new SerializationTypeNameAnnotation {
TypeName = null
};
}
if (collectionValidator != null)
{
collectionValidator.ValidateCollectionItem(itemTypeNameFromCollection, kind2);
}
switch (kind2)
{
case EdmTypeKind.Primitive:
return this.ReadPrimitiveValue(type.AsPrimitive());
case EdmTypeKind.Complex:
return this.ReadComplexValue((type == null) ? null : type.AsComplex(), itemTypeNameFromCollection, annotation, duplicatePropertyNamesChecker, epmPresent);
case EdmTypeKind.Collection:
{
IEdmCollectionTypeReference collectionTypeReference = ValidationUtils.ValidateCollectionType(type);
return this.ReadCollectionValue(collectionTypeReference, itemTypeNameFromCollection, annotation);
}
}
throw new ODataException(Microsoft.Data.OData.Strings.General_InternalError(InternalErrorCodes.ODataAtomPropertyAndValueDeserializer_ReadNonEntityValue));
}
internal bool WriteComplexValue(
ODataComplexValue complexValue,
IEdmTypeReference metadataTypeReference,
bool isOpenPropertyType,
bool isWritingCollection,
Action beforeValueAction,
Action afterValueAction,
DuplicatePropertyNamesChecker duplicatePropertyNamesChecker,
CollectionWithoutExpectedTypeValidator collectionValidator,
EpmValueCache epmValueCache,
EpmSourcePathSegment epmSourcePathSegment,
ProjectedPropertiesAnnotation projectedProperties)
{
DebugUtils.CheckNoExternalCallers();
Debug.Assert(complexValue != null, "complexValue != null");
string typeName = complexValue.TypeName;
if (collectionValidator != null)
{
collectionValidator.ValidateCollectionItem(typeName, EdmTypeKind.Complex);
}
this.IncreaseRecursionDepth();
// resolve the type name to the type; if no type name is specified we will use the
// type inferred from metadata
IEdmComplexTypeReference complexTypeReference =
WriterValidationUtils.ResolveTypeNameForWriting(this.Model, metadataTypeReference, ref typeName, EdmTypeKind.Complex, isOpenPropertyType).AsComplexOrNull();
// If the type is the same as the one specified by the parent collection, omit the type name, since it's not needed.
if (typeName != null && collectionValidator != null)
{
string expectedItemTypeName = collectionValidator.ItemTypeNameFromCollection;
if (string.CompareOrdinal(expectedItemTypeName, typeName) == 0)
{
typeName = null;
}
}
SerializationTypeNameAnnotation serializationTypeNameAnnotation = complexValue.GetAnnotation<SerializationTypeNameAnnotation>();
if (serializationTypeNameAnnotation != null)
{
typeName = serializationTypeNameAnnotation.TypeName;
}
Action beforeValueCallbackWithTypeName = beforeValueAction;
if (typeName != null)
{
// The beforeValueAction (if specified) will write the actual property element start.
// So if we are to write the type attribute, we must postpone that after the start element was written.
// And so we chain the existing action with our type attribute writing and use that
// as the before action instead.
if (beforeValueAction != null)
{
beforeValueCallbackWithTypeName = () =>
{
beforeValueAction();
this.WritePropertyTypeAttribute(typeName);
};
}
else
{
this.WritePropertyTypeAttribute(typeName);
}
}
// NOTE: see the comments on ODataWriterBehavior.UseV1ProviderBehavior for more information
// NOTE: We have to check for ProjectedPropertiesAnnotation.Empty here to avoid filling the cache for
// complex values we are writing only to ensure we don't have nested EPM-mapped null values
// that will end up in the content eventually.
if (this.MessageWriterSettings.WriterBehavior != null &&
this.MessageWriterSettings.WriterBehavior.UseV1ProviderBehavior &&
!object.ReferenceEquals(projectedProperties, ProjectedPropertiesAnnotation.EmptyProjectedPropertiesMarker))
{
IEdmComplexType complexType = (IEdmComplexType)complexTypeReference.Definition;
CachedPrimitiveKeepInContentAnnotation keepInContentCache = this.Model.EpmCachedKeepPrimitiveInContent(complexType);
if (keepInContentCache == null)
{
// we are about to write the first value of the given type; compute the keep-in-content information for the primitive properties of this type.
List<string> keepInContentPrimitiveProperties = null;
// initialize the cache with all primitive properties
foreach (IEdmProperty edmProperty in complexType.Properties().Where(p => p.Type.IsODataPrimitiveTypeKind()))
{
// figure out the keep-in-content value
EntityPropertyMappingAttribute entityPropertyMapping = EpmWriterUtils.GetEntityPropertyMapping(epmSourcePathSegment, edmProperty.Name);
if (entityPropertyMapping != null && entityPropertyMapping.KeepInContent)
{
if (keepInContentPrimitiveProperties == null)
{
keepInContentPrimitiveProperties = new List<string>();
}
keepInContentPrimitiveProperties.Add(edmProperty.Name);
}
}
this.Model.SetAnnotationValue<CachedPrimitiveKeepInContentAnnotation>(complexType, new CachedPrimitiveKeepInContentAnnotation(keepInContentPrimitiveProperties));
}
}
bool propertyWritten = this.WriteProperties(
complexTypeReference == null ? null : complexTypeReference.ComplexDefinition(),
EpmValueCache.GetComplexValueProperties(epmValueCache, complexValue, true),
isWritingCollection,
beforeValueCallbackWithTypeName,
afterValueAction,
duplicatePropertyNamesChecker,
epmValueCache,
epmSourcePathSegment,
projectedProperties);
this.DecreaseRecursionDepth();
return propertyWritten;
}
/// <summary>
/// Writes a primitive value.
/// </summary>
/// <param name="value">The value to write.</param>
/// <param name="collectionValidator">The collection validator instance.</param>
/// <param name="expectedTypeReference">The expected type of the primitive value.</param>
internal void WritePrimitiveValue(
object value,
CollectionWithoutExpectedTypeValidator collectionValidator,
IEdmTypeReference expectedTypeReference)
{
DebugUtils.CheckNoExternalCallers();
Debug.Assert(value != null, "value != null");
IEdmPrimitiveTypeReference primitiveTypeReference = EdmLibraryExtensions.GetPrimitiveTypeReference(value.GetType());
if (primitiveTypeReference == null)
{
throw new ODataException(o.Strings.ValidationUtils_UnsupportedPrimitiveType(value.GetType().FullName));
}
string typeName = primitiveTypeReference.FullName();
if (collectionValidator != null)
{
collectionValidator.ValidateCollectionItem(typeName, EdmTypeKind.Primitive);
if (string.CompareOrdinal(collectionValidator.ItemTypeNameFromCollection, typeName) == 0)
{
typeName = null;
}
}
if (expectedTypeReference != null)
{
ValidationUtils.ValidateIsExpectedPrimitiveType(value, primitiveTypeReference, expectedTypeReference);
}
if (typeName != null && typeName != Metadata.EdmConstants.EdmStringTypeName)
{
this.WritePropertyTypeAttribute(typeName);
}
AtomValueUtils.WritePrimitiveValue(this.XmlWriter, value);
}
