protected virtual void FillObject(ref object data, SerializableData serializableData)
{
foreach (SerializableData current in serializableData.SerializableDataCollection)
{
this.FillObjectField(data, data.GetType(), current);
}
}
protected virtual bool FillCollection(object data, SerializableData serializableData)
{
bool result;
if (!base.IsCollection(data))
{
result = false;
}
else
{
ICollection collection = data as ICollection;
foreach (object current in collection)
{
SerializableData serializableData2 = new SerializableData();
XmlClassSerializable xmlClassSerializableAttribute = base.GetXmlClassSerializableAttribute(current.GetType());
if (!this.FindXmlSerializableClassAttribute(current, serializableData2))
{
Type type = current.GetType();
Collection <DataMember> collection2 = new Collection <DataMember>();
this.FillDataMembers(type, collection2, false, this.IsDeepSerializable(type), this.GetFlags(type, xmlClassSerializableAttribute));
if (collection2.Count == 0)
{
continue;
}
this.CreateSerializableData(current, serializableData2);
this.FindClassFields(current, serializableData2, collection2);
}
serializableData.SerializableDataCollection.Add(serializableData2);
}
result = true;
}
return(result);
}
protected virtual object CreateArray(SerializableData serializableData)
{
object obj = null;
try
{
Type type = base.GetType(serializableData.SerializableDataCollection[0]);
Array array = Array.CreateInstance(type, serializableData.SerializableDataCollection.Count);
for (int i = 0; i < serializableData.SerializableDataCollection.Count; i++)
{
object value;
if (!this.IsBaseType(type))
{
value = this.Compose(serializableData.SerializableDataCollection[i]);
}
else
{
value = this.ConvertType(serializableData.SerializableDataCollection[i]);
}
array.SetValue(value, i);
}
obj = array;
this.FillObject(ref obj, serializableData);
}
catch
{
throw new XmlSerializationException(obj, serializableData);
}
return(obj);
}
public virtual object Compose(SerializableData serializableData)
{
object result = this.CreateObject(serializableData);
this.FillObject(ref result, serializableData);
return(result);
}
protected virtual bool IsCreateableSerializableData(SerializableData serializableData)
{
Type type = base.GetType(serializableData);
TypeCode typeCode = Type.GetTypeCode(type);
ConstructorInfo[] constructors = type.GetConstructors();
bool result;
if (constructors.Length == 0 && !type.IsValueType)
{
result = false;
}
else
{
ConstructorInfo[] array = constructors;
for (int i = 0; i < array.Length; i++)
{
ConstructorInfo constructorInfo = array[i];
if (constructorInfo.GetParameters().Length == 0)
{
result = true;
return(result);
}
}
result = (typeCode == TypeCode.Object);
}
return(result);
}
protected virtual void FindClassFields(object data, SerializableData serializableData, Collection <DataMember> dataMembers)
{
Type type = data.GetType();
int i = 0;
while (i < dataMembers.Count)
{
SerializableData serializableData2 = new SerializableData();
if (base.GetXmlClassSerializableAttribute(dataMembers[i].TypeInfo) != null)
{
object data2 = type.InvokeMember(dataMembers[i].DataInfo.Name, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.GetField | BindingFlags.GetProperty, null, data, null);
serializableData2.FieldName = dataMembers[i].DataInfo.Name;
if (this.FindXmlSerializableClassAttribute(data2, serializableData2))
{
goto IL_9D;
}
}
else
{
serializableData2 = this.CreateSerializableData(data, dataMembers[i]);
if (serializableData2 != null)
{
goto IL_9D;
}
}
IL_AB:
i++;
continue;
IL_9D:
serializableData.SerializableDataCollection.Add(serializableData2);
goto IL_AB;
}
this.FillCollection(data, serializableData);
}
public XmlSerializationException(object data, SerializableData serializableData, PropertyInfo propertyInfo, FieldInfo fieldInfo)
{
this._data = data;
this._serializableData = serializableData;
this._propertyInfo = propertyInfo;
this._fieldInfo = fieldInfo;
}
protected virtual void FillObjectField(object data, Type type, SerializableData serializableData)
{
object newObject = this.GetNewObject(serializableData);
this.Filler(data, type, new object[]
{
newObject
}, serializableData);
}
public object ReadXml(string fileName, SerializableData serializableData)
{
this._xmlDocument.Load(fileName);
try
{
this.ReadXml(this._xmlDocument.ChildNodes[1], serializableData);
}
catch
{
throw new XmlSerializationException(this._xmlDocument, serializableData);
}
return(serializableData);
}
protected virtual object CreateCollection(SerializableData serializableData)
{
object obj = this.CreateObject(serializableData);
Type type = obj.GetType();
foreach (SerializableData current in serializableData.SerializableDataCollection)
{
object obj2 = this.Compose(current);
this.Filler(obj, obj.GetType(), new object[]
{
obj2
}, current);
}
return(obj);
}
protected virtual void CreateSerializableData(object data, SerializableData serializableData)
{
Type type = data.GetType();
bool flag = true;
XmlClassSerializable xmlClassSerializableAttribute = base.GetXmlClassSerializableAttribute(type);
if (xmlClassSerializableAttribute == null || xmlClassSerializableAttribute.TagName == string.Empty)
{
flag = false;
}
serializableData.Type = type.FullName;
serializableData.Assembly = type.Assembly.ToString();
serializableData.AssemblyQualifiedName = type.AssemblyQualifiedName;
serializableData.Value = (flag ? string.Empty : data.ToString());
serializableData.TagName = (flag ? xmlClassSerializableAttribute.TagName : type.Name);
}
protected virtual object CreateObject(SerializableData serializableData)
{
Type type = base.GetType(serializableData);
if (type != null)
{
object obj = Activator.CreateInstance(type, null);
ObjectHandle objectHandle = obj as ObjectHandle;
if (objectHandle != null)
{
obj = objectHandle.Unwrap();
}
return(obj);
}
throw new XmlSerializationException(null, serializableData);
}
protected virtual object GetNewObject(SerializableData serializableData)
{
Type type = base.GetType(serializableData);
object result;
if (type.IsArray)
{
result = this.CreateArray(serializableData);
}
else if (base.IsCollection(type))
{
result = this.CreateCollection(serializableData);
}
else
{
result = this.GetObject(serializableData);
}
return(result);
}
protected virtual bool FindXmlSerializableClassAttribute(object data, SerializableData serializableData)
{
Type type = data.GetType();
XmlClassSerializable xmlClassSerializableAttribute = base.GetXmlClassSerializableAttribute(type);
bool result;
if (xmlClassSerializableAttribute == null)
{
result = false;
}
else
{
this.CreateSerializableData(data, serializableData);
Collection <DataMember> dataMembers = new Collection <DataMember>();
this.FillDataMembers(type, dataMembers, true, xmlClassSerializableAttribute.Deep, this.GetFlags(type, xmlClassSerializableAttribute));
this.FindClassFields(data, serializableData, dataMembers);
result = true;
}
return(result);
}
protected virtual SerializableData CreateSerializableData(object data, DataMember dataMember)
{
bool flag = true;
XmlFieldSerializable xmlFieldSerializableAttribute = base.GetXmlFieldSerializableAttribute(dataMember.DataInfo);
if (xmlFieldSerializableAttribute == null || xmlFieldSerializableAttribute.TagName == string.Empty)
{
flag = false;
}
SerializableData serializableData = new SerializableData();
BindingFlags flags = this.GetFlags(data.GetType());
PropertyInfo property = base.GetProperty(dataMember.DataInfo.ReflectedType, dataMember.DataInfo.Name, flags);
object obj;
SerializableData result;
if (property != null && property.CanRead)
{
obj = property.GetGetMethod(true).Invoke(data, null);
}
else
{
FieldInfo field = base.GetField(dataMember.DataInfo.ReflectedType, dataMember.DataInfo.Name, flags);
if (!(field != null))
{
result = null;
return(result);
}
obj = field.GetValue(data);
}
serializableData.Type = dataMember.TypeInfo.FullName;
serializableData.Assembly = dataMember.TypeInfo.Assembly.ToString();
serializableData.AssemblyQualifiedName = dataMember.TypeInfo.AssemblyQualifiedName;
serializableData.Value = ((obj != null) ? obj.ToString() : string.Empty);
serializableData.TagName = (flag ? xmlFieldSerializableAttribute.TagName : dataMember.TypeInfo.Name);
serializableData.FieldName = dataMember.DataInfo.Name;
this.FillCollection(obj, serializableData);
result = serializableData;
return(result);
}
protected virtual void ReadXml(XmlNode xmlNode, SerializableData serializableData)
{
XmlAttribute xmlAttribute = xmlNode.Attributes["name"];
XmlAttribute xmlAttribute2 = xmlNode.Attributes["type"];
XmlAttribute xmlAttribute3 = xmlNode.Attributes["assembly"];
XmlAttribute xmlAttribute4 = xmlNode.Attributes["assemblyQualifiedName"];
string name = xmlNode.Name;
XmlAttribute xmlAttribute5 = xmlNode.Attributes["value"];
serializableData.TagName = name;
serializableData.Type = xmlAttribute2.Value;
serializableData.Assembly = xmlAttribute3.Value;
serializableData.AssemblyQualifiedName = xmlAttribute4.Value;
serializableData.FieldName = xmlAttribute.Value;
serializableData.Value = xmlAttribute5.Value;
foreach (XmlNode xmlNode2 in xmlNode.ChildNodes)
{
SerializableData serializableData2 = new SerializableData();
serializableData.SerializableDataCollection.Add(serializableData2);
this.ReadXml(xmlNode2, serializableData2);
}
}
protected virtual void WriteXml(XmlNode xmlNode, SerializableData serializableData)
{
XmlElement xmlElement = null;
try
{
xmlElement = this._xmlDocument.CreateElement(this.GetFormattedText(serializableData.TagName));
}
catch
{
throw new XmlSerializationException(this._xmlDocument, serializableData);
}
xmlElement.Attributes.Append(this.CreateXmlAttribute("value", serializableData.Value));
xmlElement.Attributes.Append(this.CreateXmlAttribute("type", serializableData.Type));
xmlElement.Attributes.Append(this.CreateXmlAttribute("assembly", serializableData.Assembly));
xmlElement.Attributes.Append(this.CreateXmlAttribute("assemblyQualifiedName", serializableData.AssemblyQualifiedName));
xmlElement.Attributes.Append(this.CreateXmlAttribute("name", serializableData.FieldName));
xmlNode.AppendChild(xmlElement);
foreach (SerializableData current in serializableData.SerializableDataCollection)
{
this.WriteXml(xmlElement, current);
}
}
protected virtual object GetObject(SerializableData serializableData)
{
object obj = null;
Type type = base.GetType(serializableData);
TypeCode typeCode = Type.GetTypeCode(type);
if (this.IsCreateableSerializableData(serializableData))
{
obj = this.CreateObject(serializableData);
}
else
{
try
{
obj = this.ConvertType(serializableData);
}
catch
{
throw new XmlSerializationException(obj, serializableData);
}
}
this.FillObject(ref obj, serializableData);
return(obj);
}
protected Type GetType(SerializableData serializableData)
{
return(Type.GetType(serializableData.AssemblyQualifiedName));
}
public void WriteXml(string fileName, SerializableData serializableData)
{
this.CreateXmlDeclaration();
this.WriteXml(this._xmlDocument, serializableData);
this._xmlDocument.Save(fileName);
}
protected virtual void Filler(object dataToFill, Type type, object[] parameters, SerializableData serializableData)
{
XmlClassSerializable xmlClassSerializableAttribute = base.GetXmlClassSerializableAttribute(type);
bool flag = this.IsDeepSerializable(type);
BindingFlags flags = this.GetFlags(type, xmlClassSerializableAttribute);
PropertyInfo property = base.GetProperty(type, serializableData.FieldName, flags);
FieldInfo field = base.GetField(type, serializableData.FieldName, flags);
try
{
if ((property != null && property.CanWrite) || (field != null && !field.IsLiteral))
{
type.InvokeMember(serializableData.FieldName, flags, null, dataToFill, parameters);
}
else if (!type.BaseType.Equals(typeof(object)) && type.BaseType != null && flag)
{
this.FillObjectField(dataToFill, type.BaseType, serializableData);
}
else if (base.IsCollection(type) && !base.IsArray(type))
{
this.InvokeAddingMethod(dataToFill, parameters);
}
}
catch
{
throw new XmlSerializationException(dataToFill, serializableData, property, field);
}
}
public XmlSerializationException(object data, SerializableData serializableData)
{
this._data = data;
this._serializableData = serializableData;
}
protected virtual object ConvertType(SerializableData serializableData)
{
object result = null;
Type type = base.GetType(serializableData);
switch (Type.GetTypeCode(type))
{
case TypeCode.Empty:
if (serializableData.Value == string.Empty)
{
result = null;
}
else
{
result = Convert.ToBoolean(serializableData.Value);
}
break;
case TypeCode.DBNull:
if (serializableData.Value == string.Empty)
{
result = null;
}
else
{
result = Convert.ToBoolean(serializableData.Value);
}
break;
case TypeCode.Boolean:
if (serializableData.Value == string.Empty)
{
result = false;
}
else
{
result = bool.Parse(serializableData.Value);
}
break;
case TypeCode.Char:
if (serializableData.Value == string.Empty)
{
result = '\0';
}
else
{
result = char.Parse(serializableData.Value);
}
break;
case TypeCode.SByte:
if (serializableData.Value == string.Empty)
{
result = -128;
}
else
{
result = sbyte.Parse(serializableData.Value);
}
break;
case TypeCode.Byte:
if (serializableData.Value == string.Empty)
{
result = 0;
}
else
{
result = byte.Parse(serializableData.Value);
}
break;
case TypeCode.Int16:
if (serializableData.Value == string.Empty)
{
result = -32768;
}
else
{
result = short.Parse(serializableData.Value);
}
break;
case TypeCode.UInt16:
if (serializableData.Value == string.Empty)
{
result = 0;
}
else
{
result = ushort.Parse(serializableData.Value);
}
break;
case TypeCode.Int32:
if (serializableData.Value == string.Empty)
{
result = -2147483648;
}
else
{
result = int.Parse(serializableData.Value);
}
break;
case TypeCode.UInt32:
if (serializableData.Value == string.Empty)
{
result = 0u;
}
else
{
result = uint.Parse(serializableData.Value);
}
break;
case TypeCode.Int64:
if (serializableData.Value == string.Empty)
{
result = -9223372036854775808L;
}
else
{
result = long.Parse(serializableData.Value);
}
break;
case TypeCode.UInt64:
if (serializableData.Value == string.Empty)
{
result = 0uL;
}
else
{
result = ulong.Parse(serializableData.Value);
}
break;
case TypeCode.Single:
if (serializableData.Value == string.Empty)
{
result = -3.40282347E+38f;
}
else
{
result = float.Parse(serializableData.Value);
}
break;
case TypeCode.Double:
if (serializableData.Value == string.Empty)
{
result = -1.7976931348623157E+308;
}
else
{
result = double.Parse(serializableData.Value);
}
break;
case TypeCode.Decimal:
if (serializableData.Value == string.Empty)
{
result = -79228162514264337593543950335m;
}
else
{
result = decimal.Parse(serializableData.Value);
}
break;
case TypeCode.DateTime:
if (serializableData.Value == string.Empty)
{
result = DateTime.Now;
}
else
{
result = DateTime.Parse(serializableData.Value);
}
break;
case TypeCode.String:
result = serializableData.Value;
break;
}
return(result);
}
