mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-18 12:31:30 -10:00
* XmlSeriailizer: Serialize method can serialize XmlSchema perfectly. * XmlSerializerNamespaces: Reverted to use of a single Hashtable. svn path=/trunk/mcs/; revision=5589
886 lines
25 KiB
C#
886 lines
25 KiB
C#
//
|
|
// XmlSerializer.cs:
|
|
//
|
|
// Author:
|
|
// John Donagher ([email protected])
|
|
// Ajay kumar Dwivedi ([email protected])
|
|
// (C) 2002 John Donagher, Ajay kumar Dwivedi
|
|
//
|
|
|
|
using System.Xml.Serialization;
|
|
using System.Xml;
|
|
using System.IO;
|
|
using System;
|
|
using System.Collections;
|
|
using System.Reflection;
|
|
|
|
namespace System.Xml.Serialization
|
|
{
|
|
/// <summary>
|
|
/// Summary description for XmlSerializer.
|
|
/// </summary>
|
|
public class XmlSerializer
|
|
{
|
|
private Type type;
|
|
private XmlAttributeOverrides overrides;
|
|
private Type[] extraTypes;
|
|
private XmlRootAttribute rootAttribute;
|
|
private string defaultNamespace;
|
|
private static Hashtable typeTable;
|
|
private bool useOrder;
|
|
|
|
private bool isNullable;
|
|
|
|
public bool UseOrder
|
|
{
|
|
get{ return useOrder; }
|
|
set{ useOrder = value; }
|
|
}
|
|
|
|
#region constructors
|
|
protected XmlSerializer ()
|
|
{
|
|
}
|
|
|
|
public XmlSerializer (Type type)
|
|
: this(type, null, null, null, null)
|
|
{}
|
|
|
|
[MonoTODO]
|
|
public XmlSerializer (XmlTypeMapping xmltypemapping)
|
|
{}
|
|
|
|
public XmlSerializer (Type type, string defaultNamespace)
|
|
: this(type, null, null, null, defaultNamespace)
|
|
{}
|
|
|
|
public XmlSerializer (Type type, Type[] extraTypes)
|
|
: this(type, null, extraTypes, null, null)
|
|
{}
|
|
|
|
public XmlSerializer (Type type, XmlAttributeOverrides overrides)
|
|
: this(type, overrides, null, null, null)
|
|
{}
|
|
|
|
public XmlSerializer (Type type, XmlRootAttribute root)
|
|
: this(type, null, null, root, null)
|
|
{}
|
|
|
|
internal XmlSerializer(Hashtable typeTable)
|
|
{
|
|
typeTable = typeTable;
|
|
}
|
|
|
|
public XmlSerializer (Type type, XmlAttributeOverrides overrides, Type[] extraTypes, XmlRootAttribute root, string defaultNamespace)
|
|
{
|
|
if(type == null)
|
|
throw new ArgumentNullException("type", "XmlSerializer can't be consturcted with a null type");
|
|
this.type = type;
|
|
|
|
this.overrides = overrides;
|
|
|
|
this.extraTypes = (extraTypes == null ? new Type[0] : extraTypes);
|
|
|
|
this.rootAttribute = root;
|
|
|
|
this.defaultNamespace = defaultNamespace;
|
|
|
|
if(typeTable == null)
|
|
typeTable = new Hashtable();
|
|
|
|
FillTypeTable(type);
|
|
}
|
|
#endregion
|
|
#region Events
|
|
[MonoTODO]
|
|
public event XmlAttributeEventHandler UnknownAttribute;
|
|
[MonoTODO]
|
|
public event XmlElementEventHandler UnknownElement;
|
|
[MonoTODO]
|
|
public event XmlNodeEventHandler UnknownNode;
|
|
[MonoTODO]
|
|
public event UnreferencedObjectEventHandler UnreferencedObject;
|
|
#endregion
|
|
#region Deserialize
|
|
[MonoTODO]
|
|
public virtual bool CanDeserialize (XmlReader xmlReader)
|
|
{
|
|
throw new NotImplementedException ();
|
|
}
|
|
[MonoTODO]
|
|
public object Deserialize (Stream stream)
|
|
{
|
|
throw new NotImplementedException ();
|
|
}
|
|
[MonoTODO]
|
|
public object Deserialize (TextReader textReader)
|
|
{
|
|
throw new NotImplementedException ();
|
|
}
|
|
[MonoTODO]
|
|
public object Deserialize (XmlReader xmlReader)
|
|
{
|
|
throw new NotImplementedException ();
|
|
}
|
|
#endregion
|
|
#region Serialize Delegates
|
|
public void Serialize (Stream stream, object o)
|
|
{
|
|
XmlTextWriter xmlWriter = new XmlTextWriter(stream, System.Text.Encoding.Default);
|
|
xmlWriter.Formatting = Formatting.Indented;
|
|
Serialize(xmlWriter, o, null);
|
|
}
|
|
|
|
public void Serialize (TextWriter textWriter, object o)
|
|
{
|
|
XmlTextWriter xmlWriter = new XmlTextWriter(textWriter);
|
|
xmlWriter.Formatting = Formatting.Indented;
|
|
Serialize(xmlWriter, o, null);
|
|
}
|
|
|
|
public void Serialize (XmlWriter xmlWriter, object o)
|
|
{
|
|
Serialize(xmlWriter, o);
|
|
}
|
|
|
|
public void Serialize (Stream stream, object o, XmlSerializerNamespaces namespaces)
|
|
{
|
|
XmlTextWriter xmlWriter = new XmlTextWriter(stream, System.Text.Encoding.Default);
|
|
xmlWriter.Formatting = Formatting.Indented;
|
|
Serialize(xmlWriter, o, namespaces);
|
|
}
|
|
|
|
public void Serialize (TextWriter textWriter, object o, XmlSerializerNamespaces namespaces)
|
|
{
|
|
XmlTextWriter xmlWriter = new XmlTextWriter(textWriter);
|
|
xmlWriter.Formatting = Formatting.Indented;
|
|
Serialize(xmlWriter, o, namespaces);
|
|
}
|
|
#endregion
|
|
|
|
public void Serialize (XmlWriter writer, object o, XmlSerializerNamespaces namespaces)
|
|
{
|
|
if(namespaces == null)
|
|
{
|
|
namespaces = new XmlSerializerNamespaces();
|
|
}
|
|
if(namespaces.Count == 0)
|
|
{
|
|
namespaces.Add("xsd", System.Xml.Schema.XmlSchema.Namespace);
|
|
namespaces.Add("xsi", System.Xml.Schema.XmlSchema.InstanceNamespace);
|
|
}
|
|
|
|
Type objType = o.GetType();
|
|
string rootName = objType.Name;
|
|
string rootNs = null;
|
|
XmlSerializerNamespaces nss = new XmlSerializerNamespaces();
|
|
XmlQualifiedName[] qnames;
|
|
|
|
writer.WriteStartDocument();
|
|
|
|
object[] memberObj = (object[])typeTable[objType];
|
|
if(memberObj == null)
|
|
throw new Exception("Unknown Type "+objType+" encounterd during Serialization");
|
|
Hashtable memberTable = (Hashtable)memberObj[0];
|
|
|
|
XmlAttributes attrs = (XmlAttributes)memberTable[""];
|
|
//If we have been passed an XmlRoot, set it on the base class
|
|
if(rootAttribute != null)
|
|
attrs.XmlRoot = rootAttribute;
|
|
|
|
if(attrs.XmlRoot != null)
|
|
{
|
|
isNullable = attrs.XmlRoot.IsNullable;
|
|
if(attrs.XmlRoot.ElementName != null)
|
|
rootName = attrs.XmlRoot.ElementName;
|
|
rootNs = attrs.XmlRoot.Namespace;
|
|
}
|
|
|
|
//XMLNS attributes in the Root
|
|
XmlAttributes XnsAttrs = (XmlAttributes)((object[])typeTable[objType])[1];
|
|
if(XnsAttrs != null)
|
|
{
|
|
MemberInfo member = XnsAttrs.MemberInfo;
|
|
FieldInfo fInfo = member as FieldInfo;
|
|
PropertyInfo propInfo = member as PropertyInfo;
|
|
XmlSerializerNamespaces xns;
|
|
if(fInfo != null)
|
|
xns = (XmlSerializerNamespaces) fInfo.GetValue(o);
|
|
else
|
|
xns = (XmlSerializerNamespaces) propInfo.GetValue(o,null);
|
|
|
|
qnames = xns.ToArray();
|
|
foreach(XmlQualifiedName qname in qnames)
|
|
{
|
|
nss.Add(qname.Name, qname.Namespace);
|
|
}
|
|
}
|
|
//XmlNs from the namespaces passed
|
|
qnames = namespaces.ToArray();
|
|
foreach(XmlQualifiedName qname in qnames)
|
|
{
|
|
if(writer.LookupPrefix(qname.Namespace) != qname.Name)
|
|
{
|
|
nss.Add(qname.Name, qname.Namespace);
|
|
}
|
|
}
|
|
|
|
if(namespaces.GetPrefix(rootNs) != null)
|
|
writer.WriteStartElement(namespaces.GetPrefix(rootNs),rootName, rootNs);
|
|
|
|
qnames = nss.ToArray();
|
|
foreach(XmlQualifiedName qname in qnames)
|
|
{
|
|
if(writer.LookupPrefix(qname.Namespace) != qname.Name)
|
|
{
|
|
writer.WriteAttributeString("xmlns", qname.Name, null, qname.Namespace);
|
|
}
|
|
}
|
|
|
|
SerializeMembers(writer, o, true);//, namespaces);
|
|
writer.WriteEndElement();
|
|
}
|
|
|
|
private void SerializeMembers ( XmlWriter writer, object o, bool isRoot)
|
|
{
|
|
Type objType = o.GetType();
|
|
XmlAttributes XnsAttrs = (XmlAttributes)((object[])typeTable[objType])[1];
|
|
ArrayList attrList = (ArrayList)((object[])typeTable[objType])[2];
|
|
ArrayList elemList = (ArrayList)((object[])typeTable[objType])[3];
|
|
|
|
if(!isRoot && XnsAttrs != null)
|
|
{
|
|
MemberInfo member = XnsAttrs.MemberInfo;
|
|
FieldInfo fInfo = member as FieldInfo;
|
|
PropertyInfo propInfo = member as PropertyInfo;
|
|
XmlSerializerNamespaces xns;
|
|
if(fInfo != null)
|
|
xns = (XmlSerializerNamespaces) fInfo.GetValue(o);
|
|
else
|
|
xns = (XmlSerializerNamespaces) propInfo.GetValue(o,null);
|
|
|
|
XmlQualifiedName[] qnames = xns.ToArray();
|
|
foreach(XmlQualifiedName qname in qnames)
|
|
{
|
|
if(writer.LookupPrefix(qname.Namespace) != qname.Name)
|
|
writer.WriteAttributeString("xmlns", qname.Name, null, qname.Namespace);
|
|
}
|
|
}
|
|
|
|
//Serialize the Attributes.
|
|
foreach(XmlAttributes attrs in attrList)
|
|
{
|
|
MemberInfo member = attrs.MemberInfo;
|
|
FieldInfo fInfo = member as FieldInfo;
|
|
PropertyInfo propInfo = member as PropertyInfo;
|
|
Type attributeType;
|
|
object attributeValue;
|
|
string attributeValString;
|
|
string attributeName;
|
|
string attributeNs;
|
|
|
|
if(fInfo != null)
|
|
{
|
|
attributeType = fInfo.FieldType;
|
|
attributeValue = fInfo.GetValue(o);
|
|
}
|
|
else if(propInfo != null)
|
|
{
|
|
attributeType = propInfo.PropertyType;
|
|
attributeValue = propInfo.GetValue(o,null);
|
|
}
|
|
else
|
|
throw new Exception("Should never Happen. Neither field or property");
|
|
|
|
attributeName = attrs.GetAttributeName(attributeType, member.Name);
|
|
attributeNs = attrs.GetAttributeNamespace(attributeType);
|
|
|
|
if(attributeValue is XmlQualifiedName)
|
|
{
|
|
XmlQualifiedName qname = (XmlQualifiedName) attributeValue;
|
|
if(qname.IsEmpty)
|
|
continue;
|
|
writer.WriteStartAttribute(attributeName, attributeNs);
|
|
writer.WriteQualifiedName(qname.Name, qname.Namespace);
|
|
writer.WriteEndAttribute();
|
|
continue;
|
|
}
|
|
|
|
else if(attributeValue is XmlQualifiedName[])
|
|
{
|
|
XmlQualifiedName[] qnames = (XmlQualifiedName[]) attributeValue;
|
|
writer.WriteStartAttribute(attributeName, attributeNs);
|
|
int count = 0;
|
|
foreach(XmlQualifiedName qname in qnames)
|
|
{
|
|
if(qname.IsEmpty)
|
|
continue;
|
|
if(count++ > 0)
|
|
writer.WriteWhitespace(" ");
|
|
writer.WriteQualifiedName(qname.Name, qname.Namespace);
|
|
}
|
|
writer.WriteEndAttribute();
|
|
continue;
|
|
}
|
|
else if(attributeValue is XmlAttribute[])
|
|
{
|
|
XmlAttribute[] xmlattrs = (XmlAttribute[]) attributeValue;
|
|
foreach(XmlAttribute xmlattr in xmlattrs)
|
|
xmlattr.WriteTo(writer);
|
|
continue;
|
|
}
|
|
attributeValString = GetXmlValue(attributeValue);
|
|
|
|
if(attributeValString != GetXmlValue(attrs.XmlDefaultValue))
|
|
{
|
|
writer.WriteAttributeString(attributeName, attributeNs, attributeValString);
|
|
}
|
|
}
|
|
|
|
//Serialize Elements
|
|
foreach(XmlAttributes attrs in elemList)
|
|
{
|
|
MemberInfo member = attrs.MemberInfo;
|
|
FieldInfo fInfo = member as FieldInfo;
|
|
PropertyInfo propInfo = member as PropertyInfo;
|
|
Type elementType;
|
|
object elementValue;
|
|
string elementName;
|
|
string elementNs;
|
|
|
|
if(fInfo != null)
|
|
{
|
|
elementType = fInfo.FieldType;
|
|
elementValue = fInfo.GetValue(o);
|
|
}
|
|
else if(propInfo != null)
|
|
{
|
|
elementType = propInfo.PropertyType;
|
|
elementValue = propInfo.GetValue(o,null);
|
|
}
|
|
else throw new Exception("should never happpen. Element is neither field nor property");
|
|
|
|
elementName = attrs.GetElementName(elementType, member.Name);
|
|
elementNs = attrs.GetElementNamespace(elementType);
|
|
|
|
WriteElement(writer, attrs, elementName, elementNs, elementType, elementValue);
|
|
}
|
|
}
|
|
|
|
private void WriteElement(XmlWriter writer, XmlAttributes attrs,
|
|
string name, string ns, Type type, Object value)
|
|
{
|
|
if(IsInbuiltType(type))
|
|
{
|
|
writer.WriteElementString(name, ns, "" + GetXmlValue(value));
|
|
}
|
|
else if(attrs.XmlText != null && value != null)
|
|
{
|
|
if(type == typeof(object[]))
|
|
{
|
|
}
|
|
else if(type == typeof(string[]))
|
|
{
|
|
}
|
|
else if(type == typeof(XmlNode))
|
|
{
|
|
((XmlNode)value).WriteTo(writer);
|
|
}
|
|
else if(type == typeof(XmlNode[]))
|
|
{
|
|
XmlNode[] nodes = (XmlNode[])value;
|
|
foreach(XmlNode node in nodes)
|
|
node.WriteTo(writer);
|
|
}
|
|
}
|
|
else if(type.IsArray && value != null)
|
|
{
|
|
writer.WriteStartElement(name, ns);
|
|
SerializeArray(writer, value);
|
|
writer.WriteEndElement();
|
|
}
|
|
else if(value is ICollection)
|
|
{
|
|
BindingFlags flags = BindingFlags.Public | BindingFlags.Instance;
|
|
//Find a non indexer Count Property with return type of int
|
|
PropertyInfo countProp = type.GetProperty("Count", flags, null, typeof(int),new Type[0], null);
|
|
PropertyInfo itemProp = type.GetProperty("Item", flags, null, null, new Type[1]{typeof(int)}, null);
|
|
int count = (int)countProp.GetValue(value,null);
|
|
object[] items = new object[1];
|
|
|
|
if(count > 0)
|
|
{
|
|
for(int i=0;i<count;i++)
|
|
{
|
|
items[0] = i;
|
|
object itemval = itemProp.GetValue(value, items);
|
|
string itemName;
|
|
string itemNs;
|
|
if(itemval != null)
|
|
{
|
|
itemName = attrs.GetElementName(itemval.GetType(), name);
|
|
itemNs = attrs.GetElementNamespace(itemval.GetType());
|
|
writer.WriteStartElement(itemName, itemNs);
|
|
SerializeMembers(writer, itemval, false);
|
|
writer.WriteEndElement();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if(value is IEnumerable)
|
|
{
|
|
|
|
}
|
|
else if(type.IsEnum)
|
|
{
|
|
|
|
}
|
|
else if(value != null) //Complex Type?
|
|
{
|
|
string itemName = attrs.GetElementName(value.GetType(), name);
|
|
string itemNs = attrs.GetElementNamespace(value.GetType());
|
|
writer.WriteStartElement(itemName, itemNs);
|
|
SerializeMembers(writer, value, false);
|
|
writer.WriteEndElement();
|
|
}
|
|
else
|
|
{
|
|
}
|
|
}
|
|
|
|
private void SerializeArray( XmlWriter writer, object o)
|
|
{
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// If the type is a string, valuetype or primitive type we do not populate the TypeTable.
|
|
/// If the type is an array, we populate the TypeTable with Element type of the array.
|
|
/// If the type implements ICollection, it is handled differently. We do not care for its members.
|
|
/// If the type implements IEnumberable, we check that it implements Add(). Don't care for members.
|
|
/// </summary>
|
|
private void FillTypeTable(Type type)
|
|
{
|
|
if(typeTable.Contains(type))
|
|
return;
|
|
|
|
//For value types and strings we don't need the members.
|
|
//FIXME: We will need the enum types probably.
|
|
if(IsInbuiltType(type))
|
|
return;
|
|
|
|
//Array, ICollection and IEnumberable are treated differenty
|
|
if(type.IsArray)
|
|
{
|
|
FillArrayType(type);
|
|
return;
|
|
}
|
|
else if(type.IsEnum)
|
|
{
|
|
FillEnum(type);
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
//There must be a public constructor
|
|
if(!HasDefaultConstructor(type))
|
|
{
|
|
throw new Exception("Can't Serialize Type " + type.Name + " since it does not have default Constructor");
|
|
}
|
|
|
|
if(type.GetInterface("ICollection") == typeof(System.Collections.ICollection))
|
|
{
|
|
FillICollectionType(type);
|
|
return;
|
|
}
|
|
|
|
if(type.GetInterface("IEnumerable") == typeof(System.Collections.IEnumerable))
|
|
{
|
|
FillIEnumerableType(type);
|
|
return;
|
|
}
|
|
}
|
|
|
|
//Add the Class to the hashtable.
|
|
//Each value of the hashtable has two objects, one is the hashtable with key of membername (for deserialization)
|
|
//Other is an Array of XmlSerializernames, Array of XmlAttributes & Array of XmlElements.
|
|
Object[] memberObj = new Object[4];
|
|
typeTable.Add(type,memberObj);
|
|
|
|
Hashtable memberTable = new Hashtable();
|
|
memberObj[0] = memberTable;
|
|
memberTable.Add("", XmlAttributes.FromClass(type));
|
|
|
|
memberObj[1] = null;
|
|
|
|
ArrayList attrList = new ArrayList();
|
|
memberObj[2] = attrList;
|
|
|
|
ArrayList elemList = new ArrayList();
|
|
memberObj[3] = elemList;
|
|
|
|
//Get the graph of the members. Graph is nothing but the order
|
|
//in which MS implementation serializes the members.
|
|
MemberInfo[] minfo = GetGraph(type);
|
|
|
|
foreach(MemberInfo member in minfo)
|
|
{
|
|
FieldInfo fInfo = (member as FieldInfo);
|
|
PropertyInfo propInfo = (member as PropertyInfo);
|
|
|
|
if(fInfo != null)
|
|
{
|
|
//If field is readOnly or const, do not serialize it.
|
|
if(fInfo.IsLiteral || fInfo.IsInitOnly)
|
|
continue;
|
|
|
|
XmlAttributes attrs = XmlAttributes.FromField(member,fInfo);
|
|
|
|
//If XmlAttributes have XmlIgnore, ignore this member
|
|
if(attrs.XmlIgnore)
|
|
continue;
|
|
//If this member is a XmlNs type, set the XmlNs object.
|
|
if(attrs.Xmlns)
|
|
{
|
|
memberObj[1] = attrs;
|
|
continue;
|
|
}
|
|
//If the member is a attribute Type, Add to attribute list
|
|
if(attrs.isAttribute)
|
|
attrList.Add(attrs);
|
|
else //Add to elements
|
|
{
|
|
elemList.Add(attrs);
|
|
}
|
|
//Add in the Hashtable.
|
|
memberTable.Add(member.Name, attrs);
|
|
|
|
Type fieldType = fInfo.FieldType;
|
|
|
|
if(attrs.XmlAnyAttribute != null || attrs.XmlText != null)
|
|
continue;
|
|
|
|
if(attrs.XmlElements.Count > 0)
|
|
{
|
|
foreach(XmlElementAttribute elem in attrs.XmlElements)
|
|
{
|
|
if(elem.Type != null)
|
|
FillTypeTable(elem.Type);
|
|
else
|
|
FillTypeTable(fieldType);
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if(!IsInbuiltType(fieldType))
|
|
FillTypeTable(fieldType);
|
|
}
|
|
else if(propInfo != null)
|
|
{
|
|
//If property is readonly or writeonly, do not serialize it.
|
|
//Exceptions are properties whose return type is array, ICollection or IEnumerable
|
|
//Indexers are not serialized unless the class Implements ICollection.
|
|
if(!(propInfo.PropertyType.IsArray || Implements(propInfo.PropertyType,typeof(ICollection)) ||
|
|
(propInfo.PropertyType != typeof(string) && Implements(propInfo.PropertyType,typeof(IEnumerable)))))
|
|
{
|
|
if(!(propInfo.CanRead && propInfo.CanWrite) || propInfo.GetIndexParameters().Length != 0)
|
|
continue;
|
|
}
|
|
XmlAttributes attrs = XmlAttributes.FromProperty(member,propInfo);
|
|
//If XmlAttributes have XmlIgnore, ignore this member
|
|
if(attrs.XmlIgnore)
|
|
continue;
|
|
|
|
//If this member is a XmlNs type, set the XmlNs object.
|
|
if(attrs.Xmlns)
|
|
{
|
|
memberObj[1] = attrs;
|
|
continue;
|
|
}
|
|
//If the member is a attribute Type, Add to attribute list
|
|
if(attrs.isAttribute)
|
|
attrList.Add(attrs);
|
|
else //Add to elements
|
|
{
|
|
elemList.Add(attrs);
|
|
}
|
|
|
|
//OtherWise add in the Hashtable.
|
|
memberTable.Add(member.Name, attrs);
|
|
|
|
Type propType = propInfo.PropertyType;
|
|
|
|
if(attrs.XmlAnyAttribute != null || attrs.XmlText != null)
|
|
continue;
|
|
|
|
if(attrs.XmlElements.Count > 0)
|
|
{
|
|
foreach(XmlElementAttribute elem in attrs.XmlElements)
|
|
{
|
|
if(elem.Type != null)
|
|
FillTypeTable(elem.Type);
|
|
else
|
|
FillTypeTable(propType);
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if(!IsInbuiltType(propType))
|
|
FillTypeTable(propType);
|
|
}
|
|
}
|
|
//Sort the attributes for the members according to their Order
|
|
//This is an extension to MS's Implementation and will be useful
|
|
//if our reflection does not return the same order of elements
|
|
//as MS .NET impl
|
|
if(useOrder)
|
|
BubbleSort(elemList,XmlAttributes.attrComparer);
|
|
}
|
|
|
|
private void FillArrayType(Type type)
|
|
{
|
|
if(!type.IsArray)
|
|
throw new Exception("Should never happen. Type is not an array");
|
|
|
|
if(type.GetArrayRank() != 1)
|
|
throw new Exception("MultiDimensional Arrays are not Supported");
|
|
|
|
Type arrayType = type.GetElementType();
|
|
|
|
if(arrayType.IsArray)
|
|
{
|
|
FillArrayType(arrayType);
|
|
}
|
|
else if(!IsInbuiltType(arrayType))
|
|
{
|
|
FillTypeTable(arrayType);
|
|
}
|
|
}
|
|
|
|
private void FillICollectionType(Type type)
|
|
{
|
|
//Must have an public Indexer that takes an integer and
|
|
//a public Count Property which returns an int.
|
|
|
|
BindingFlags flags = BindingFlags.Public | BindingFlags.Instance;
|
|
|
|
//Find a non indexer Count Property with return type of int
|
|
PropertyInfo countProp = type.GetProperty("Count", flags, null, typeof(int),new Type[0], null);
|
|
if(countProp == null || !countProp.CanRead)
|
|
throw new Exception("Cannot Serialize "+type+" because it implements ICollectoion, but does not implement public Count property");
|
|
//Find a indexer Item Property which takes an int
|
|
PropertyInfo itemProp = type.GetProperty("Item", flags, null, null, new Type[1]{typeof(int)}, null);
|
|
if(itemProp == null || !itemProp.CanRead || !itemProp.CanWrite)
|
|
throw new Exception("Cannot Serialize "+type+" because it does not have a read/write indexer property that takes an int as argument");
|
|
}
|
|
|
|
private void FillIEnumerableType(Type type)
|
|
{
|
|
//Must implement a public Add method that takes a single parameter.
|
|
//The Add method's parameter must be of the same type as is returned from
|
|
// the Current property on the value returned from GetEnumerator, or one of that type's bases.
|
|
BindingFlags flags = BindingFlags.Public | BindingFlags.Instance;
|
|
MethodInfo enumMethod = type.GetMethod("GetEnumerator", flags, null, new Type[0], null);
|
|
if(enumMethod == null)
|
|
throw new Exception("Cannot serialize "+type+" because it does not implement GetEnumerator");
|
|
|
|
Type returnType = enumMethod.ReturnType;
|
|
|
|
while(returnType != null)
|
|
{
|
|
MethodInfo addMethod = type.GetMethod("Add", flags, null, new Type[1]{returnType},null);
|
|
if(addMethod != null)
|
|
return;
|
|
returnType = returnType.BaseType;
|
|
}
|
|
|
|
throw new Exception("Cannot serialize "+type+" because it does not have a Add method which takes "
|
|
+enumMethod.ReturnType+" or one of its base types.");
|
|
}
|
|
|
|
private void FillEnum(Type type)
|
|
{
|
|
Hashtable memberTable = new Hashtable();
|
|
BindingFlags flags = BindingFlags.Public | BindingFlags.Instance;
|
|
typeTable.Add(type,memberTable);
|
|
string[] names = Enum.GetNames(type);
|
|
foreach(string name in names)
|
|
{
|
|
MemberInfo[] members = type.GetMember(name);
|
|
if(members.Length != 1)
|
|
throw new Exception("Should never happen. Enum member not present or more than one. "+name);
|
|
XmlAttributes attrs = new XmlAttributes(members[0]);
|
|
if(attrs.XmlIgnore)
|
|
continue;
|
|
if(attrs.XmlEnum != null)
|
|
{
|
|
memberTable.Add(members[0].Name, attrs.XmlEnum.Name);
|
|
}
|
|
else
|
|
{
|
|
memberTable.Add(members[0].Name, members[0].Name);
|
|
}
|
|
}
|
|
}
|
|
|
|
private bool HasDefaultConstructor(Type type)
|
|
{
|
|
ConstructorInfo defaultConstructor = type.GetConstructor(new Type[0]);
|
|
if(defaultConstructor == null || defaultConstructor.IsAbstract || defaultConstructor.IsStatic
|
|
|| !defaultConstructor.IsPublic)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
private bool IsInbuiltType(Type type)
|
|
{
|
|
if(type.IsEnum)
|
|
return false;
|
|
if(type.IsValueType || type == typeof(string) || type.IsPrimitive)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
private static MemberInfo[] GetGraph(Type type)
|
|
{
|
|
ArrayList typeGraph = new ArrayList();
|
|
GetGraph(type, typeGraph);
|
|
return (MemberInfo[]) typeGraph.ToArray(typeof(MemberInfo));
|
|
}
|
|
|
|
private static void GetGraph(Type type, ArrayList typeGraph)
|
|
{
|
|
BindingFlags flags = BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly;
|
|
if(type.BaseType == null)
|
|
return;
|
|
GetGraph(type.BaseType,typeGraph);
|
|
|
|
typeGraph.AddRange(type.GetFields(flags));
|
|
typeGraph.AddRange(type.GetProperties(flags));
|
|
}
|
|
|
|
private string GetXmlValue(object value)
|
|
{
|
|
if(value == null)
|
|
return null;
|
|
if(value is Enum)
|
|
{
|
|
Type type = value.GetType();
|
|
|
|
if(typeTable.ContainsKey(type))
|
|
{
|
|
Hashtable memberTable = (Hashtable)(typeTable[type]);
|
|
if(type.IsDefined(typeof(FlagsAttribute),false))
|
|
{
|
|
//If value is exactly a single enum member
|
|
if(memberTable.Contains(value.ToString()))
|
|
return (string)memberTable[value.ToString()];
|
|
|
|
string retval = "";
|
|
int count=0;
|
|
int enumval = (int) value;
|
|
string[] names = Enum.GetNames(type);
|
|
foreach(string key in names)
|
|
{
|
|
if(!memberTable.ContainsKey(key))
|
|
continue;
|
|
//Otherwise multiple values.
|
|
int val = (int)Enum.Parse(type, key);
|
|
if(val != 0 && (enumval & val) == val)
|
|
{
|
|
retval += " " + (string)memberTable[Enum.GetName(type,val)];
|
|
}
|
|
}
|
|
retval = retval.Trim();
|
|
if(retval.Length == 0)
|
|
return null;
|
|
return retval;
|
|
}
|
|
else
|
|
{
|
|
if(memberTable.ContainsKey(value.ToString()))
|
|
return (string)memberTable[value.ToString()];
|
|
else
|
|
return null;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
throw new Exception("Unknown Enumeration");
|
|
}
|
|
}
|
|
if(value is bool)
|
|
{
|
|
return (bool)value ? "true" : "false";
|
|
}
|
|
if(value is XmlQualifiedName)
|
|
{
|
|
if(((XmlQualifiedName)value).IsEmpty)
|
|
return null;
|
|
}
|
|
return (value==null) ? null : value.ToString();
|
|
}
|
|
|
|
private static void ProcessAttributes(XmlAttributes attrs, Hashtable memberTable)
|
|
{
|
|
if(attrs.XmlAnyAttribute != null)
|
|
{
|
|
}
|
|
foreach(XmlAnyElementAttribute anyelem in attrs.XmlAnyElements)
|
|
{
|
|
memberTable.Add(new XmlQualifiedName(anyelem.Name, anyelem.Namespace), attrs);
|
|
}
|
|
if(attrs.XmlArray != null)
|
|
{
|
|
}
|
|
foreach(XmlArrayItemAttribute item in attrs.XmlArrayItems)
|
|
{
|
|
memberTable.Add(new XmlQualifiedName(item.ElementName, item.Namespace), attrs);
|
|
}
|
|
if(attrs.XmlAttribute != null)
|
|
{
|
|
memberTable.Add(new XmlQualifiedName(attrs.XmlAttribute.AttributeName,attrs.XmlAttribute.Namespace), attrs);
|
|
}
|
|
if(attrs.XmlChoiceIdentifier != null)
|
|
{
|
|
}
|
|
foreach(XmlElementAttribute elem in attrs.XmlElements)
|
|
{
|
|
memberTable.Add(new XmlQualifiedName(elem.ElementName, elem.Namespace), attrs);
|
|
}
|
|
if(attrs.XmlEnum != null)
|
|
{
|
|
}
|
|
if(attrs.XmlType != null)
|
|
{
|
|
memberTable.Add(new XmlQualifiedName(attrs.XmlType.TypeName, attrs.XmlType.Namespace), attrs);
|
|
}
|
|
}
|
|
|
|
private bool Implements(Type type, Type interfaceType)
|
|
{
|
|
if(type.GetInterface(interfaceType.FullName) == interfaceType)
|
|
return true;
|
|
return false;
|
|
}
|
|
private static void BubbleSort(ArrayList array, IComparer comparer)
|
|
{
|
|
int len = array.Count;
|
|
object obj1, obj2;
|
|
for (int i=0; i < len; i++)
|
|
{
|
|
for (int j=0; j < len -i -1; j++)
|
|
{
|
|
obj1 = array[j];
|
|
obj2 = array[j+1];
|
|
if (comparer.Compare( obj2 , obj1 ) < 0)
|
|
{
|
|
array[j] = obj2;
|
|
array[j+1] = obj1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} |