wie Ausnahmeobjekt als XML-String serialise

Question

möchte ich so etwas wie

try 
{ 
    //code here 
} 
catch (Exception ex) 
    { 
    stringXML = Exception.toXML(); 
    } 

so dass der Wert von stringXML

<exception><message></message><innerException></innerException></exception> 

Zum Beispiel wäre ...

Wie ist das möglich ?

Answer 1

Es hängt davon ab, wie viel Code Sie schreiben möchten. Ein einfacher Ansatz wäre Ihr eigenes Objekt zu schreiben und verwenden XmlSerializer:

[XmlRoot("exception"), XmLType("exception")] 
public class SerializableException { 
    [XmlElement("message")] 
    public string Message {get;set;} 

    [XmlElement("innerException")] 
    public SerializableException InnerException {get;set;} 
} 

und nur eine regelmäßige Ausnahme in diese Karte. Da es aber trotzdem einfach ist, vielleicht ist XmlWriter gut genug ...

public static string GetXmlString(this Exception exception) 
{ 
    if (exception == null) throw new ArgumentNullException("exception"); 
    StringWriter sw = new StringWriter(); 
    using (XmlWriter xw = XmlWriter.Create(sw)) 
    { 
     WriteException(xw, "exception", exception); 
    } 
    return sw.ToString(); 
} 
static void WriteException(XmlWriter writer, string name, Exception exception) 
{ 
    if (exception == null) return; 
    writer.WriteStartElement(name); 
    writer.WriteElementString("message", exception.Message); 
    writer.WriteElementString("source", exception.Source); 
    WriteException(writer, "innerException", exception.InnerException); 
    writer.WriteEndElement(); 
} 

Answer 2

Jemand hat bereits wrote a blog entry about it

using System; 
using System.Collections; 
using System.Linq; 
using System.Xml.Linq; 

/// <summary>Represent an Exception as XML data.</summary> 
public class ExceptionXElement : XElement 
{ 
    /// <summary>Create an instance of ExceptionXElement.</summary> 
    /// <param name="exception">The Exception to serialize.</param> 
    public ExceptionXElement(Exception exception) 
     : this(exception, false) 
    { } 

    /// <summary>Create an instance of ExceptionXElement.</summary> 
    /// <param name="exception">The Exception to serialize.</param> 
    /// <param name="omitStackTrace"> 
    /// Whether or not to serialize the Exception.StackTrace member 
    /// if it's not null. 
    /// </param> 
    public ExceptionXElement(Exception exception, bool omitStackTrace) 
     : base(new Func<XElement>(() => 
     { 
      // Validate arguments 

      if (exception == null) 
      { 
       throw new ArgumentNullException("exception"); 
      } 

      // The root element is the Exception's type 

      XElement root = new XElement 
       (exception.GetType().ToString()); 

      if (exception.Message != null) 
      { 
       root.Add(new XElement("Message", exception.Message)); 
      } 

      // StackTrace can be null, e.g.: 
      // new ExceptionAsXml(new Exception()) 

      if (!omitStackTrace && exception.StackTrace != null) 
      { 
       root.Add 
       ( 
        new XElement("StackTrace", 
         from frame in exception.StackTrace.Split('\n') 
         let prettierFrame = frame.Substring(6).Trim() 
         select new XElement("Frame", prettierFrame)) 
       ); 
      } 

      // Data is never null; it's empty if there is no data 

      if (exception.Data.Count > 0) 
      { 
       root.Add 
       ( 
        new XElement("Data", 
         from entry in 
          exception.Data.Cast<DictionaryEntry>() 
         let key = entry.Key.ToString() 
         let value = (entry.Value == null) ? 
          "null" : entry.Value.ToString() 
         select new XElement(key, value)) 
       ); 
      } 

      // Add the InnerException if it exists 

      if (exception.InnerException != null) 
      { 
       root.Add 
       ( 
        new ExceptionXElement 
         (exception.InnerException, omitStackTrace) 
       ); 
      } 

      return root; 
     })()) 
    { } 
}