/// <summary>Transforms the specified type into a string that is fit to be traced.</summary>
/// <param name="xml">The type to transform.</param>
/// <returns>The string.</returns>
internal protected static string ToTraceString(IXmlSerializable xml)
{
var sb=new StringBuilder();
using (var xw=XmlWriter.Create(sb))
xml.WriteXml(xw);
return sb.ToString();
}
private static Message CreateMessage(IXmlSerializable response, MessageVersion version)
{
StringBuilder serialized=new StringBuilder();
using (var xw=XmlWriter.Create(serialized))
response.WriteXml(xw);
var xr=XmlReader.Create(new StringReader(serialized.ToString()));
return Message.CreateMessage(version, "ExecuteResponse", xr);
}
private static void SerializeCustom(XmlWriter writer, XPathResult result, XPathNavigator node, IXmlSerializable value)
{
if (string.IsNullOrEmpty(node.NamespaceURI))
{
writer.WriteStartElement(node.LocalName);
}
else
{
var prefix = result.Context.AddNamespace(node.NamespaceURI);
writer.WriteStartElement(prefix, node.LocalName, node.NamespaceURI);
}
value.WriteXml(writer);
writer.WriteEndElement();
}
/// <summary>
/// Serializes property values to the settings file.
/// </summary>
/// <param name="filename">The name of the settings file to write to.</param>
public void Save(string filename)
{
// make sure directory exists!
Directory.CreateDirectory(Path.GetDirectoryName(filename));
XmlTextWriter w = null;
try {
w = new XmlTextWriter(filename, System.Text.Encoding.UTF8);
w.Formatting = Formatting.Indented;
w.WriteStartElement("Settings");
foreach (string key in map.Keys)
{
object value = map[key];
if (value != null)
{
if (value is Hashtable)
{
w.WriteStartElement(key); // container element
WriteHashTable(w, (Hashtable)value);
w.WriteEndElement();
}
else if (value is Array)
{
WriteArray(w, key, (Array)value);
}
else if (value is IXmlSerializable)
{
w.WriteStartElement(key); // container element
IXmlSerializable xs = (IXmlSerializable)value;
xs.WriteXml(w);
w.WriteEndElement();
}
else
{
string s = ConvertToString(value);
if (s != null)
{
w.WriteElementString(key, s);
}
}
}
}
} catch (Exception e) {
Console.WriteLine(e.Message);
} finally {
using (w) {
}
}
}
public static string WriteXml(IXmlSerializable target)
{
StringBuilder sb = new StringBuilder();
XmlWriterSettings xmlWriterSettings = new XmlWriterSettings();
xmlWriterSettings.ConformanceLevel = ConformanceLevel.Fragment;
using (XmlWriter writer = XmlTextWriter.Create(sb, xmlWriterSettings))
{
XmlRootAttribute[] xmlRootAttribute = target.GetType().GetCustomAttributes(typeof(XmlRootAttribute), false) as XmlRootAttribute[];
writer.WriteStartElement(xmlRootAttribute[0].ElementName);
target.WriteXml(writer);
writer.WriteEndElement();
}
return sb.ToString();
}
public void WriteXml(XmlWriter writer)
{
writer.WriteAttributeString("type", "object");
foreach (KeyValuePair <string, SaveValue> pair in _items)
{
IXmlSerializable xmlSerializable = pair.Value as IXmlSerializable;
if (xmlSerializable != null)
{
writer.WriteStartElement(pair.Key);
xmlSerializable.WriteXml(writer);
writer.WriteEndElement();
}
}
}
public static string WriteXml(IXmlSerializable target)
{
StringBuilder sb = new StringBuilder();
XmlWriterSettings xmlWriterSettings = new XmlWriterSettings();
xmlWriterSettings.ConformanceLevel = ConformanceLevel.Fragment;
using (XmlWriter writer = XmlTextWriter.Create(sb, xmlWriterSettings))
{
XmlRootAttribute[] xmlRootAttribute = target.GetType().GetCustomAttributes(typeof(XmlRootAttribute), false) as XmlRootAttribute[];
writer.WriteStartElement(xmlRootAttribute[0].ElementName);
target.WriteXml(writer);
writer.WriteEndElement();
}
return(sb.ToString());
}
public void WriteXml(XmlWriter writer)
{
writer.WriteAttributeString(DialectAttribute, _dialect);
IXmlSerializable serializable = _value as IXmlSerializable;
if (serializable != null)
{
serializable.WriteXml(writer);
return;
}
if (_value != null)
{
XmlSerializer serializer = new XmlSerializer(_value.GetType());
serializer.Serialize(writer, _value);
}
}
protected override void OnWriteBodyContents(XmlDictionaryWriter writer)
{
if (toSerialize != null)
{
IXmlSerializable serializable = toSerialize as IXmlSerializable;
if (serializable != null)
{
serializable.WriteXml(writer);
}
else
{
XmlSerializer xs = new XmlSerializer(toSerialize.GetType());
xs.Serialize(writer, toSerialize);
}
}
}
protected void WriteSerializable(IXmlSerializable serializable, string name, string ns, bool isNullable)
{
if (serializable == null)
{
if (isNullable)
{
WriteNullTagLiteral(name, ns);
}
return;
}
else
{
Writer.WriteStartElement(name, ns);
serializable.WriteXml(Writer);
Writer.WriteEndElement();
}
}
public void ArgumentsTest()
{
AssertHelper.ExpectedException <ArgumentException>(() => new RecentFile(null !));
var recentFile = new RecentFile("Doc1");
Assert.AreEqual("Doc1", recentFile.Path);
AssertHelper.PropertyChangedEvent(recentFile, x => x.IsPinned, () => recentFile.IsPinned = true);
Assert.IsTrue(recentFile.IsPinned);
IXmlSerializable serializable = recentFile;
Assert.IsNull(serializable.GetSchema());
AssertHelper.ExpectedException <ArgumentNullException>(() => serializable.ReadXml(null));
AssertHelper.ExpectedException <ArgumentNullException>(() => serializable.WriteXml(null));
}
private static void SerializeXmlSerializable(IXmlSerializable obj, XContainer parent)
{
StringBuilder sb = new StringBuilder();
using (XmlWriter xw = XmlWriter.Create(sb, new XmlWriterSettings {
ConformanceLevel = ConformanceLevel.Fragment
}))
{
obj.WriteXml(xw);
xw.Flush();
}
Type objType = obj.GetType();
string contentName = null;
object[] attrs = objType.GetCustomAttributes(typeof(XmlRootAttribute), true);
if (attrs.Length > 0)
{
contentName = ((XmlRootAttribute)attrs[0]).ElementName;
}
if (String.IsNullOrEmpty(contentName))
{
contentName = objType.Name;
}
using (XmlReader xr = XmlReader.Create(new StringReader(sb.ToString()), new XmlReaderSettings {
ConformanceLevel = ConformanceLevel.Fragment, CloseInput = true
}))
{
if (!xr.Read())
{
return;
}
XElement content = new XElement(contentName);
while (!xr.EOF)
{
content.Add(XNode.ReadFrom(xr));
}
parent.Add(content);
}
parent.Add(new XAttribute(XmlSerializer.AttributeFormat, XmlSerializer.AttributeValueCustom));
}
public void WriteXml(XmlWriter writer)
{
writer.WriteStartElement(this.GetType().ToString());
writer.WriteAttributeString("assembly", CurrentAssemblyName);
writer.WriteAttributeString("title", title.Text);
writer.WriteAttributeString("Expand", Expand.ToString());
writer.WriteStartElement("widget");
IXmlSerializable xmlitm = CurrentWidget as IXmlSerializable;
if (xmlitm != null)
{
xmlitm.WriteXml(writer);
}
writer.WriteEndElement();
writer.WriteEndElement();
}
public void WriteXml(XmlWriter writer)
{
writer.WriteAttributeString("type", "array");
int curIndex = 0;
foreach (SaveValue item in _items)
{
IXmlSerializable xmlSerializable = item as IXmlSerializable;
if (xmlSerializable != null)
{
writer.WriteStartElement("Item");
writer.WriteAttributeString("index", curIndex.ToString());
xmlSerializable.WriteXml(writer);
writer.WriteEndElement();
curIndex++;
}
}
}
/// <include file='doc\XmlSerializationWriter.uex' path='docs/doc[@for="XmlSerializationWriter.WriteSerializable1"]/*' />
protected void WriteSerializable(IXmlSerializable serializable, string name, string ns, bool isNullable, bool wrapped)
{
if (serializable == null)
{
if (isNullable)
{
WriteNullTagLiteral(name, ns);
}
return;
}
if (wrapped)
{
_w.WriteStartElement(name, ns);
}
serializable.WriteXml(_w);
if (wrapped)
{
_w.WriteEndElement();
}
}
/// <summary>
/// Serialize to XML string
/// </summary>
/// <param name="o">object to be serialized</param>
/// <returns>json string of object</returns>
public static string SerializeToXML(IXmlSerializable apiObject)
{
XmlWriterSettings settings = new XmlWriterSettings();
settings.ConformanceLevel = ConformanceLevel.Fragment;
settings.CloseOutput = false;
var ms = new StringBuilder();
{
using (XmlWriter writer = XmlWriter.Create(ms, settings))
{
//Write to XML first (built into ESAPI)
var @class = apiObject.GetType().FullName;
writer.WriteStartElement(@class);
apiObject.WriteXml(writer);
writer.WriteFullEndElement();
writer.Close();
var xml = ms.ToString();
return(xml);
}
}
}
private bool CheckExceptions(IXmlSerializable instance)
{
try
{
// ReSharper disable ReturnValueOfPureMethodIsNotUsed
instance.GetSchema();
// ReSharper restore ReturnValueOfPureMethodIsNotUsed
throw new UnitTestException(string.Format(CultureInfo.InvariantCulture, Resources.XmlSerialization_GetSchema, Type.Name));
}
catch (NotSupportedException)
{
}
try
{
// ReSharper disable ReturnValueOfPureMethodIsNotUsed
instance.ReadXml(null);
// ReSharper restore ReturnValueOfPureMethodIsNotUsed
throw new UnitTestException(string.Format(CultureInfo.InvariantCulture, Resources.XmlSerialization_ReadXmlNull, Type.Name));
}
catch (ArgumentNullException)
{
}
try
{
// ReSharper disable ReturnValueOfPureMethodIsNotUsed
instance.WriteXml(null);
// ReSharper restore ReturnValueOfPureMethodIsNotUsed
throw new UnitTestException(string.Format(CultureInfo.InvariantCulture, Resources.XmlSerialization_WriteXmlNull, Type.Name));
}
catch (ArgumentNullException)
{
}
return(true);
}
/// <summary>
/// Writer must be in parent element, which should be closed by the parent.
/// </summary>
private static void SerializeXmlSerializable(IXmlSerializable obj, XmlWriter writer)
{
writer.WriteAttributeString(XmlSerializer.AttributeFormat, XmlSerializer.AttributeValueCustom);
Type objType = obj.GetType();
string contentName = null;
object[] attrs = objType.GetCustomAttributes(typeof(XmlRootAttribute), true);
if (attrs.Length > 0)
{
contentName = ((XmlRootAttribute)attrs[0]).ElementName;
}
if (String.IsNullOrEmpty(contentName))
{
contentName = objType.Name;
}
writer.WriteStartElement(contentName);
obj.WriteXml(writer);
writer.WriteFullEndElement();
}
public void WriteXml(XmlWriter writer)
{
writer.WriteStartElement("triple");
writer.WriteAttributeString("type", this.GetType().ToString());
if (!this.isDefaultGraph)
{
if (this.variableDataSet != null)
{
writer.WriteAttributeString("graph", "variable");
this.variableDataSet.WriteXml(writer);
}
else
{
writer.WriteAttributeString("graph", "named");
this.graphs.WriteXml(writer);
}
}
else
{
writer.WriteAttributeString("graph", "default");
}
IXmlSerializable s = this.sVariableNode ?? this.Subject;
s.WriteXml(writer);
IXmlSerializable p = this.pVariableNode ?? this.Predicate;
p.WriteXml(writer);
IXmlSerializable o = this.oVariableNode ?? this.Object;
o.WriteXml(writer);
writer.WriteEndElement();
}
public void XmlSerializing()
{
XmlSerializer serializer = new XmlSerializer(typeof(RecentFileList));
// Serialize an empty list
MemoryStream stream1 = new MemoryStream();
RecentFileList recentFileList1 = new RecentFileList();
serializer.Serialize(stream1, recentFileList1);
stream1.Position = 0;
RecentFileList recentFileList2 = (RecentFileList)serializer.Deserialize(stream1);
Assert.AreEqual(recentFileList1.RecentFiles.Count, recentFileList2.RecentFiles.Count);
AssertHelper.SequenceEqual(recentFileList1.RecentFiles.Select(f => f.Path), recentFileList2.RecentFiles.Select(f => f.Path));
// Serialize a list with items
MemoryStream stream2 = new MemoryStream();
recentFileList2.AddFile("Doc3");
recentFileList2.AddFile("Doc2");
recentFileList2.AddFile("Doc1");
serializer.Serialize(stream2, recentFileList2);
stream2.Position = 0;
RecentFileList recentFileList3 = (RecentFileList)serializer.Deserialize(stream2);
AssertHelper.SequenceEqual(recentFileList2.RecentFiles.Select(f => f.Path), recentFileList3.RecentFiles.Select(f => f.Path));
// Set MaxFilesNumber to a lower number
recentFileList3.MaxFilesNumber = 2;
AssertHelper.SequenceEqual(new[] { "Doc1", "Doc2" }, recentFileList3.RecentFiles.Select(f => f.Path));
// Check error handling of the serializable implementation
IXmlSerializable serializable = recentFileList3;
Assert.IsNull(serializable.GetSchema());
AssertHelper.ExpectedException <ArgumentNullException>(() => serializable.ReadXml(null));
AssertHelper.ExpectedException <ArgumentNullException>(() => serializable.WriteXml(null));
}
void WriteSerializable(IXmlSerializable serializable, string name, string ns, bool isNullable, bool wrapped)
{
if (serializable == null)
{
if (isNullable && wrapped)
{
WriteNullTagLiteral(name, ns);
}
return;
}
else
{
if (wrapped)
{
Writer.WriteStartElement(name, ns);
}
serializable.WriteXml(Writer);
if (wrapped)
{
Writer.WriteEndElement();
}
}
}
/// <summary>
/// Helper method for serializing a simple or complex type and
/// formating the data into an xml element.
/// </summary>
/// <param name="name"></param>
/// <param name="obj"></param>
/// <returns></returns>
protected XmlElement SerializeCore(string name, object obj)
{
//if we are serializing a null object, we have already created the element for it
//so now we need to let it know there is no data to be found.
if (IsReferenceNull(obj))
{
XmlElement e = Doc.CreateElement(name);
e.SetAttribute("value", "null");
return(e);
}
//we want Unity objects to be identified by their type
Type objType = obj.GetType();
XmlElement element = null;
if (obj is UnityEngine.Object && name == null)
{
element = Doc.CreateElement(objType.Name);
}
else
{
element = Doc.CreateElement(name);
}
//WARNING: I'm guessing 'AnsiClass' means 'struct'. Not entirely sure though.
//And I have no idea what an 'AutoClass' or 'UnicodeClass' is at all.
//we are serializing a complex object of some kind
if (objType.IsClass && objType != typeof(string))
{
//This object is a Unity component that had its serialization previously defered.
//We now need to know what that defered element used as an id and store that
//when we serialize this object.
if (DeferedCache != null && DeferedCache.ContainsKey(obj))
{
element.SetAttribute("id", GetCacheId(objType, obj).ToString());
//element.SetAttribute("DeferedId", DeferedCache[obj].ToString());
//tj
//SetAsDeferedComponent((Component)obj, element);
//continue serialization as normal from here...
}
//if this is not a unity object we still need to check the object cache and see
//if we already serialized it once.
else if (Options.UseGraphSerialization && !AddObjToCache(objType, obj, element))
{
return(element);
}
// the object has just been added
SetTypeInfo(objType, element);
//TODO: For general-surrogate support we'll need to implement it here.
if (CheckForcedSerialization(objType))
{
// serialize as complex type
SerializeComplexType(obj, ref element);
return(element);
}
IXmlSerializable xmlSer = obj as IXmlSerializable;
if (xmlSer == null)
{
//HACK ALERT: Hard-coding logic tied to specific datatypes!!
//We need to intercept Unity built-in types here because some of
//them expose the IEnumerable interface and will cause inifite loops
//(namely, the Transform component).
if (objType.IsSubclassOf(typeof(Component)))
{
SerializeComplexType(obj as Component, ref element);
return(element);
}
// does not know about automatic serialization
IEnumerable enumerable = obj as IEnumerable;
if (enumerable == null)
{
SerializeComplexType(obj, ref element);
}
else
{
//This gets a little poo-poo here. We can't simply serialize
//as a list of enumerables if this is a multi-dimensional array
//since we'll need to know the individual ranks and rank lengths
//when we deserialize. So we'll try casting to see what we do next.
var arr = obj as Array;
if (arr != null && arr.Rank > 1)
{
element.SetAttribute("Ranks", ArrayRankCounter(arr));
SerializeMultiDimensionalArray(name, arr, 0, new int[arr.Rank], element);
}
else
{
//either a single-dimensional array or just an enumerable list of some kind
foreach (object arrObj in enumerable)
{
XmlElement e = SerializeCore(name, arrObj);
element.AppendChild(e);
}
}
}
}
else
{
// can perform the serialization itself
StringBuilder sb = new StringBuilder();
XmlWriterSettings settings = new XmlWriterSettings();
settings.ConformanceLevel = ConformanceLevel.Fragment;
settings.Encoding = Encoding.UTF8;
settings.OmitXmlDeclaration = true;
XmlWriter wr = XmlWriter.Create(sb, settings);
wr.WriteStartElement("value");
xmlSer.WriteXml(wr);
wr.WriteEndElement();
wr.Close();
element.InnerXml = sb.ToString();
}
}
else
{
// the object has just been added
SetTypeInfo(objType, element);
if (CheckForcedSerialization(objType))
{
// serialize as complex type
SerializeComplexType(obj, ref element);
return(element);
}
if (objType.IsEnum)
{
object val = Enum.Format(objType, obj, "d");
element.SetAttribute("value", val.ToString());
}
else
{
if (objType.IsPrimitive || objType == typeof(string) ||
objType == typeof(DateTime) || objType == typeof(decimal))
{
element.SetAttribute("value", obj.ToString());
}
else
{
// this is most probably a struct (or autoclass or unicodeclass, whatever those are)
SerializeComplexType(obj, ref element);
}
}
}
return(element);
}
public static void WriteElement(this XmlWriter writer, string name, IXmlSerializable child)
{
writer.WriteStartElement(name);
child.WriteXml(writer);
writer.WriteEndElement();
}
/// <summary>
/// Writes an element
/// </summary>
/// <param name="writer">An Xml Writer</param>
/// <param name="name">The element name</param>
/// <param name="value">The value</param>
internal static void WriteElement(this XmlWriter writer, string name, IXmlSerializable value)
{
writer.WriteStartElement(name);
value.WriteXml(writer);
writer.WriteEndElement();
}
/// <include file='doc\XmlSerializationWriter.uex' path='docs/doc[@for="XmlSerializationWriter.WriteSerializable1"]/*' />
protected void WriteSerializable(IXmlSerializable serializable, string name, string ns, bool isNullable, bool wrapped) {
if (serializable == null) {
if (isNullable) WriteNullTagLiteral(name, ns);
return;
}
if (wrapped) {
w.WriteStartElement(name, ns);
}
serializable.WriteXml(w);
if (wrapped) {
w.WriteEndElement();
}
}
public void Serialize(IXmlSerializable item, XmlWriter output)
{
if (item == null) throw new ArgumentNullException("value");
if (output == null) throw new ArgumentNullException("output");
XmlRootAttribute xmlRootAttr = GetXmlRootAttribute(item.GetType());
XmlRootPrefixedAttribute xmlRootPrefixAttr = xmlRootAttr as XmlRootPrefixedAttribute;
if (xmlRootPrefixAttr != null
&& xmlRootPrefixAttr.Prefix.HasValue()) {
output.WriteStartElement(xmlRootPrefixAttr.Prefix, xmlRootAttr.ElementName, xmlRootAttr.Namespace);
} else {
output.WriteStartElement(xmlRootAttr.ElementName, xmlRootAttr.Namespace);
}
item.WriteXml(output);
output.WriteEndElement();
}
XmlElement SerializeCore(string name, object obj)
{
if (name.Contains("<") || name.Contains(">"))
{
name = name.Replace("<", string.Empty).Replace(">k__BackingField", string.Empty);
}
XmlElement element = doc.CreateElement(name);
if (obj == null)
{
element.SetAttribute("value", "null");
return(element);
}
Type objType = obj.GetType();
if (objType.IsClass && objType != typeof(string))
{
// check if we have already serialized this object
if (options.UseGraphSerialization && !AddObjToCache(objType, obj, element))
{
return(element);
}
// the object has just been added
SetTypeInfo(objType, element);
if (CheckForcedSerialization(objType))
{
// serialize as complex type
SerializeComplexType(obj, element);
return(element);
}
IXmlSerializable xmlSer = obj as IXmlSerializable;
if (xmlSer == null)
{
// does not know about automatic serialization
IEnumerable arr = obj as IEnumerable;
if (arr == null)
{
SerializeComplexType(obj, element);
}
else
{
foreach (object arrObj in arr)
{
XmlElement e = SerializeCore(name, arrObj);
element.AppendChild(e);
}
}
}
else
{
// can perform the serialization itself
StringBuilder sb = new StringBuilder();
XmlWriterSettings settings = new XmlWriterSettings();
settings.ConformanceLevel = ConformanceLevel.Fragment;
settings.Encoding = Encoding.UTF8;
settings.OmitXmlDeclaration = true;
XmlWriter wr = XmlWriter.Create(sb, settings);
wr.WriteStartElement("value");
xmlSer.WriteXml(wr);
wr.WriteEndElement();
wr.Close();
element.InnerXml = sb.ToString();
}
}
else
{
// the object has just been added
SetTypeInfo(objType, element);
if (CheckForcedSerialization(objType))
{
// serialize as complex type
SerializeComplexType(obj, element);
return(element);
}
if (objType.IsEnum)
{
object val = Enum.Format(objType, obj, "d");
element.SetAttribute("value", val.ToString());
}
else
{
if (objType.IsPrimitive || objType == typeof(string) ||
objType == typeof(DateTime) || objType == typeof(decimal))
{
element.SetAttribute("value", obj.ToString());
}
else
{
// this is most probably a struct
SerializeComplexType(obj, element);
}
}
}
return(element);
}
private bool CheckExceptions(IXmlSerializable instance)
{
try
{
// ReSharper disable ReturnValueOfPureMethodIsNotUsed
instance.GetSchema();
// ReSharper restore ReturnValueOfPureMethodIsNotUsed
throw new UnitTestException(string.Format(CultureInfo.InvariantCulture, Resources.XmlSerialization_GetSchema, Type.Name));
}
catch (NotSupportedException)
{
}
try
{
// ReSharper disable ReturnValueOfPureMethodIsNotUsed
instance.ReadXml(null);
// ReSharper restore ReturnValueOfPureMethodIsNotUsed
throw new UnitTestException(string.Format(CultureInfo.InvariantCulture, Resources.XmlSerialization_ReadXmlNull, Type.Name));
}
catch (ArgumentNullException)
{
}
try
{
// ReSharper disable ReturnValueOfPureMethodIsNotUsed
instance.WriteXml(null);
// ReSharper restore ReturnValueOfPureMethodIsNotUsed
throw new UnitTestException(string.Format(CultureInfo.InvariantCulture, Resources.XmlSerialization_WriteXmlNull, Type.Name));
}
catch (ArgumentNullException)
{
}
return true;
}
public void WriteXml(XmlWriter w)
{
w.WriteStartDocument();
w.WriteStartElement("Settings");
ArrayList keys = new ArrayList(map.Keys);
keys.Sort();
foreach (string key in keys)
{
object value = map[key];
if (value == null)
{
continue;
}
PropertyInfo pi = this.GetType().GetProperty(key);
if (pi != null)
{
Type t = pi.PropertyType;
if (t == typeof(Point))
{
w.WriteStartElement(key);
SerializePoint(w, (Point)value);
w.WriteEndElement();
}
else if (t == typeof(Size))
{
SerializeSize(w, key, (Size)value);
}
else if (t == typeof(int))
{
w.WriteElementString(key, ((int)value).ToString());
}
else if (t == typeof(string))
{
w.WriteElementString(key, ((string)value));
}
else if (t == typeof(GraphState))
{
w.WriteStartElement(key);
this.GraphState.WriteXml(w);
w.WriteEndElement();
}
else if (t == typeof(DateTime))
{
SerializeDateTime(w, key, (DateTime)value);
}
else if (t == typeof(TimeSpan))
{
SerializeTimeSpan(w, key, (TimeSpan)value);
}
else if (t == typeof(bool))
{
w.WriteElementString(key, ((bool)value).ToString());
}
else if (t == typeof(QueryRow[]))
{
w.WriteStartElement(key);
WriteQuery(w, (QueryRow[])value);
w.WriteEndElement();
}
else
{
throw new Exception("Settings.ReadXml encountered unsupported property type '" + t.FullName + "'");
}
}
else if (value is IXmlSerializable)
{
IXmlSerializable s = (IXmlSerializable)value;
if (s != null)
{
w.WriteStartElement(key);
s.WriteXml(w);
w.WriteEndElement();
}
}
else
{
w.WriteElementString(key, value.ToString());
}
}
HashSet <Type> saved = new HashSet <Type>();
foreach (KeyValuePair <Type, ViewState> pair in this.viewStates)
{
Type t = pair.Key;
ViewState s = pair.Value;
if (s != null)
{
saved.Add(t);
string key = s.GetType().FullName;
w.WriteStartElement(key);
w.WriteAttributeString("ViewType", t.FullName);
s.WriteXml(w);
w.WriteEndElement();
}
}
foreach (KeyValuePair <Type, XmlElement> pair in this.viewStateNodes)
{
Type t = pair.Key;
if (!saved.Contains(t))
{
// this view type was not used, but we need to round trip the previous settings so we don't lose them.
XmlElement e = pair.Value;
if (e != null)
{
e.WriteTo(w);
}
}
}
w.WriteEndElement();
w.WriteEndDocument();
}
XmlElement SerializeCore(string name, object obj, Type objType, string elementType)
{
XmlElement element = doc.CreateElement(elementType);
element.SetAttribute("Name", name);
if (obj == null)
{
element.SetAttribute("value", NULL_VALUE);
return(element);
}
if (objType.IsClass && objType != typeof(string))
{
// check if we have already serialized this object
if (options.UseGraphSerialization && !AddObjToCache(objType, obj, element))
{
return(element);
}
// the object has just been added
SetTypeInfo(objType, element);
if (CheckForcedSerialization(objType))
{
// serialize as complex type
SerializeComplexType(obj, objType, element);
return(element);
}
IXmlSerializable xmlSer = obj as IXmlSerializable;
if (xmlSer == null)
{
// does not know about automatic serialization
if (objType.IsSubclassOf(typeof(XmlNode)))
{
SerializeXmlType(obj, objType, element);
}
else
{
IEnumerable arr = obj as IEnumerable;
if (arr == null)
{
SerializeComplexType(obj, objType, element);
}
else
{
SerializeIEnumerable(name, arr, element);
}
}
}
else
{
// can perform the serialization itself
StringBuilder sb = new StringBuilder();
XmlWriterSettings settings = new XmlWriterSettings();
settings.ConformanceLevel = ConformanceLevel.Fragment;
settings.Encoding = Encoding.UTF8;
settings.OmitXmlDeclaration = true;
XmlWriter wr = XmlWriter.Create(sb, settings);
wr.WriteStartElement("value");
xmlSer.WriteXml(wr);
wr.WriteEndElement();
wr.Close();
element.InnerXml = sb.ToString();
}
}
else
{
// the object has just been added
SetTypeInfo(objType, element);
if (CheckForcedSerialization(objType))
{
// serialize as complex type
SerializeComplexType(obj, objType, element);
return(element);
}
if (objType.IsEnum)
{
object val = Enum.Format(objType, obj, "d");
element.SetAttribute("value", val.ToString());
}
else
{
if (objType.IsPrimitive || objType == typeof(string) ||
objType == typeof(DateTime) || objType == typeof(decimal))
{
element.SetAttribute("value", obj.ToString());
}
else
{
// this is most probably a struct
SerializeComplexType(obj, objType, element);
}
}
}
return(element);
}
private static void SerializeCustom(XmlWriter writer, XPathResult result, XPathNavigator node, IXmlSerializable value)
{
if (string.IsNullOrEmpty(node.NamespaceURI))
{
writer.WriteStartElement(node.LocalName);
}
else
{
var prefix = result.Context.AddNamespace(node.NamespaceURI);
writer.WriteStartElement(prefix, node.LocalName, node.NamespaceURI);
}
value.WriteXml(writer);
writer.WriteEndElement();
}
void WriteSerializable (IXmlSerializable serializable, string name, string ns, bool isNullable, bool wrapped)
{
if (serializable == null)
{
if (isNullable && wrapped) WriteNullTagLiteral (name, ns);
return;
}
else
{
if (wrapped)
Writer.WriteStartElement (name, ns);
serializable.WriteXml (Writer);
if (wrapped)
Writer.WriteEndElement ();
}
}
/// <summary/>
public void Serialize(XmlTextWriter writer, object obj, bool writeElement)
{
//Use the IXmlSerializable implementation if needed
IXmlSerializable serializableObject = obj as IXmlSerializable;
if (serializableObject != null)
{
serializableObject.WriteXml(writer);
return;
}
//If the type can be converted directly to a string then serialize it
//as an element with text content (int, string, etc)
TypeConverter conv = TypeDescriptor.GetConverter(obj);
if (CanSerialize(conv))
{
writer.WriteElementString(obj.GetType().Name.ToUpperInvariant(), conv.ConvertToInvariantString(obj));
return;
}
//Serialize the object and its public members
if (writeElement)
{
writer.WriteStartElement(obj.GetType().Name);
}
//Get the list of properties with the ones that want to be serialized as attributed listed first
List <PropertyDescriptor> props = SortAttributedProperties(obj);
//Serialize the Properties
foreach (PropertyDescriptor prop in props)
{
//Get the property value
object value = prop.GetValue(obj);
if (value == null)
{
continue;
}
if (prop.IsReadOnly)
{
//if the property is read-only and is a list then serialize the content
IList list = value as IList;
if (list != null && list.Count > 0)
{
writer.WriteStartElement(prop.Name);
string elementName = prop.Name.Substring(0, prop.Name.Length - 1);
DefaultListSerializer serializer = new DefaultListSerializer(elementName);
serializer.Serialize(writer, list, false);
writer.WriteEndElement();
}
}
else
{
//Get a converter and Serialize it to a string
TypeConverter converter = prop.Converter;
if (converter == null || !converter.CanConvertTo(typeof(string)) || !converter.CanConvertFrom(typeof(string)))
{
writer.WriteStartElement(prop.Name);
ObjectSerializer.Serialize(writer, value, false);
writer.WriteEndElement();
continue;
}
string strValue = converter.ConvertToString(null, InvariantSerializationCulture, value);
if (prop.Attributes.Contains(new XmlAttributeAttribute()))
{
writer.WriteAttributeString(prop.Name, strValue);
}
else
{
writer.WriteElementString(prop.Name, strValue);
}
}
}
if (writeElement)
{
writer.WriteEndElement(); //Object element
}
}
private static string WriteXml(IXmlSerializable obj)
{
var f = Path.GetTempFileName();
//var f = "test.xml";
using (var writer = GetXmlWriter(f))
{
writer.WriteStartElement("root");
obj.WriteXml(writer);
writer.WriteEndElement();
}
return f;
}
/// <summary>
/// Converts or casts an object to a string.
/// </summary>
/// <param name="obj">The string to cast / convert.</param>
/// <param name="handleDBNullAsNull">
/// Handle <see cref="DBNull" /> objects as <see langword="null" /> or not.
/// </param>
/// <returns>The converted / casted string.</returns>
/// <remarks>
/// If <paramref name="obj" /> is <see langword="null" /> the result will also be <see langword="null" />.
/// If <paramref name="obj" /> is already a <see cref="string" />, it is simply casted.
/// </remarks>
public static string AsString(object obj, bool handleDBNullAsNull)
{
if (obj == null)
{
return(null);
}
if (obj is string)
{
return((string)obj);
}
if (handleDBNullAsNull &&
DBNull.Value.Equals(obj))
{
return(null);
}
if (obj is IEnumerable <char> )
{
// char sequence / array
return(new string(CollectionHelper.AsArray(obj as IEnumerable <char>)));
}
else if (obj is TextReader)
{
// read text to end
return(((TextReader)obj).ReadToEnd());
}
else if (obj is IEnumerable <byte> )
{
// hex string
return(AsHexString(obj as IEnumerable <byte>, true));
}
else if (obj is Stream)
{
// handle blob as UTF-8 string data
using (StreamReader reader = new StreamReader(new NonDisposableStream(obj as Stream),
Encoding.UTF8))
{
return(AsString(reader, true));
}
}
else if (obj is IXmlSerializable)
{
// XML object
IXmlSerializable xmlObj = (IXmlSerializable)obj;
StringBuilder xml = new StringBuilder();
using (StringWriter strWriter = new StringWriter(xml))
{
using (XmlWriter xmlWriter = XmlWriter.Create(strWriter))
{
xmlObj.WriteXml(xmlWriter);
xmlWriter.Flush();
xmlWriter.Close();
}
}
return(AsString(xml, true));
}
else if (obj is IContentProvider)
{
IContentProvider provider = (IContentProvider)obj;
Stream stream = provider.OpenStream();
if (stream != null)
{
using (StreamReader reader = new StreamReader(stream,
provider.Encoding ?? Encoding.UTF8,
false))
{
return(AsString(reader, true));
}
}
return(null);
}
else if ((obj is IEnumerable <string>) ||
(obj is IEnumerable <IEnumerable <char> >))
{
// concat string sequence
IEnumerable seq = (IEnumerable)obj;
IEnumerable <object> objSeq = CollectionHelper.Cast <object>(seq);
StringBuilder concatedStrList = new StringBuilder();
foreach (object item in objSeq)
{
concatedStrList.Append(AsString(item, true));
}
return(concatedStrList.ToString());
}
bool extensionHandled = false;
StringBuilder extensionResultBuilder = new StringBuilder();
AsStringExtension(obj,
ref extensionHandled,
ref extensionResultBuilder);
if (extensionHandled)
{
return(extensionResultBuilder != null?extensionResultBuilder.ToString() : null);
}
// use default
return(obj.ToString());
}
public void WriteXml(XmlWriter writer)
{
serializer.WriteXml(writer, this);
}
void IXmlSerializable.WriteXml(XmlWriter writer)
{
IXmlSerializable serializable = this.Untyped as IXmlSerializable;
serializable.WriteXml(writer);
}
private XmlElement SerializeCore(string name, object obj)
{
XmlElement xmlElement = this.doc.CreateElement(name);
if (obj == null)
{
xmlElement.SetAttribute("value", "null");
return(xmlElement);
}
Type type = obj.GetType();
if (type.IsClass && type != typeof(string))
{
if (this.options.UseGraphSerialization && !this.AddObjToCache(type, obj, xmlElement))
{
return(xmlElement);
}
this.SetTypeInfo(type, xmlElement);
if (CustomXmlSerializer.CheckForcedSerialization(type))
{
this.SerializeComplexType(obj, xmlElement);
return(xmlElement);
}
IXmlSerializable xmlSerializable = obj as IXmlSerializable;
if (xmlSerializable == null)
{
IEnumerable enumerable = obj as IEnumerable;
if (enumerable == null)
{
this.SerializeComplexType(obj, xmlElement);
return(xmlElement);
}
IEnumerator enumerator = enumerable.GetEnumerator();
try
{
while (enumerator.MoveNext())
{
object current = enumerator.Current;
XmlElement newChild = this.SerializeCore(name, current);
xmlElement.AppendChild(newChild);
}
return(xmlElement);
}
finally
{
IDisposable disposable = enumerator as IDisposable;
if (disposable != null)
{
disposable.Dispose();
}
}
}
StringBuilder stringBuilder = new StringBuilder();
XmlWriter xmlWriter = XmlWriter.Create(stringBuilder, new XmlWriterSettings
{
ConformanceLevel = ConformanceLevel.Fragment,
Encoding = Encoding.UTF8,
OmitXmlDeclaration = true
});
xmlWriter.WriteStartElement("value");
xmlSerializable.WriteXml(xmlWriter);
xmlWriter.WriteEndElement();
xmlWriter.Close();
xmlElement.InnerXml = stringBuilder.ToString();
}
else
{
this.SetTypeInfo(type, xmlElement);
if (CustomXmlSerializer.CheckForcedSerialization(type))
{
this.SerializeComplexType(obj, xmlElement);
return(xmlElement);
}
if (type.IsEnum)
{
object obj2 = Enum.Format(type, obj, "d");
xmlElement.SetAttribute("value", obj2.ToString());
}
else
{
if (type.IsPrimitive || type == typeof(string) || type == typeof(DateTime) || type == typeof(decimal))
{
xmlElement.SetAttribute("value", obj.ToString());
}
else
{
this.SerializeComplexType(obj, xmlElement);
}
}
}
return(xmlElement);
}
protected void WriteSerializable (IXmlSerializable serializable, string name, string ns, bool isNullable)
{
if (serializable == null)
{
if (isNullable) WriteNullTagLiteral (name, ns);
return;
}
else
{
Writer.WriteStartElement (name, ns);
serializable.WriteXml (Writer);
Writer.WriteEndElement ();
}
}
/// <summary>
/// Attach an <see cref="IXmlSerializable"/> to an XML file.
/// </summary>
public static void SerializeObject(XmlWriter writer, IXmlSerializable target)
{
writer.WriteStartElement(target.GetType().Name);
target.WriteXml(writer);
writer.WriteEndElement();
}