internal static void ApplyProperty(ODataProperty property, IEdmStructuredTypeReference resourceType, object resource,
ODataDeserializerProvider deserializerProvider, ODataDeserializerContext readContext)
{
IEdmProperty edmProperty = resourceType.FindProperty(property.Name);
string propertyName = property.Name;
if (edmProperty != null)
{
propertyName = EdmLibHelpers.GetClrPropertyName(edmProperty, readContext.Model);
}
IEdmTypeReference propertyType = edmProperty != null ? edmProperty.Type : null; // open properties have null values
EdmTypeKind propertyKind;
object value = ConvertValue(property.Value, ref propertyType, deserializerProvider, readContext, out propertyKind);
if (propertyKind == EdmTypeKind.Collection)
{
SetCollectionProperty(resource, edmProperty, value, propertyName);
}
else
{
if (propertyKind == EdmTypeKind.Primitive && !readContext.IsUntyped)
{
value = EdmPrimitiveHelpers.ConvertPrimitiveValue(value, GetPropertyType(resource, propertyName));
}
SetProperty(resource, propertyName, value);
}
}
public override void WriteProperty(ODataProperty property)
{
var schema = this.AvroWriter.UpdateSchema(property.Value, null);
var obj = ODataAvroConvert.FromODataObject(property.Value, schema);
this.AvroWriter.Write(obj);
this.Flush();
}
internal static void ApplyProperty(ODataProperty property, IEdmStructuredTypeReference resourceType, object resource,
ODataDeserializerProvider deserializerProvider, ODataDeserializerContext readContext, AssembliesResolver assembliesResolver)
{
IEdmProperty edmProperty = resourceType.FindProperty(property.Name);
bool isDynamicProperty = false;
string propertyName = property.Name;
if (edmProperty != null)
{
propertyName = EdmLibHelpers.GetClrPropertyName(edmProperty, readContext.Model);
}
else
{
IEdmStructuredType structuredType = resourceType.StructuredDefinition();
isDynamicProperty = structuredType != null && structuredType.IsOpen;
}
// dynamic properties have null values
IEdmTypeReference propertyType = edmProperty != null ? edmProperty.Type : null;
EdmTypeKind propertyKind;
object value = ConvertValue(property.Value, ref propertyType, deserializerProvider, readContext,
out propertyKind);
if (isDynamicProperty)
{
SetDynamicProperty(resource, resourceType, propertyKind, propertyName, value, propertyType,
readContext, assembliesResolver);
}
else
{
SetDeclaredProperty(resource, propertyKind, propertyName, value, edmProperty, readContext, assembliesResolver);
}
}
public override void WriteProperty(ODataProperty property)
{
var val = property.Value as ODataComplexValue;
if (val == null)
{
throw new ApplicationException("only support write complex type property.");
}
this.writer.WriteStart();
foreach (ODataProperty prop in val.Properties)
{
string name = null;
string @params = string.Empty;
int idx = prop.Name.IndexOf('_');
if (idx < 0)
{
name = prop.Name;
}
else
{
name = prop.Name.Substring(0, idx);
@params = string.Join(";", prop.Name.Substring(idx + 1).Split('_'));
}
foreach (ODataInstanceAnnotation anns in prop.InstanceAnnotations)
{
@params += ";" + anns.Name.Substring(6) /*VCARD.*/ + "=" + ((ODataPrimitiveValue)anns.Value).Value;
}
this.writer.WriteItem(null, name, @params, (string)prop.Value);
}
this.writer.WriteEnd();
}
/// <summary>
/// Validates an <see cref="ODataProperty"/> for not being null.
/// </summary>
/// <param name="property">The property to validate for not being null.</param>
internal static void ValidatePropertyNotNull(ODataProperty property)
{
if (property == null)
{
throw new ODataException(Strings.WriterValidationUtils_PropertyMustNotBeNull);
}
}
public void ShouldBeAbleToSetThePropertySerializationInfo()
{
ODataProperty property = new ODataProperty();
ODataPropertySerializationInfo serializationInfo = new ODataPropertySerializationInfo();
property.SetSerializationInfo(serializationInfo);
property.SerializationInfo.Should().BeSameAs(serializationInfo);
}
public void ShouldBeAbleToClearThePropertySerializationInfo()
{
ODataProperty property = new ODataProperty();
ODataPropertySerializationInfo serializationInfo = new ODataPropertySerializationInfo();
property.SerializationInfo = serializationInfo;
property.SetSerializationInfo(null);
property.SerializationInfo.Should().BeNull();
}
public void ApplyNonExistantPropertyWithIgnoreMissingPropertiesShouldNotError()
{
TestMaterializerContext context = new TestMaterializerContext() {IgnoreMissingProperties = true};
CollectionValueMaterializationPolicyTests.Point point = new CollectionValueMaterializationPolicyTests.Point();
ODataProperty property = new ODataProperty() {Name = "Z", Value = 10};
this.CreatePrimitiveValueMaterializationPolicy(context).ApplyDataValue(context.ResolveTypeForMaterialization(typeof(CollectionValueMaterializationPolicyTests.Point), null), property, point);
}
/// <summary>
/// Deserializes the primitive from the given <paramref name="primitiveProperty"/> under the given <paramref name="readContext"/>.
/// </summary>
/// <param name="primitiveProperty">The primitive property to deserialize.</param>
/// <param name="readContext">The deserializer context.</param>
/// <returns>The deserialized OData primitive value.</returns>
public virtual object ReadPrimitive(ODataProperty primitiveProperty, ODataDeserializerContext readContext)
{
if (primitiveProperty == null)
{
throw Error.ArgumentNull("primitiveProperty");
}
return primitiveProperty.Value;
}
public void ApplyODataComplexValueForCollectionPropertyShouldError()
{
TestMaterializerContext context = new TestMaterializerContext();
ComplexTypeWithPrimitiveCollection complexInstance = new ComplexTypeWithPrimitiveCollection();
ODataProperty property = new ODataProperty() { Name = "Strings", Value = new ODataComplexValue() };
Action test = () => this.CreatePrimitiveValueMaterializationPolicy(context).ApplyDataValue(context.ResolveTypeForMaterialization(typeof(ComplexTypeWithPrimitiveCollection), null), property, complexInstance);
test.ShouldThrow<InvalidOperationException>().WithMessage(DSClient.Strings.AtomMaterializer_InvalidCollectionItem(property.Name));
}
private static ODataProperty CreateProperty(string name, object value)
{
ODataProperty prop = new ODataProperty()
{
Name = name,
Value = value,
};
return prop;
}
public void ComplexTypeRoundtripAtomTest()
{
var age = new ODataProperty() { Name = "Age", Value = (Int16)18 };
var email = new ODataProperty() { Name = "Email", Value = "*****@*****.**" };
var tel = new ODataProperty() { Name = "Tel", Value = "0123456789" };
var id = new ODataProperty() { Name = "ID", Value = Guid.Empty };
ODataComplexValue complexValue = new ODataComplexValue() { TypeName = "NS.PersonalInfo", Properties = new[] { age, email, tel, id } };
this.VerifyComplexTypeRoundtrip(complexValue, "NS.PersonalInfo");
}
/// <summary>
/// Materializes the enum data value.
/// </summary>
/// <param name="valueType">Type of the collection item.</param>
/// <param name="property">The ODataProperty.</param>
/// <returns>Materialized enum data CLR value.</returns>
public object MaterializeEnumTypeProperty(Type valueType, ODataProperty property)
{
object materializedValue = null;
ODataEnumValue value = property.Value as ODataEnumValue;
this.MaterializeODataEnumValue(valueType, value.TypeName, value.Value, () => "TODO: Is this reachable?", out materializedValue);
if (!property.HasMaterializedValue())
{
property.SetMaterializedValue(materializedValue);
}
return materializedValue;
}
public void ShouldBeAbleToWriteInstanceAnnotationsInResponse()
{
ODataProperty property = new ODataProperty()
{
Name = "Prop",
Value = Guid.Empty,
InstanceAnnotations = new Collection<ODataInstanceAnnotation>
{
new ODataInstanceAnnotation("Annotation.1", new ODataPrimitiveValue(true)),
new ODataInstanceAnnotation("Annotation.2", new ODataPrimitiveValue(123))
}
};
WriteAndValidate(outputContext => outputContext.WriteProperty(property), "{\"@odata.context\":\"http://odata.org/test/$metadata#Edm.Guid\",\"@Annotation.1\":true,\"@Annotation.2\":123,\"value\":\"00000000-0000-0000-0000-000000000000\"}");
}
internal static void ApplyProperty(ODataProperty property, IEdmStructuredTypeReference resourceType, object resource,
ODataDeserializerProvider deserializerProvider, ODataDeserializerContext readContext)
{
IEdmProperty edmProperty = resourceType.FindProperty(property.Name);
// try to deserializer the dynamic properties for open type.
if (edmProperty == null)
{
// the logic here works for open complex type and open entity type.
IEdmStructuredType structuredType = resourceType.StructuredDefinition();
if (structuredType != null && structuredType.IsOpen)
{
if (ApplyDynamicProperty(property, structuredType, resource, deserializerProvider, readContext))
{
return;
}
}
}
string propertyName = property.Name;
if (edmProperty != null)
{
propertyName = EdmLibHelpers.GetClrPropertyName(edmProperty, readContext.Model);
}
IEdmTypeReference propertyType = edmProperty != null ? edmProperty.Type : null; // open properties have null values
EdmTypeKind propertyKind;
object value = ConvertValue(property.Value, ref propertyType, deserializerProvider, readContext, out propertyKind);
if (propertyKind == EdmTypeKind.Collection)
{
SetCollectionProperty(resource, edmProperty, value, propertyName);
}
else
{
if (!readContext.IsUntyped)
{
if (propertyKind == EdmTypeKind.Primitive)
{
value = EdmPrimitiveHelpers.ConvertPrimitiveValue(value, GetPropertyType(resource, propertyName));
}
else if (propertyKind == EdmTypeKind.Enum)
{
value = EnumDeserializationHelpers.ConvertEnumValue(value, GetPropertyType(resource, propertyName));
}
}
SetProperty(resource, propertyName, value);
}
}
public void PropertyGettersAndSettersTest()
{
string name1 = "ODataPrimitiveProperty";
object value1 = "Hello world";
ODataProperty primitiveProperty = new ODataProperty()
{
Name = name1,
Value = value1,
};
this.Assert.AreEqual(name1, primitiveProperty.Name, "Expected equal name values.");
this.Assert.AreSame(value1, primitiveProperty.Value, "Expected reference equal values for property 'Value'.");
string name2 = "ODataComplexProperty";
ODataComplexValue value2 = new ODataComplexValue()
{
Properties = new[]
{
new ODataProperty() { Name = "One", Value = 1 },
new ODataProperty() { Name = "Two", Value = 2 },
}
};
ODataProperty complexProperty = new ODataProperty()
{
Name = name2,
Value = value2,
};
this.Assert.AreEqual(name2, complexProperty.Name, "Expected equal name values.");
this.Assert.AreSame(value2, complexProperty.Value, "Expected reference equal values for property 'Value'.");
string name3 = "ODataCollectionProperty";
ODataCollectionValue value3 = new ODataCollectionValue()
{
Items = new[] { 1, 2, 3 }
};
ODataProperty multiValueProperty = new ODataProperty()
{
Name = name3,
Value = value3,
};
this.Assert.AreEqual(name3, multiValueProperty.Name, "Expected equal name values.");
this.Assert.AreSame(value3, multiValueProperty.Value, "Expected reference equal values for property 'Value'.");
}
/// <summary>
/// Validates a stream reference property.
/// </summary>
/// <param name="streamProperty">The stream property to check.</param>
/// <param name="structuredType">The owning type of the stream property or null if no metadata is available.</param>
/// <param name="streamEdmProperty">The stream property defined by the model.</param>
/// <param name="messageReaderSettings">The message reader settings being used.</param>
internal static void ValidateStreamReferenceProperty(ODataProperty streamProperty, IEdmStructuredType structuredType, IEdmProperty streamEdmProperty, ODataMessageReaderSettings messageReaderSettings)
{
Debug.Assert(streamProperty != null, "streamProperty != null");
ValidationUtils.ValidateStreamReferenceProperty(streamProperty, streamEdmProperty);
if (structuredType != null && structuredType.IsOpen)
{
// If no property match was found in the metadata and an error wasn't raised,
// it is an open property (which is not supported for streams).
if (streamEdmProperty == null && !messageReaderSettings.ReportUndeclaredLinkProperties)
{
// Fails with the correct error message.
ValidationUtils.ValidateOpenPropertyValue(streamProperty.Name, streamProperty.Value);
}
}
}
public void ReadInline_Calls_ReadPrimitive()
{
// Arrange
IEdmPrimitiveTypeReference primitiveType = EdmCoreModel.Instance.GetInt32(isNullable: true);
Mock<ODataPrimitiveDeserializer> deserializer = new Mock<ODataPrimitiveDeserializer>();
ODataProperty property = new ODataProperty();
ODataDeserializerContext readContext = new ODataDeserializerContext();
deserializer.Setup(d => d.ReadPrimitive(property, readContext)).Returns(42).Verifiable();
// Act
var result = deserializer.Object.ReadInline(property, primitiveType, readContext);
// Assert
deserializer.Verify();
Assert.Equal(42, result);
}
private void EntryStarting(WritingEntryArgs ea)
{
var odataProps = ea.Entry.Properties as List<ODataProperty>;
var entityState = contextWrapper.Context.Entities.First(e => e.Entity == ea.Entity).State;
// Send up an undeclared property on an Open Type.
if (entityState == EntityStates.Modified || entityState == EntityStates.Added)
{
if (ea.Entity.GetType() == typeof(Row))
{
// In practice, the data from this undeclared property would probably be stored in a transient property of the partial companion class to the client proxy.
var undeclaredOdataProperty = new ODataProperty() { Name = "dynamicPropertyKey", Value = "dynamicPropertyValue" };
odataProps.Add(undeclaredOdataProperty);
}
}
}
public void PropertyGettersAndSettersTest()
{
string etag = "ETag";
Uri id = new Uri("http://odatalib.org/id");
Uri readlink = new Uri("http://odatalib.org/readlink");
Uri editlink = new Uri("http://odatalib.org/editlink");
ODataStreamReferenceValue mediaResource = new ODataStreamReferenceValue();
ODataProperty primitiveProperty = new ODataProperty();
ODataProperty complexProperty = new ODataProperty();
ODataProperty multiValueProperty = new ODataProperty();
ODataProperty namedStreamProperty = new ODataProperty();
List<ODataProperty> properties = new List<ODataProperty>()
{
primitiveProperty,
complexProperty,
multiValueProperty,
namedStreamProperty
};
string typeName = "ODataLibSample.DummyType";
ODataEntry entry = new ODataEntry()
{
ETag = etag,
Id = id,
EditLink = editlink,
Properties = properties,
TypeName = typeName,
MediaResource = mediaResource
};
this.Assert.IsNull(entry.ReadLink, "Expect ReadLink to be null if it was not set.");
entry.ReadLink = readlink;
this.Assert.AreSame(etag, entry.ETag, "Expected reference equal values for property 'ETag'.");
this.Assert.AreSame(id, entry.Id, "Expected reference equal values for property 'Id'.");
this.Assert.AreSame(readlink, entry.ReadLink, "Expected reference equal values for property 'ReadLink'.");
this.Assert.AreSame(editlink, entry.EditLink, "Expected reference equal values for property 'EditLink'.");
this.Assert.AreSame(properties, entry.Properties, "Expected reference equal values for property 'Properties'.");
this.Assert.AreSame(typeName, entry.TypeName, "Expected reference equal values for property 'TypeName'.");
this.Assert.AreSame(mediaResource, entry.MediaResource, "Expected reference equals for property 'MediaResource'.");
}
public void JsonPaddingEnabledWithUserSpecifiedContentType()
{
var settings = new ODataMessageWriterSettings {JsonPCallback = "functionName", DisableMessageStreamDisposal = true};
settings.SetServiceDocumentUri(new Uri("http://stuff"));
IODataResponseMessage message = new InMemoryMessage {StatusCode = 200, Stream = new MemoryStream()};
message.SetHeader("Content-Type", "application/json");
var property = new ODataProperty {Name = "PropertyName", Value = "value"};
using (var writer = new ODataMessageWriter(message, settings))
{
writer.WriteProperty(property);
}
var responseStream = message.GetStream();
responseStream.Position = 0;
var responseString = new StreamReader(responseStream).ReadToEnd();
responseString.Should().Be("functionName({\"@odata.context\":\"http://stuff/$metadata#Edm.String\",\"value\":\"value\"})");
message.GetHeader("Content-Type").Should().StartWith("text/javascript");
}
public void NullValueShouldBeAppliedToSubComplexValueProperty()
{
TestMaterializerContext context = new TestMaterializerContext();
ComplexTypeWithChildComplexType complexInstance = new ComplexTypeWithChildComplexType();
complexInstance.InnerComplexProperty = new ChildComplexType();
ODataProperty property = new ODataProperty() { Name = "InnerComplexProperty", Value = null };
this.CreatePrimitiveValueMaterializationPolicy(context).ApplyDataValue(context.ResolveTypeForMaterialization(typeof(ComplexTypeWithChildComplexType), null), property, complexInstance);
Assert.IsNull(complexInstance.InnerComplexProperty);
}
public void ValueShouldBeAppliedRegardlessIfPropertyStartsNullOrNot()
{
foreach (var startingPropertyState in new ChildComplexType[] {null, new ChildComplexType()})
{
TestMaterializerContext context = new TestMaterializerContext();
ComplexTypeWithChildComplexType complexInstance = new ComplexTypeWithChildComplexType();
complexInstance.InnerComplexProperty = startingPropertyState;
ODataProperty property = new ODataProperty() {Name = "InnerComplexProperty", Value = new ODataComplexValue() {Properties = new ODataProperty[] {new ODataProperty() {Name = "Prop", Value = 1}}}};
this.CreatePrimitiveValueMaterializationPolicy(context).ApplyDataValue(context.ResolveTypeForMaterialization(typeof(ComplexTypeWithChildComplexType), null), property, complexInstance);
complexInstance.InnerComplexProperty.Prop.Should().Be(1);
}
}
public void ApplyODataCollectionValueToNullCollectionProperty()
{
TestMaterializerContext context = new TestMaterializerContext();
ComplexTypeWithPrimitiveCollection complexInstance = new ComplexTypeWithPrimitiveCollection();
complexInstance.Strings = null;
ODataProperty property = new ODataProperty() { Name = "Strings", Value = new ODataCollectionValue() { Items = new string[] { "foo" }, TypeName = typeof(ComplexTypeWithPrimitiveCollection).FullName } };
this.CreatePrimitiveValueMaterializationPolicy(context).ApplyDataValue(context.ResolveTypeForMaterialization(typeof(ComplexTypeWithPrimitiveCollection), null), property, complexInstance);
complexInstance.Strings.Should().HaveCount(1);
complexInstance.Strings[0].Should().Be("foo");
}
public void ApplyODataCollectionValueToNonNullExistingCollectionProperty()
{
TestMaterializerContext context = new TestMaterializerContext();
ComplexTypeWithPrimitiveCollection complexInstance = new ComplexTypeWithPrimitiveCollection();
complexInstance.Strings.Add("ShouldBeCleared");
ODataProperty property = new ODataProperty() { Name = "Strings", Value = new ODataCollectionValue() };
this.CreatePrimitiveValueMaterializationPolicy(context).ApplyDataValue(context.ResolveTypeForMaterialization(typeof(ComplexTypeWithPrimitiveCollection), null), property, complexInstance);
complexInstance.Strings.Should().HaveCount(0);
}
public void CreateEntry_Calls_CreateStructuralProperty_ForEachSelectedStructuralProperty()
{
// Arrange
SelectExpandNode selectExpandNode = new SelectExpandNode
{
SelectedStructuralProperties = { new Mock<IEdmStructuralProperty>().Object, new Mock<IEdmStructuralProperty>().Object }
};
ODataProperty[] properties = new ODataProperty[] { new ODataProperty(), new ODataProperty() };
Mock<ODataEntityTypeSerializer> serializer = new Mock<ODataEntityTypeSerializer>(_serializerProvider);
serializer.CallBase = true;
serializer
.Setup(s => s.CreateStructuralProperty(selectExpandNode.SelectedStructuralProperties.ElementAt(0), _entityInstanceContext))
.Returns(properties[0])
.Verifiable();
serializer
.Setup(s => s.CreateStructuralProperty(selectExpandNode.SelectedStructuralProperties.ElementAt(1), _entityInstanceContext))
.Returns(properties[1])
.Verifiable();
// Act
ODataEntry entry = serializer.Object.CreateEntry(selectExpandNode, _entityInstanceContext);
// Assert
serializer.Verify();
Assert.Equal(properties, entry.Properties);
}
/// <summary>
/// Validates a named stream property to ensure it's not null and it's name if correct.
/// </summary>
/// <param name="streamProperty">The stream reference property to validate.</param>
/// <param name="edmProperty">Property metadata to validate against.</param>
/// <param name="writingResponse">true when writing a response; otherwise false.</param>
/// <param name="bypassValidation">Bypass the validation if it is true.</param>
/// <remarks>This does NOT validate the value of the stream property, just the property itself.</remarks>
internal static void ValidateStreamReferenceProperty(ODataProperty streamProperty, IEdmProperty edmProperty, bool writingResponse, bool bypassValidation = false)
{
Debug.Assert(streamProperty != null, "streamProperty != null");
if (bypassValidation)
{
return;
}
ValidationUtils.ValidateStreamReferenceProperty(streamProperty, edmProperty);
if (!writingResponse)
{
// Stream properties are only valid in responses; writers fail if they encounter them in requests.
throw new ODataException(Strings.WriterValidationUtils_StreamPropertyInRequest(streamProperty.Name));
}
}
/// <summary>
/// Provide additional serialization information to the <see cref="ODataWriter"/> for <paramref name="property"/>.
/// </summary>
/// <param name="property">The instance to set the serialization info.</param>
/// <param name="serializationInfo">The serialization info to set.</param>
public static void SetSerializationInfo(this ODataProperty property, ODataPropertySerializationInfo serializationInfo)
{
ExceptionUtils.CheckArgumentNotNull(property, "property");
property.SerializationInfo = serializationInfo;
}
/// <summary>
/// Validates a named stream property to ensure it's not null and it's name if correct.
/// </summary>
/// <param name="streamProperty">The stream reference property to validate.</param>
/// <param name="edmProperty">Property metadata to validate against.</param>
/// <param name="writingResponse">true when writing a response; otherwise false.</param>
/// <remarks>This does NOT validate the value of the stream property, just the property itself.</remarks>
public void ValidateStreamReferenceProperty(ODataProperty streamProperty, IEdmProperty edmProperty, bool writingResponse)
{
}
/// <summary>
/// Writes an <see cref="ODataProperty"/> as message payload.
/// </summary>
/// <param name="property">The property to write.</param>
/// <remarks>It is the responsibility of this method to flush the output before the method returns.</remarks>
internal virtual void WriteProperty(ODataProperty property)
{
throw this.CreatePayloadKindNotSupportedException(ODataPayloadKind.Property);
}
/// <summary>
/// Validates an <see cref="ODataProperty"/> for not being null.
/// </summary>
/// <param name="property">The property to validate for not being null.</param>
public void ValidatePropertyNotNull(ODataProperty property)
{
WriterValidationUtils.ValidatePropertyNotNull(property);
}
public void ApplyODataDerivedComplexValueForBaseComplexTypeProperty()
{
TestMaterializerContext context = new TestMaterializerContext();
ComplexTypeWithChildComplexType complexInstance = new ComplexTypeWithChildComplexType();
complexInstance.InnerComplexProperty = new DerivedComplexType {DerivedProp = 1};
//In a true client, a TypeResolver will be used to resolve derived property type.
context.ResolveTypeForMaterializationOverrideFunc = (Type type, string name) =>
{
if (name == "DerivedComplexType")
{
var edmType = context.Model.GetOrCreateEdmType(typeof(DerivedComplexType));
return new ClientTypeAnnotation(edmType, typeof(DerivedComplexType), "DerivedComplexType", context.Model);
}
else
{
var edmType = context.Model.GetOrCreateEdmType(typeof(ComplexTypeWithChildComplexType));
return new ClientTypeAnnotation(edmType, typeof(ComplexTypeWithChildComplexType), "ComplexTypeWithChildComplexType", context.Model);
}
};
IEdmType t = context.Model.GetOrCreateEdmType(typeof(DerivedComplexType));
ODataProperty property = new ODataProperty() { Name = "InnerComplexProperty", Value = new ODataComplexValue { TypeName = "DerivedComplexType", Properties = new ODataProperty[] { new ODataProperty { Name = "DerivedProp", Value = 1 } } } };
Action test = () => this.CreatePrimitiveValueMaterializationPolicy(context).ApplyDataValue(context.ResolveTypeForMaterialization(typeof(ComplexTypeWithChildComplexType), null), property, complexInstance);
test.ShouldNotThrow();
}
/// <summary>
/// Applies collectionValue item to the provided <paramref name="collectionInstance"/>.
/// </summary>
/// <param name="collectionProperty">Atom property containing materialized Collection items.</param>
/// <param name="collectionInstance">Collection instance. Must implement ICollection<T> where T is either primitive or complex type (not an entity).</param>
/// <param name="collectionItemType">Type of items in the Collection. Note: this could be calculated from collectionInstance but we already have it in upstream methods.</param>
/// <param name="addValueToBackingICollectionInstance">Action called actually add a Collection item to <paramref name="collectionInstance" /></param>
/// <param name="isElementNullable">If element type is nullable.</param>
internal void ApplyCollectionDataValues(
ODataProperty collectionProperty,
object collectionInstance,
Type collectionItemType,
Action<object, object> addValueToBackingICollectionInstance,
bool isElementNullable)
{
Debug.Assert(collectionProperty != null, "property != null");
Debug.Assert(collectionProperty.Value != null, "Collection should have already been checked for nullness");
Debug.Assert(collectionInstance != null, "collectionInstance != null");
Debug.Assert(WebUtil.IsCLRTypeCollection(collectionInstance.GetType(), this.materializerContext.Model), "collectionInstance must be a CollectionValue");
Debug.Assert(collectionItemType.IsAssignableFrom(
ClientTypeUtil.GetImplementationType(collectionInstance.GetType(), typeof(ICollection<>)).GetGenericArguments()[0]),
"collectionItemType has to match the collectionInstance generic type.");
Debug.Assert(!ClientTypeUtil.TypeIsEntity(collectionItemType, this.materializerContext.Model), "CollectionValues cannot contain entities");
Debug.Assert(addValueToBackingICollectionInstance != null, "AddValueToBackingICollectionInstance != null");
ODataCollectionValue collectionValue = collectionProperty.Value as ODataCollectionValue;
this.ApplyCollectionDataValues(
collectionValue.Items,
collectionValue.TypeName,
collectionInstance,
collectionItemType,
addValueToBackingICollectionInstance,
isElementNullable);
collectionProperty.SetMaterializedValue(collectionInstance);
}
/// <summary>
/// Asynchronously writes an <see cref="ODataProperty"/> as message payload.
/// </summary>
/// <param name="property">The property to write</param>
/// <returns>A task representing the asynchronous operation of writing the property.</returns>
/// <remarks>It is the responsibility of this method to flush the output before the task finishes.</remarks>
public virtual Task WritePropertyAsync(ODataProperty property)
{
throw this.CreatePayloadKindNotSupportedException(ODataPayloadKind.Property);
}
/// <summary>
/// Creates Collection instance of store Collection items.
/// </summary>
/// <param name="collectionProperty">ODataProperty instance representing the Collection as seen in the atom payload.</param>
/// <param name="userCollectionType">CLR type of the Collection as defined by the user.</param>
/// <returns>Newly created Collection instance. Never null.</returns>
internal object CreateCollectionPropertyInstance(ODataProperty collectionProperty, Type userCollectionType)
{
Debug.Assert(collectionProperty != null, "collectionProperty != null");
Debug.Assert(collectionProperty.Value != null, "Collection should have already been checked for nullness");
Debug.Assert(userCollectionType != null, "userCollectionType != null");
Debug.Assert(ClientTypeUtil.GetImplementationType(userCollectionType, typeof(ICollection<>)) != null, "Not a Collection - Collection types must implement ICollection<> interface.");
Debug.Assert(
!ClientTypeUtil.TypeIsEntity(ClientTypeUtil.GetImplementationType(userCollectionType, typeof(ICollection<>)).GetGenericArguments()[0], this.materializerContext.Model),
"Not a Collection - Collections cannot contain entities");
Debug.Assert(!(collectionProperty.Value is ODataFeed) && !(collectionProperty.Value is ODataEntry), "Collection properties should never materialized from entry or feed payload");
ODataCollectionValue collectionValue = collectionProperty.Value as ODataCollectionValue;
// get a ClientType instance for the Collection property. This determines what type will be used later when creating the actual Collection instance
ClientTypeAnnotation collectionClientType = this.materializerContext.ResolveTypeForMaterialization(userCollectionType, collectionValue.TypeName);
return this.CreateCollectionInstance(collectionClientType.EdmTypeReference as IEdmCollectionTypeReference, collectionClientType.ElementType, () => DSClient.Strings.AtomMaterializer_NoParameterlessCtorForCollectionProperty(collectionProperty.Name, collectionClientType.ElementTypeName));
}
/// <summary>
/// Validates an <see cref="ODataProperty"/> for not being null.
/// </summary>
/// <param name="property">The property to validate for not being null.</param>
public void ValidatePropertyNotNull(ODataProperty property)
{
}
/// <summary>
/// Validates a named stream property to ensure it's not null and it's name if correct.
/// </summary>
/// <param name="streamProperty">The stream reference property to validate.</param>
/// <param name="edmProperty">Property metadata to validate against.</param>
/// <param name="writingResponse">true when writing a response; otherwise false.</param>
/// <remarks>This does NOT validate the value of the stream property, just the property itself.</remarks>
public void ValidateStreamReferenceProperty(ODataProperty streamProperty, IEdmProperty edmProperty, bool writingResponse)
{
WriterValidationUtils.ValidateStreamReferenceProperty(streamProperty, edmProperty, writingResponse);
}
