public static void ReadXml(this object receiver, string xml, ReadSettings settings, QName root)
{
TkDebug.AssertArgumentNull(root, "root", null);
ReadFromString(receiver, "Xml", null, xml, settings, root);
}
public static string WriteXml(this object receiver, WriteSettings settings, QName root)
{
return(WriteXml(receiver, null, settings, root));
}
public static void ReadObject(IObjectSerializer serializer, object reader,
object receiver, string modelName, ReadSettings settings, QName root,
BaseObjectAttribute attribute, object serializerData, SerializerOptions options)
{
if (receiver is IDictionary)
{
BaseDictionaryAttribute attr = attribute as BaseDictionaryAttribute;
options.CheckReadDictionary(serializer, attr);
if (attr == null)
{
attr = GetDictionaryAttribute(receiver, root);
}
serializer.ReadDictionary(reader, receiver.Convert <IDictionary>(), attr,
modelName, settings, root, serializerData);
}
else if (receiver is IList)
{
SimpleElementAttribute attr = attribute as SimpleElementAttribute;
options.CheckReadList(serializer, attr);
if (attr == null)
{
Type valueType = ObjectUtil.GetListValueType(receiver.GetType(), "", null);
attr = GetElementAttribute(receiver, valueType);
}
serializer.ReadList(reader, receiver.Convert <IList>(), attr, modelName,
settings, root, serializerData);
}
else
{
options.CheckReadObject(serializer);
serializer.ReadObject(reader, receiver, modelName, settings, root, serializerData);
}
}
private static BaseDictionaryAttribute GetDictionaryAttribute(object receiver, QName root)
{
Type valueType = ObjectUtil.GetDictionaryValueType(receiver.GetType(), "", null);
ITkTypeConverter converter = TkTypeDescriptor.GetSimpleConverter(valueType);
BaseDictionaryAttribute attr;
if (converter == null)
{
attr = new ObjectDictionaryAttribute {
ObjectType = valueType
}
}
;
else
{
attr = new DictionaryAttribute {
ObjectType = valueType
}
};
attr.Assign(root);
return(attr);
}
public bool ReadToRoot(object reader, QName root)
{
return(true);
}
public static void WriteObject(IObjectSerializer serializer, object writer,
object receiver, string modelName, WriteSettings settings, QName root,
BaseObjectAttribute attribute, object serializerData, SerializerOptions options)
{
Type type = receiver.GetType();
if (receiver is IDictionary)
{
BaseDictionaryAttribute attr = attribute as BaseDictionaryAttribute;
options.CheckWriteDictionary(serializer, attr);
if (attr == null)
{
attr = GetDictionaryAttribute(receiver, root);
}
serializer.WriteDictionary(writer, receiver.Convert <IDictionary>(), attr,
modelName, settings, root, serializerData);
}
else if (type.IsArray || receiver is IList)
{
SimpleElementAttribute attr = attribute as SimpleElementAttribute;
options.CheckWriteList(serializer, attr);
if (attr == null)
{
Type valueType;
if (type.IsArray)
{
Array arr = receiver as Array;
if (arr.Length == 0)
{
return;
}
var enumerator = arr.GetEnumerator();
enumerator.MoveNext();
valueType = enumerator.Current.GetType();
}
else
{
valueType = ObjectUtil.GetListValueType(type, "", null);
}
attr = GetElementAttribute(receiver, valueType);
}
serializer.WriteList(writer, receiver.Convert <IEnumerable>(), attr,
modelName, settings, root, serializerData);
}
else
{
options.CheckWriteObject(serializer);
ITkTypeConverter converter = TkTypeDescriptor.GetSimpleConverter(type);
if (converter != null)
{
SimpleElementAttribute simpleAttr = new SimpleElementAttribute
{
LocalName = root.LocalName,
NamespaceUri = root.Namespace
};
var info = new SimpleObjectPropertyInfo(receiver, type, simpleAttr, converter);
serializer.WriteElement(simpleAttr, writer, receiver, settings, info, serializerData);
}
else
{
serializer.WriteObject(writer, receiver, modelName, settings, root, serializerData);
}
}
}
public void WriteDictionary(object writer, IDictionary receiver, BaseDictionaryAttribute attribute,
string modelName, WriteSettings settings, QName root, object serializerData)
{
throw new NotSupportedException();
}
public static XDocument CreateXDocument(this object receiver, string modelName,
WriteSettings settings, QName root)
{
return(receiver.CreateObject("XElement", modelName, settings, root).Convert <XElementData>().Root);
}
public void Write(object writer, object receiver, string modelName, WriteSettings settings,
QName root, object serializerData, BaseObjectAttribute attribute)
{
SerializerUtil.WriteObject(this, writer, receiver, modelName, settings,
root, attribute, null, Options);
}
public void WriteList(object writer, IEnumerable receiver, SimpleElementAttribute attribute,
string modelName, WriteSettings settings, QName root, object serializerData)
{
throw new NotSupportedException();
}
public void ReadList(object reader, IList receiver, SimpleElementAttribute attribute,
string modelName, ReadSettings settings, QName root, object serializerData)
{
throw new NotSupportedException();
}
public void ReadObject(object reader, object receiver, string modelName,
ReadSettings settings, QName root, object serializerData)
{
throw new NotSupportedException();
}
public void WriteObject(object writer, object receiver, string modelName,
WriteSettings settings, QName root, object serializerData)
{
SerializerUtil.Write(this, writer, receiver, modelName, settings);
}
public void Read(object reader, object receiver, string modelName, ReadSettings settings,
QName root, BaseObjectAttribute attribute)
{
SerializerUtil.ReadObject(this, reader, receiver, modelName, settings,
root, attribute, null, SerializerOptions.XmlOptions);
}
public object BeginWrite(object writer, object receiver, WriteSettings settings, QName root)
{
return(null);
}
public bool ReadToRoot(object reader, QName root)
{
XmlReader xmlreader = reader.Convert <XmlReader>();
return(xmlreader.ReadToFollowing(root.LocalName, root.Namespace));
}
public static void ReadXmlFromFile(this object receiver, string fileName,
ReadSettings settings, QName root)
{
ReadXmlFromFile(receiver, null, fileName, settings, root);
}
