Nadpisywanie deserializacji XML w celu korzystania z deserializacji podstawowej i dodawania funkcjonalności

Question

Mam klasę, która powinna zostać przekształcona do postaci szeregowej i ponownie sformatowana.

Ale za każdym razem po dewastyzacji muszę wywołać metodę synchronizowania odniesień.

W każdym razie mogę przeprowadzić deserializację i użyć tradycyjnej deserializacji, ale dodać wywołanie do mojej metody po regularnej deserializacji?

Answer 1

using System.Xml.Serialization; 

namespace Custom.Xml.Serialization 
{ 
    public interface IXmlDeserializationCallback 
    { 
     void OnXmlDeserialization(object sender); 
    } 

    public class CustomXmlSerializer : XmlSerializer 
    { 
     protected override object Deserialize(XmlSerializationReader reader) 
     { 
      var result = base.Deserialize(reader); 

      var deserializedCallback = result as IXmlDeserializationCallback; 
      if (deserializedCallback != null) 
      { 
       deserializedCallback.OnXmlDeserialization(this); 
      } 

      return result; 
     } 
    } 
} 

dziedziczy swoją klasę od IXmlDeserializationCallback i implementuje logikę synchronizacji w metodzie OnXmlDeserialization.

kredyty do How do you find out when you've been loaded via XML Serialization?

UPDATE:

dobrze, o ile mi zrozumieć topicstarter, on nie chce się "ręcznie" nazywamy jakąś logikę po każdym deserializacji XML. Zamiast tego:

public class MyEntity 
{ 
    public string SomeData { get; set; } 

    public void FixReferences() 
    { 
      // call after deserialization 
      // ... 
    } 
} 

foreach (var xmlData in xmlArray) 
{ 
    var xmlSer = new XmlSerializer(typeof(MyEntity)); 
    using (var memStream = new MemoryStream(Encoding.UTF8.GetBytes(xmlData))) 
    { 
     var entity = (MyEntity)xmlSer.Deserialize(memStream); 
     entity.FixReferences(); 

     // do something else with the entity 
     // ... 
    } 
} 

chce zrobić tylko deserializację, nie martwiąc się o dodatkowe połączenia. W tym przypadku, proponowane rozwiązanie jest najczystszym/najprostszy - trzeba tylko dziedziczą swoją klasę podmiot z interfejsem IXmlDeserializationCallback i zastąpić XmlSerializer z CustomXmlSerializer:

public class MyEntity: IXmlDeserializationCallback 
    { 
     public string SomeData { get; set; } 

     private void FixReferences() 
     { 
       // call after deserialization 
       // ... 
     } 

     public void OnXmlDeserialization(object sender) 
     { 
      FixReferences(); 
     } 
    } 

    foreach (var xmlData in xmlArray) 
    { 
     var xmlSer = new CustomXmlSerializer(typeof(MyEntity)); 
     using (var memStream = new MemoryStream(Encoding.UTF8.GetBytes(xmlData))) 
     { 
      var entity = (MyEntity)xmlSer.Deserialize(memStream); 
      // entity.FixReferences(); - will be called automatically 

      // do something else with the entity 
      // ... 
     } 
    } 

Answer 2

Twoje opcje wykorzystujące XmlSerializer są ograniczone.

• Oddestrykuj cały wykres obiektu, a następnie zastosuj dowolne wymagane poprawki.
• Wykonaj pewne przetwarzanie w ustawieniach właściwości obiektu.
• Wykonaj IXmlSerializable na swoich typach, aby mieć wyraźną kontrolę nad serializacją/deserializacją. Nie jest to łatwa opcja.

Jeśli można zmienić za pomocą DataContractSerializer, który ma swoje wady i advantanges(), a następnie można użyć OnDeserializedAttribute. Na przykład

[DataContract] 
public class MyClass 
{ 
    [DataMember] 
    public string AMember{get;set;} 

    [OnDeserialized] 
    public void OnDeserialized(StreamingContext context) 
    { 
     // called after deserializing instance of MyClass 
    } 
} 

Answer 3

Mam ładne rozwiązanie 4 u

napisać to statyczna klasa

public delegate void OnDeserializedEventArgs(object itemDeserialized, string xmlSource); 
public delegate void OnDeserializedFailedEventArgs(string xmlSource); 
public static class SerializationServices 
{ 
    public static event OnDeserializedEventArgs OnDeserializedEvent; 
    public static event OnDeserializedFailedEventArgs OnDeserializedFailedEvent; 

    public static T Deserialize<T>(this string item) where T : class 
    { 
     XmlSerializer ser = new XmlSerializer(item.GetType()); 
     StringReader sr = new StringReader(item); 
     var obj = ser.Deserialize(sr); 

     if (obj is T) 
     { 
      if (OnDeserializedEvent != null) 
       OnDeserializedEvent(obj, item); 

      return obj as T; 
     } 

     if (OnDeserializedFailedEvent != null) 
      OnDeserializedFailedEvent(item); 

     //callback - invalid event 
     return null; 
    } 
} 

a następnie używać go z tym kodem

public class MyDesrializedClass 
{ 
    //put some properties here... 
} 
class Program 
{ 
    static void Main(string[] args) 
    { 
     SerializationServices.OnDeserializedEvent += SerializationServices_OnDeserializedEvent; 
     SerializationServices.OnDeserializedFailedEvent += SerializationServices_OnDeserializedFailedEvent; 

     string someXml = string.Empty; //replace this with something... 
     MyDesrializedClass deserializedClass = someXml.Deserialize<MyDesrializedClass>(); 
    } 

    private static void SerializationServices_OnDeserializedFailedEvent(string xmlSource) 
    { 
     //will get here before 'deserializedClass' will get it's results 
    } 

    private static void SerializationServices_OnDeserializedEvent(object itemDeserialized, string xmlSource) 
    { 
     //will get here before 'deserializedClass' will get it's results 
    } 
} 

jeśli u wklej te kod do różnych przestrzeni nazw nie zapomnij dodać "używając ...", inaczej nie zobaczymy metody deserializacji w programie contex t

Tzahi