private T StrictDeserialize(Func <Object> block)
{
errors = new List <string> ();
var Node = new XmlNodeEventHandler(serializer_UnknownNode);
var Attr = new XmlAttributeEventHandler(serializer_UnknownAttribute);
var Element = new XmlElementEventHandler(serializer_UnknownElement);
serializer.UnknownNode += Node;
serializer.UnknownAttribute += Attr;
serializer.UnknownElement += Element;
T result;
try {
result = (T)block();
} finally {
serializer.UnknownNode -= Node;
serializer.UnknownAttribute -= Attr;
serializer.UnknownElement -= Element;
}
if (errors.Count > 0)
{
throw new System.Exception("XML for " + typeof(T) + " has invalid format:\n" + string.Join("\n", errors.ToArray()));
}
return(result);
}
public object Deserialize(string sourceFile, Type type, XmlElementEventHandler unknownElementHandler,
bool deleteAfterDeserialization)
{
try
{
object result;
using (var fileStream = new StreamReader(sourceFile))
{
result = Deserialize(fileStream, type, unknownElementHandler, deleteAfterDeserialization);
}
if (deleteAfterDeserialization)
{
File.Delete(sourceFile);
}
return(result);
}
catch (Exception ex)
{
var exceptionMessage = ExceptionUtils.GetDeepExceptionMessageOnly(ex);
if (exceptionMessage.IndexOf("invalid character", StringComparison.OrdinalIgnoreCase) >= 0)
{
return(DeserializeSanitized(sourceFile, type, unknownElementHandler, deleteAfterDeserialization));
}
else
{
throw;
}
}
}
public static object InnerFromXml(string xml, Type type,
XmlNodeEventHandler UnknownNode, XmlElementEventHandler UnknownElement, XmlAttributeEventHandler UnknownAttribute,
UnreferencedObjectEventHandler UnreferencedObject)
{
if (string.IsNullOrEmpty(xml))
{
return(null);
}
if (null == type)
{
return(null);
}
XmlSerializer xmlSerializer = new XmlSerializer(type);
if (UnknownNode != null)
{
xmlSerializer.UnknownNode += UnknownNode;
}
if (UnknownAttribute != null)
{
xmlSerializer.UnknownAttribute += UnknownAttribute;
}
if (UnknownElement != null)
{
xmlSerializer.UnknownElement += UnknownElement;
}
//WriteStringToFile(xml, "synchroon-vanuit-PowerForms.xml");
using (TextReader r = new StringReader(xml))
{
object result = xmlSerializer.Deserialize(r);
return(result);
}
}
public static T FromXml <T>(string xml,
XmlNodeEventHandler UnknownNode, XmlElementEventHandler UnknownElement, XmlAttributeEventHandler UnknownAttribute,
UnreferencedObjectEventHandler UnreferencedObject)
{
T result = (T)FromXml(xml, typeof(T), UnknownNode, UnknownElement, UnknownAttribute, UnreferencedObject);
return(result);
}
/// <summary>
/// Extends BeginInvoke so that when a state object is not needed, null does not need to be passed.
/// <example>
/// xmlelementeventhandler.BeginInvoke(sender, e, callback);
/// </example>
/// </summary>
public static IAsyncResult BeginInvoke(this XmlElementEventHandler xmlelementeventhandler, Object sender, XmlElementEventArgs e, AsyncCallback callback)
{
if (xmlelementeventhandler == null)
{
throw new ArgumentNullException("xmlelementeventhandler");
}
return(xmlelementeventhandler.BeginInvoke(sender, e, callback, null));
}
public object Deserialize(StreamReader fileStream, Type type, XmlElementEventHandler unknownElementHandler,
bool deleteAfterDeserialization)
{
XmlSerializer serializer = new XmlSerializer(type);
serializer.UnknownElement += new XmlElementEventHandler(DefaultUnknownElementHandler);
if (unknownElementHandler != null)
{
serializer.UnknownElement += unknownElementHandler;
}
using (XmlReader reader = XmlReader.Create(fileStream))
{
return(serializer.Deserialize(reader));
}
}
/// <summary>
/// Deserialize
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="xml"></param>
/// <param name="unknownElementHandler"></param>
/// <returns></returns>
public object Deserialize(XmlElement element, Type elementType, XmlElementEventHandler unknownElementHandler)
{
XmlSerializer serializer = new XmlSerializer(elementType);
serializer.UnknownElement += new XmlElementEventHandler(DefaultUnknownElementHandler);
if (unknownElementHandler != null)
{
serializer.UnknownElement += unknownElementHandler;
}
using (XmlNodeReader reader = new XmlNodeReader(element))
{
return(serializer.Deserialize(reader));
}
}
private static object FromXml(string xml, Type type,
XmlNodeEventHandler UnknownNode, XmlElementEventHandler UnknownElement, XmlAttributeEventHandler UnknownAttribute,
UnreferencedObjectEventHandler UnreferencedObject)
{
if (null == type)
{
return(null);
}
try
{
return(InnerFromXmlProvider.InnerFromXml(xml, type, UnknownNode, UnknownElement, UnknownAttribute, UnreferencedObject));
}
catch (Exception)
{
return(InnerFromXmlProvider.InnerFromXml(xml, type, UnknownNode, UnknownElement, UnknownAttribute, UnreferencedObject));
}
}
public object DeserializeSanitized(string sourceFile, Type type, XmlElementEventHandler unknownElementHandler,
bool deleteAfterDeserialization)
{
object result;
using (var fileStream = File.OpenRead(sourceFile))
{
using (var sanitizedStream = new XmlSanitizingStream(fileStream))
{
result = Deserialize(sanitizedStream, type, unknownElementHandler, deleteAfterDeserialization);
}
}
if (deleteAfterDeserialization)
{
File.Delete(sourceFile);
}
return(result);
}
public T Deserialize <T>(byte[] bytes, XmlElementEventHandler unknownElementHandler, XmlAttributeEventHandler unknownAttributeHandler)
{
XmlSerializer serializer = new XmlSerializer(typeof(T));
serializer.UnknownElement += new XmlElementEventHandler(DefaultUnknownElementHandler);
if (unknownElementHandler != null)
{
serializer.UnknownElement += unknownElementHandler;
}
if (unknownAttributeHandler != null)
{
serializer.UnknownAttribute += unknownAttributeHandler;
}
using (XmlReader reader = XmlReader.Create(new MemoryStream(bytes)))
{
return((T)serializer.Deserialize(reader));
}
}
internal void ReadHeaders(XmlReader reader, XmlSerializer serializer, SoapHeaderCollection headers, SoapHeaderMapping[] mappings, SoapHeaderDirection direction, string envelopeNs, string encodingStyle)
{
reader.MoveToContent();
if (!reader.IsStartElement(Soap.Header, envelopeNs))
{
return;
}
if (reader.IsEmptyElement)
{
reader.Skip(); return;
}
this.unknownHeaders = new SoapHeaderCollection();
this.unreferencedHeaders = new SoapHeaderCollection();
// thread hash code is used to differentiate between deserializations in event callbacks
this.currentThread = Thread.CurrentThread.GetHashCode();
this.envelopeNs = envelopeNs;
XmlElementEventHandler unknownHandler = new XmlElementEventHandler(this.OnUnknownElement);
UnreferencedObjectEventHandler unreferencedHandler = new UnreferencedObjectEventHandler(this.OnUnreferencedObject);
serializer.UnknownElement += unknownHandler;
serializer.UnreferencedObject += unreferencedHandler;
reader.ReadStartElement();
reader.MoveToContent();
// SOAP12: not using encodingStyle
//object[] headerValues = (object[])serializer.Deserialize(reader, encodingStyle);
object[] headerValues = (object[])serializer.Deserialize(reader);
for (int i = 0; i < headerValues.Length; i++)
{
if (headerValues[i] != null)
{
SoapHeader header = (SoapHeader)headerValues[i];
header.DidUnderstand = true;
headers.Add(header);
}
}
serializer.UnknownElement -= unknownHandler;
serializer.UnreferencedObject -= unreferencedHandler;
this.currentThread = 0;
this.envelopeNs = null;
foreach (SoapHeader header in this.unreferencedHeaders)
{
headers.Add(header);
}
this.unreferencedHeaders = null;
foreach (SoapHeader header in this.unknownHeaders)
{
headers.Add(header);
}
this.unknownHeaders = null;
while (reader.NodeType == XmlNodeType.Whitespace)
{
reader.Skip();
}
if (reader.NodeType == XmlNodeType.None)
{
reader.Skip();
}
else
{
reader.ReadEndElement();
}
}
public T Deserialize <T>(string xml, XmlElementEventHandler unknownElementHandler, XmlAttributeEventHandler unknownAttributeHandler)
{
return(Deserialize <T>(StringUtils.UTF8.GetBytes(xml), unknownElementHandler, unknownAttributeHandler));
}
public T DeserializeFromBase64String <T>(string text, XmlElementEventHandler unknownElementHandler)
{
return(Deserialize <T>(Convert.FromBase64String(text), unknownElementHandler));
}
/// <summary>
///
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="sourceFile"></param>
/// <param name="unknownElementHandler"></param>
/// <param name="deleteAfterDeserialization"></param>
/// <returns></returns>
public T Deserialize <T>(string sourceFile, XmlElementEventHandler unknownElementHandler,
bool deleteAfterDeserialization)
{
return((T)Deserialize(sourceFile, typeof(T), unknownElementHandler, deleteAfterDeserialization));
}
/// <summary>
/// Deserialize
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="xml"></param>
/// <param name="unknownElementHandler"></param>
/// <returns></returns>
public T Deserialize <T>(XmlElement element, XmlElementEventHandler unknownElementHandler)
{
return((T)Deserialize(element, typeof(T), unknownElementHandler));
}
/// <summary>
/// Deserialize
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="xml"></param>
/// <param name="unknownElementHandler"></param>
/// <returns></returns>
public T Deserialize <T>(byte[] bytes, XmlElementEventHandler unknownElementHandler)
{
return(Deserialize <T>(bytes, unknownElementHandler, null));
}
