public override void Serialize(XmlWriter writer, IXmlTemplateNode templateNode, object value, IContentDefinition definition, XRoadMessage message)
{
var valueArray = (Array)value;
if (!(definition is RequestValueDefinition))
{
message.Protocol.Style.WriteExplicitArrayType(writer, elementTypeMap.Definition.Name, valueArray.Length);
}
var arrayItemDefinition = definition.ArrayItemDefinition;
var itemName = arrayItemDefinition.Name.LocalName;
foreach (var valueItem in valueArray)
{
writer.WriteStartElement(itemName);
if (valueItem != null)
{
var typeMap = serializerCache != null?serializerCache.GetTypeMap(valueItem.GetType()) : elementTypeMap;
typeMap.Serialize(writer, templateNode, valueItem, arrayItemDefinition, message);
}
else
{
writer.WriteNilAttribute();
}
writer.WriteEndElement();
}
}
public void Serialize(XmlWriter writer, IXmlTemplateNode templateNode, object value, XRoadMessage message)
{
if (message.EnableFiltering && !filters.Contains(message.FilterName))
{
return;
}
var propertyValue = value != null?getValueMethod(value) : null;
if (!Definition.MergeContent)
{
writer.WriteStartElement(Definition.Name.LocalName);
if (propertyValue == null)
{
writer.WriteNilAttribute();
}
}
if (propertyValue != null)
{
var concreteTypeMap = typeMap.Definition.IsInheritable ? serializerCache.GetTypeMap(propertyValue.GetType()) : typeMap;
concreteTypeMap.Serialize(writer, templateNode, propertyValue, Definition, message);
}
if (!Definition.MergeContent)
{
writer.WriteEndElement();
}
}
private void SerializeValue(XmlWriter writer, object value, ITypeMap typeMap, IXmlTemplateNode templateNode, XRoadMessage message, IContentDefinition contentDefinition)
{
if (value == null)
{
writer.WriteNilAttribute();
return;
}
var concreteTypeMap = typeMap.Definition.IsInheritable ? serializerCache.GetTypeMap(value.GetType()) : typeMap;
concreteTypeMap.Serialize(writer, templateNode, value, contentDefinition, message);
}
public void CanDeserializeAnonymousType()
{
using (var stream = new MemoryStream())
using (var writer = new StreamWriter(stream, Encoding.UTF8))
{
writer.WriteLine(@"<?xml version=""1.0"" encoding=""utf-8""?>");
writer.WriteLine(@"<entity xsi:type=""tns:ContainerType"" xmlns:xsi=""{0}"" xmlns:tns=""{1}"">", NamespaceConstants.XSI, Globals.XRoadProtocol20.ProducerNamespace);
writer.WriteLine(@"<AnonymousProperty>");
writer.WriteLine(@"<Property1 xsi:type=""xsd:string"" xmlns:xsd=""{0}"">1</Property1>", NamespaceConstants.XSD);
writer.WriteLine(@"<Property2 xsi:type=""xsd:string"" xmlns:xsd=""{0}"">2</Property2>", NamespaceConstants.XSD);
writer.WriteLine(@"<Property3 xsi:type=""xsd:string"" xmlns:xsd=""{0}"">3</Property3>", NamespaceConstants.XSD);
writer.WriteLine(@"</AnonymousProperty>");
writer.WriteLine(@"<KnownProperty xsi:type=""xsd:string"" xmlns:xsd=""{0}"">value</KnownProperty>", NamespaceConstants.XSD);
writer.WriteLine(@"</entity>");
writer.Flush();
stream.Position = 0;
using (var reader = XmlReader.Create(stream))
{
Assert.True(reader.MoveToElement(0));
var typeMap = serializerCache31.GetTypeMap(typeof(ContainerType));
using (var message = new XRoadMessage())
{
var entity = typeMap.Deserialize(reader, XRoadXmlTemplate.EmptyNode, Globals.GetTestDefinition(typeof(ContainerType)), message);
Assert.NotNull(entity);
Assert.IsType <ContainerType>(entity);
var container = (ContainerType)entity;
Assert.Equal("value", container.KnownProperty);
Assert.NotNull(container.AnonymousProperty);
Assert.Equal("1", container.AnonymousProperty.Property1);
Assert.Equal("2", container.AnonymousProperty.Property2);
Assert.Equal("3", container.AnonymousProperty.Property3);
}
}
}
}
private static ITypeMap GetPropertyTypeMap(string customTypeName, Type runtimeType, bool isArray, IDictionary <Type, ITypeMap> partialTypeMaps, ISerializerCache serializerCache)
{
return(string.IsNullOrWhiteSpace(customTypeName)
? serializerCache.GetTypeMap(runtimeType, partialTypeMaps)
: serializerCache.GetTypeMap(XName.Get(customTypeName, NamespaceConstants.XSD), isArray));
}
