Kann ich eine benutzerdefinierte Serialisierung für XmlSerializer bereitstellen, ohne IXmlSerializable zu implementieren?

Question

Wir verwenden XmlSerializer, und ich möchte benutzerdefinierte Serialisierung für bestimmte Klassen bereitstellen. Ich habe jedoch nicht immer die Möglichkeit, den Quellcode der betreffenden Klasse zu ändern, sonst könnte ich es einfach implementieren IXmlSerializable. Gibt es eine Möglichkeit, dies zu tun?

Answer 1

Hier ist ein einfaches Beispiel für die Proxy-deserialize Helfer:

eine Art gegeben, die wir nicht direkt Serialisierung auf Klassenebene steuern:

public sealed class Class //contrived example 
{ 
    public string Property {get;set;} 
} 

Und die xml wir mit deserialisieren müssen:

<Class> 
    <Property>Value</Property> 
</Class> 

Sie könnten einen Proxy-Typ manuell erstellen die Deserialisierung des Zieltyps zu verarbeiten wie so:

[XmlRoot("Class")] // <-- Very important 
public sealed class ClassSerializerProxy : IXmlSerializable 
{ 
    public Class ClassValue {get;set;} 

    public System.Xml.Schema.XmlSchema GetSchema(){return null;} 
    public void WriteXml(System.Xml.XmlWriter writer){} 

    public void ReadXml(System.Xml.XmlReader reader) 
    { 
     var x = XElement.ReadFrom(reader) as XElement; 
     this.ClassValue = new Class(); 
     //again this is a simple contrived example 
     this.ClassValue.Property = x.XPathSelectElement("Property").Value; 
    } 
} 

Verbrauch ist:

void Main() 
{ 
    // get the xml value somehow 
    var xdoc= XDocument.Parse(@"<Class><Property>Value</Property></Class>"); 

    // deserialize the xml into the proxy type 
    var proxy = Deserialize<ClassSerializerProxy>(xdoc); 

    // read the resulting value 
    var value = proxy.ClassValue; 
} 

public object Deserialize(XDocument xmlDocument, Type DeserializeToType) 
{ 
    XmlSerializer xmlSerializer = new XmlSerializer(DeserializeToType); 
    using (XmlReader reader = xmlDocument.CreateReader()) 
     return xmlSerializer.Deserialize(reader); 
} 

Jetzt in einigen Generika werfen und eine Erweiterungsmethode, und wir können für eine endgültige (AUSSER EXCEPTION HANDLING) Version Aufrufort up ein wenig reinigen:

Verbrauch:

void Main() 
{ 
    var xml = @"<Class><Property>Value</Property></Class>"; 

    var value = xml.DeserializeWithProxy<ClassSerializerProxy,Class>(); 

    value.Dump(); 
} 

Ihre Instance-Typ:

public sealed class Class 
{ 
    public string Property {get;set;} 
} 

Eine Schnittstelle, die Proxy-Typ

public interface ISerializerProxy<TInstanceType> where TInstanceType : class 
{ 
    TInstanceType Value { get; } 
} 

Das Beispiel Proxy implementiert nun die neue Schnittstelle

[XmlRoot("Class")] 
public sealed class ClassSerializerProxy : IXmlSerializable, ISerializerProxy<Class> 
{ 
    public Class Value {get;set;} 

    public System.Xml.Schema.XmlSchema GetSchema(){return null;} 
    public void WriteXml(System.Xml.XmlWriter writer){} 

    public void ReadXml(System.Xml.XmlReader reader) 
    { 
     var x = XElement.ReadFrom(reader) as XElement; 
     this.Value = new Class(); 
     this.Value.Property = x.XPathSelectElement("Property").Value; 
    } 
} 

Die Deserialisierung Methode ist jetzt eine Erweiterungsmethode auf string und kann mit jedem Proxy implementieren muss verwendet werden, Art.

public static class ExtensionMethods 
{ 
    public static TInstanceType DeserializeWithProxy<TProxyType,TInstanceType>(this string xml) 
     where TProxyType : ISerializerProxy<TInstanceType> 
     where TInstanceType : class 
    { 
     using (XmlReader reader = XDocument.Parse(xml).CreateReader()) 
     { 
      var xmlSerializer = new XmlSerializer(typeof(TProxyType)); 
      return (xmlSerializer.Deserialize(reader) as ISerializerProxy<TInstanceType>).Value; 
     } 
    } 
}