protected IXmlSerializable ReadSerializable(IXmlSerializable serializable, bool wrappedAny)
{
string name = null;
string ns = null;
if (wrappedAny)
{
name = reader.LocalName;
ns = reader.NamespaceURI;
reader.Read();
reader.MoveToContent();
}
serializable.ReadXml(reader);
if (wrappedAny)
{
while (reader.NodeType == XmlNodeType.Whitespace)
{
reader.Skip();
}
if (reader.NodeType == XmlNodeType.None)
{
reader.Skip();
}
if (reader.NodeType == XmlNodeType.EndElement && reader.LocalName == name && reader.NamespaceURI == ns)
{
reader.Read();
}
}
return(serializable);
}
/// <summary>
/// deep copy an object using XmlSerialization
/// </summary>
/// <param name="elementName">name of surrounding element when writing the object</param>
/// <param name="source">object to copy</param>
/// <param name="destination">new blank element to copy into</param>
public static void CloneUsingXmlSerialization(string elementName, IXmlSerializable source, IXmlSerializable destination)
{
XmlWriterSettings writeSettings = new XmlWriterSettings
{
OmitXmlDeclaration = true,
ConformanceLevel = ConformanceLevel.Fragment,
CloseOutput = false,
Encoding = Encoding.UTF8
};
MemoryStream memoryStream = new MemoryStream();
var xmlWriter = XmlWriter.Create(memoryStream, writeSettings);
// simulate the behaviour of XmlSerialisation
xmlWriter.WriteStartElement(elementName);
source.WriteXml(xmlWriter);
xmlWriter.WriteEndElement();
xmlWriter.Flush();
memoryStream.Position = 0;
XmlReaderSettings readSettings = new XmlReaderSettings {
ConformanceLevel = ConformanceLevel.Fragment
};
var reader = XmlReader.Create(memoryStream, readSettings);
destination.ReadXml(reader);
}
public static IXmlSerializable CreateByTypeAttribute(XmlReader reader)
{
reader.ReadStartElement();
if (!reader.IsStartElement())
{
return(null);
}
//reader.ReadStartElement();
// reader.MoveToAttribute("type");
// if (!reader.ReadAttributeValue()) { }
string typeString = reader.GetAttribute("type");
if (typeString == null)
{
throw new NullReferenceException();
}
else
{
Type type = Type.GetType(typeString);
IXmlSerializable obj = (IXmlSerializable)type.GetConstructor(new Type[0]).Invoke(new object[0]);
obj.ReadXml(reader);
if (!reader.IsEmptyElement)
{
reader.ReadEndElement();
}
//reader.Skip();
return(obj);
}
}
public void ReadXml(XmlReader reader)
{
_dialect = reader.GetAttribute(DialectAttribute);
Type type = FilterMapExtension.GetDialectType(_dialect);
if (type == null)
{
throw CreateNotSupportedDialectException();
}
if (type == typeof(void))
{
return;
}
if (typeof(IXmlSerializable).IsAssignableFrom(type))
{
IXmlSerializable serializable = (IXmlSerializable)Activator.CreateInstance(type);
serializable.ReadXml(reader);
return;
}
XmlSerializer serializer = new XmlSerializer(type);
if (!reader.IsEmptyElement)
{
reader.ReadStartElement("Filter", reader.NamespaceURI);
_value = serializer.Deserialize(reader);
reader.ReadEndElement();
}
}
/// <summary>
/// Deserialize xml string to object.
/// </summary>
/// <param name="data">Deserialized string</param>
/// <param name="obj">The object implements IXmlSerializable.</param>
public static void Deserialize(string data, IXmlSerializable obj)
{
if (data.Equals(string.Empty))
{
return;
}
XmlReader reader = null;
StringReader sr = null;
try {
sr = new StringReader(data);
reader = new XmlTextReader(sr);
obj.ReadXml(reader);
}
catch {
}
finally {
if (sr != null)
{
sr.Close();
}
}
}
public void ReadXml(XmlReader reader)
{
if (reader.IsEmptyElement)
{
reader.Read();
return;
}
reader.ReadStartElement();
while (reader.NodeType != XmlNodeType.EndElement)
{
string key = reader.LocalName;
string type = reader.GetAttribute("type");
SaveValue saveValue = SaveValue.Instantiate(type);
IXmlSerializable xmlSerializable = saveValue as IXmlSerializable;
if (xmlSerializable != null)
{
xmlSerializable.ReadXml(reader);
_items[key] = saveValue;
}
if (reader.EOF)
{
throw new IOException("Malformed XML file");
}
}
reader.ReadEndElement();
}
public override void SetXmlInstance(object inst, XamlMember property, XData xData)
{
IXmlSerializable serializable = this.GetValue(inst, property, true) as IXmlSerializable;
if (serializable == null)
{
throw this.CreateException(System.Xaml.SR.Get("XmlDataNull", new object[] { property.Name }));
}
XmlReader xmlReader = xData.XmlReader as XmlReader;
if (xmlReader == null)
{
throw new XamlInternalException(System.Xaml.SR.Get("XmlValueNotReader", new object[] { property.Name }));
}
try
{
serializable.ReadXml(xmlReader);
}
catch (Exception exception)
{
if (CriticalExceptions.IsCriticalException(exception))
{
throw;
}
throw this.CreateException(System.Xaml.SR.Get("SetXmlInstance", new object[] { property }), exception);
}
}
/// <summary>
/// Deserialize xml file to object.
/// </summary>
/// <param name="obj">The object implements IXmlSerializable.</param>
/// <param name="fileName">The name of file used to stored object.</param>
public static void Deserialize(IXmlSerializable obj, string fileName)
{
if (!File.Exists(fileName))
{
return;
}
FileStream fs = null;
XmlReader reader = null;
try {
fs = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read);
reader = new XmlTextReader(fs);
obj.ReadXml(reader);
}
catch {
}
finally {
//Throw
if (fs != null)
{
fs.Close();
}
}
}
public static void ReadElement(XmlReader reader, string localName, IXmlSerializable instance)
{
if (reader.IsStartElement(localName))
{
instance.ReadXml(reader);
}
}
internal static object ReadIXmlSerializable(XmlSerializableReader xmlSerializableReader, XmlReaderDelegator xmlReader, XmlDataContract xmlDataContract, bool isMemberType)
{
object obj = null;
xmlSerializableReader.BeginRead(xmlReader);
if (isMemberType && !xmlDataContract.HasRoot)
{
xmlReader.Read();
xmlReader.MoveToContent();
}
if (xmlDataContract.UnderlyingType == Globals.TypeOfXmlElement)
{
if (!xmlReader.IsStartElement())
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateUnexpectedStateException(XmlNodeType.Element, xmlReader));
}
XmlDocument xmlDoc = new XmlDocument();
obj = (XmlElement)xmlDoc.ReadNode(xmlSerializableReader);
}
else if (xmlDataContract.UnderlyingType == Globals.TypeOfXmlNodeArray)
{
obj = XmlSerializableServices.ReadNodes(xmlSerializableReader);
}
else
{
IXmlSerializable xmlSerializable = xmlDataContract.CreateXmlSerializableDelegate();
xmlSerializable.ReadXml(xmlSerializableReader);
obj = xmlSerializable;
}
xmlSerializableReader.EndRead();
return(obj);
}
public void ReadXmlTest()
{
var recentFileList = new RecentFileList();
IXmlSerializable serializable = recentFileList;
serializable.ReadXml(null);
}
public void ReadXml(XmlReader reader)
{
if (reader.IsEmptyElement)
{
reader.Read();
return;
}
reader.ReadStartElement();
while (reader.NodeType != XmlNodeType.EndElement)
{
string type = reader.GetAttribute("type");
SaveValue saveValue = SaveValue.Instantiate(type);
IXmlSerializable xmlSerializable = saveValue as IXmlSerializable;
if (xmlSerializable != null)
{
xmlSerializable.ReadXml(reader);
_items.Add(saveValue);
}
}
reader.ReadEndElement();
}
// SetXmlInstance: receives the value as "object" so the calling code doesn't
// need to load System.Xml.dll types to make the call.
public override void SetXmlInstance(object inst, XamlMember property, XAML3.XData xData)
{
object propInstance = GetValue(inst, property, true);
IXmlSerializable iXmlSerial = propInstance as IXmlSerializable;
if (iXmlSerial == null)
{
throw CreateException((SR.Get(SRID.XmlDataNull, property.Name)));
}
XmlReader reader = xData.XmlReader as XmlReader;
if (reader == null)
{
throw new XamlInternalException(SR.Get(SRID.XmlValueNotReader, property.Name));
}
try
{
iXmlSerial.ReadXml(reader);
}
catch (Exception e)
{
if (CriticalExceptions.IsCriticalException(e))
{
throw;
}
throw CreateException(SR.Get(SRID.SetXmlInstance, property), e);
}
}
private static void SetXmlContent(IXmlSerializable serializable, string content)
{
if (content == null)
{
content = string.Empty;
}
serializable.ReadXml(XmlReader.Create(new StringReader(content)));
}
/// <summary>
/// Reads a library subset description object from an XML fragment.
/// </summary>
/// <param name="fragment">The XML reader containing the fragment to read.</param>
/// <returns>The parsed LSLLibrarySubsetDescription object.</returns>
public static LSLLibrarySubsetDescription FromXmlFragment(XmlReader fragment)
{
var ev = new LSLLibrarySubsetDescription();
IXmlSerializable x = ev;
x.ReadXml(fragment);
return(ev);
}
private static void ReadXmlSerializable(DataTable dt, XmlReader xr)
{
XmlSerializer serializer = new XmlSerializer(dt.GetType());
IXmlSerializable idt = dt;
idt.ReadXml(xr);
xr.Close();
}
public void ReadXmlTest_Precondition()
{
var recentFile = new RecentFile("Doc1");
IXmlSerializable serializable = recentFile;
serializable.ReadXml(null);
}
/// <summary>
/// Loads the specified settings file and deserializes values. It uses the existing
/// settings to figure out the type to convert the strings to.
/// </summary>
/// <param name="filename">XmlNotepad settings xml file.</param>
public void Load(string filename)
{
// we don't use the serializer because it's too slow to fire up.
XmlTextReader r = null;
try
{
r = new XmlTextReader(filename);
if (r.IsStartElement("Settings"))
{
while (r.Read())
{
if (r.NodeType == XmlNodeType.Element)
{
string name = r.Name;
object o = map[name];
if (o != null)
{
object value = null;
if (o is Hashtable)
{
ReadHashTable(r, (Hashtable)o);
}
else if (o is Array)
{
value = ReadArray(name, (Array)o, r);
}
else if (o is IXmlSerializable)
{
IXmlSerializable xs = (IXmlSerializable)o;
xs.ReadXml(r);
}
else
{
string s = r.ReadString();
value = ConvertToType(s, o.GetType());
}
if (value != null)
{
this[name] = value;
}
}
OnChanged(name);
}
}
}
}
catch (Exception)
{
// Hey, at least we tried!
}
finally
{
using (r) {}
}
this.FileName = filename;
}
/// <summary>
/// Loads the specified settings file and deserializes values. It uses the existing
/// settings to figure out the type to convert the strings to.
/// </summary>
/// <param name="filename">XmlNotepad settings xml file.</param>
public void Load(string filename)
{
pfn = new PersistentFileNames(Settings.Instance.StartupPath);
// we don't use the serializer because it's too slow to fire up.
try
{
using (var r = new XmlTextReader(filename))
{
if (r.IsStartElement("Settings"))
{
while (r.Read())
{
if (r.NodeType == XmlNodeType.Element)
{
string name = r.Name;
object o = map[name];
if (o != null)
{
object value = null;
if (o is Hashtable)
{
ReadHashTable(r, (Hashtable)o);
}
else if (o is Array)
{
value = ReadArray(name, (Array)o, r);
}
else if (o is IXmlSerializable)
{
IXmlSerializable xs = (IXmlSerializable)o;
xs.ReadXml(r);
}
else
{
string s = r.ReadString();
value = ConvertToType(s, o.GetType());
}
if (value != null)
{
this[name] = value;
}
}
OnChanged(name);
}
}
}
}
}
catch (Exception ex)
{
// Hey, at least we tried!
Debug.WriteLine("Load settings failed: " + ex.Message);
}
this.FileName = filename;
}
private void ReadConfig(string key, Type type, string configXml)
{
XmlReaderSettings settings = new XmlReaderSettings()
{
ConformanceLevel = ConformanceLevel.Fragment,
IgnoreProcessingInstructions = false,
};
using (StringReader sr = new StringReader(configXml))
using (XmlReader reader = XmlReader.Create(sr, settings))
{
reader.MoveToContent();
if (typeof(IXmlSerializable).IsAssignableFrom(type) == true)
{
IXmlSerializable serializer = null;
if (this.ContainsKey(key) == true)
{
serializer = this[key] as IXmlSerializable;
serializer.ReadXml(reader);
}
else
{
serializer = Activator.CreateInstance(type) as IXmlSerializable;
serializer.ReadXml(reader);
this.Add(key, serializer);
}
}
else
{
if (this.ContainsKey(key) == true)
{
var serializer = XmlSerializer.FromTypes(new Type[] { type, })[0];
this[key] = serializer.Deserialize(reader);
}
else
{
var serializer = XmlSerializer.FromTypes(new Type[] { type, })[0];
this.Add(key, serializer.Deserialize(reader));
}
}
}
}
public static void Deserialize(string xml, IXmlSerializable serializable, XmlReaderSettings settings)
{
TextReader textReader = new StringReader(xml);
using (XmlReader reader = XmlReader.Create(textReader, settings, CreateParserContext()))
{
reader.MoveToContent();
serializable.ReadXml(reader);
}
}
private object ReadSpecialContent(object obj)
{
IXmlSerializable xmlSerializable = (IXmlSerializable)obj;
if (xmlSerializable != null)
{
xmlSerializable.ReadXml(this.m_reader);
}
return(obj);
}
public override object Deserialize(XElement node, Type type, RoyalXmlSerializer serializer)
{
IXmlSerializable toReturn = (IXmlSerializable)Activator.CreateInstance(type);
using (XmlReader reader = node.CreateReader())
{
toReturn.ReadXml(reader);
return(toReturn);
}
}
protected void DeserializeSelf(IXmlSerializable xmlSer, XmlElement element)
{
// the object can deserialize itself
StringReader sr = new StringReader(element.InnerXml);
XmlReader rd = XmlReader.Create(sr);
xmlSer.ReadXml(rd);
rd.Close();
sr.Close();
}
public static void Deserialize(IXmlSerializable readingObject, string serializedObject)
{
TextReader textReader = new StringReader(serializedObject);
var settings = new XmlReaderSettings();
settings.IgnoreWhitespace = true;
using (var xmlReader = XmlReader.Create(textReader, settings)) {
readingObject.ReadXml(xmlReader);
}
}
// Token: 0x06007BB0 RID: 31664 RVA: 0x0022BD9C File Offset: 0x00229F9C
public object Deserialize(XmlReader reader)
{
Invariant.Assert(reader != null);
IXmlSerializable xmlSerializable = (IXmlSerializable)this._ctor.Invoke(new object[0]);
if (reader.ReadState == ReadState.Initial)
{
reader.Read();
}
xmlSerializable.ReadXml(reader);
return(xmlSerializable);
}
public override object ConvertXmlToObject(string s)
{
SqlString str2 = new SqlString();
StringReader input = new StringReader("<col>" + s + "</col>");
IXmlSerializable serializable = str2;
using (XmlTextReader reader = new XmlTextReader(input))
{
serializable.ReadXml(reader);
}
return(new SqlChars((SqlString)serializable));
}
public override object ConvertXmlToObject(string s)
{
SqlDateTime time = new SqlDateTime();
StringReader input = new StringReader("<col>" + s + "</col>");
IXmlSerializable serializable = time;
using (XmlTextReader reader = new XmlTextReader(input))
{
serializable.ReadXml(reader);
}
return((SqlDateTime)serializable);
}
public override object ConvertXmlToObject(string s)
{
SqlGuid guid = new SqlGuid();
StringReader input = new StringReader("<col>" + s + "</col>");
IXmlSerializable serializable = guid;
using (XmlTextReader reader = new XmlTextReader(input))
{
serializable.ReadXml(reader);
}
return((SqlGuid)serializable);
}
public override object ConvertXmlToObject(string s)
{
SqlBoolean flag = new SqlBoolean();
StringReader input = new StringReader("<col>" + s + "</col>");
IXmlSerializable serializable = flag;
using (XmlTextReader reader = new XmlTextReader(input))
{
serializable.ReadXml(reader);
}
return((SqlBoolean)serializable);
}
protected IXmlSerializable ReadSerializable(IXmlSerializable serializable, bool wrappedAny)
{
string localName = null;
string namespaceURI = null;
if (wrappedAny)
{
localName = this.r.LocalName;
namespaceURI = this.r.NamespaceURI;
this.r.Read();
this.r.MoveToContent();
}
serializable.ReadXml(this.r);
if (wrappedAny)
{
while (this.r.NodeType == XmlNodeType.Whitespace)
{
this.r.Skip();
}
if (this.r.NodeType == XmlNodeType.None)
{
this.r.Skip();
}
if (((this.r.NodeType == XmlNodeType.EndElement) && (this.r.LocalName == localName)) && (this.r.NamespaceURI == namespaceURI))
{
this.Reader.Read();
}
}
return serializable;
}
/// <include file='doc\XmlSerializationReader.uex' path='docs/doc[@for="XmlSerializationReader.ReadSerializable"]/*' />
protected IXmlSerializable ReadSerializable(IXmlSerializable serializable, bool wrappedAny)
{
string name = null;
string ns = null;
if (wrappedAny) {
name = r.LocalName;
ns = r.NamespaceURI;
r.Read();
r.MoveToContent();
}
serializable.ReadXml(r);
if (wrappedAny) {
while (r.NodeType == XmlNodeType.Whitespace) r.Skip();
if (r.NodeType == XmlNodeType.None) r.Skip();
if (r.NodeType == XmlNodeType.EndElement && r.LocalName == name && r.NamespaceURI == ns) {
Reader.Read();
}
}
return serializable;
}
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;
}
protected IXmlSerializable ReadSerializable (IXmlSerializable serializable)
{
if (ReadNull ()) return null;
int depth = reader.Depth;
readCount++;
serializable.ReadXml (reader);
Reader.MoveToContent ();
while (reader.Depth > depth)
reader.Skip ();
if (reader.Depth == depth && reader.NodeType == XmlNodeType.EndElement)
reader.ReadEndElement ();
return serializable;
}
/// <include file='doc\XmlSerializationReader.uex' path='docs/doc[@for="XmlSerializationReader.ReadSerializable"]/*' />
protected IXmlSerializable ReadSerializable(IXmlSerializable serializable) {
serializable.ReadXml(r);
return serializable;
}