public override void Serialize(Array item, XmlWriter writer)
{
writer.WriteStartElement("Array");
try
{
writer.WriteAttributeString("Count", item.Length.ToString(CultureInfo.InvariantCulture));
foreach (var element in item)
{
writer.WriteStartElement("Entry");
try
{
if (null == element)
{
writer.WriteAttributeString("IsNull", true.ToString());
continue;
}
writer.WriteAttributeString("IsNull", false.ToString());
var elementType = element.GetType();
writer.WriteAttributeString("Type", elementType.AssemblyQualifiedName ?? "???");
var serializer = XmlSerializerService.GetSerializer(elementType);
serializer.Serialize(element, writer);
}
finally
{
writer.WriteEndElement();
}
}
}
finally { writer.WriteEndElement(); }
}
public override T Deserialize(XmlReader reader)
{
var target = Activator.CreateInstance(typeof(T));
reader.SkipToElement(xmlFriendlyName);
if (reader.IsEmptyElement)
{
return((T)target);
}
reader.ReadStartElement(xmlFriendlyName);
try
{
foreach (var member in Graph)
{
reader.SkipToElement(member.Member.Name);
try
{
IXmlSerializer serializer;
var typeName = reader.GetAttribute("Type");
if (null != typeName)
{
var memberType = Type.GetType(typeName);
if (null == memberType)
{
continue;
}
serializer = XmlSerializerService.GetSerializer(memberType);
}
else
{
serializer = member.TypeSerializer;
}
reader.ReadStartElement(member.Member.Name);
var value = serializer.Deserialize(reader);
try
{
if (value is NullType)
{
member.SetValue(ref target, null);
}
else
{
member.SetValue(ref target, value);
}
}
catch (Exception e)
{
PostQuit(e, MethodBase.GetCurrentMethod());
break;
}
}
finally
{
CompleteRead(reader);
}
}
return((T)target);
}
finally { CompleteRead(reader); }
}
public override Array Deserialize(XmlReader reader)
{
reader.SkipToElement("Array");
try
{
var countString = reader.GetAttribute("Count");
int count;
if (!int.TryParse(countString, out count))
{
return(null);
}
var target = Array.CreateInstance(arrayElementType, count);
if (reader.IsEmptyElement)
{
return(target);
}
reader.ReadStartElement("Array");
for (var i = 0; i < count; ++i)
{
try
{
reader.SkipToElement("Entry");
var isNull = bool.Parse(reader.GetAttribute("IsNull") ?? "true");
if (isNull)
{
continue;
}
var elementTypeString = reader.GetAttribute("Type");
if (null == elementTypeString)
{
continue;
}
var elementType = Type.GetType(elementTypeString);
if (null == elementType)
{
continue;
}
reader.ReadStartElement("Entry");
var serializer = XmlSerializerService.GetSerializer(elementType);
var result = serializer.Deserialize(reader);
target.SetValue(result, i);
}
finally { reader.ReadEndElement(); }
}
return(target);
}
finally
{
if (reader.IsEmptyElement)
{
reader.Skip();
}
else
{
reader.ReadEndElement();
}
}
}
/// <summary>
/// Serializes the specified item.
/// </summary>
/// <param name="item">The item.</param>
/// <param name="target">The target.</param>
public override void Serialize(T item, XmlWriter target)
{
target.WriteStartElement(xmlFriendlyName);
try
{
foreach (var member in Graph)
{
target.WriteStartElement(member.Member.Name);
try
{
IXmlSerializer serializer;
var value = member.IsDelegate ? null : member.GetValue(item);
if (null == value || member.IsUntyped)
{
value = value ?? new NullType();
var type = value.GetType();
serializer = XmlSerializerService.GetSerializer(type);
WriteType(target, type);
}
else
{
serializer = member.TypeSerializer;
}
try
{
serializer.Serialize(value, target);
}
catch (Exception e)
{
PostQuit(e, MethodBase.GetCurrentMethod());
break;
}
}
finally { target.WriteEndElement(); }
}
}
finally { target.WriteEndElement(); }
}
public ArraySerializer(Type arrayType)
{
elementType = arrayType.GetElementType();
elementSerializer = XmlSerializerService.GetSerializer(elementType);
}
