.NET Deserialisation avec OnDeserializing et OnDeserialized

J'utilise une classe simple qui est sérialisable. Il a un constructeur pour la désérialisation:

protected MyClass(SerializationInfo info, StreamingContext context)

et un GetObjectData méthode de sérialisation. Il fonctionne très bien.

Maintenant, j'ai ajouté deux méthodes de suivi de la deserialisation:

        [OnDeserializing()]
    internal void OnDeserializingMethod(StreamingContext context)
    {
        System.Diagnostics.Trace.WriteLine("OnDeserializingMethod: " + this.GetType().ToString());
    }

    [OnDeserialized()]
    internal void OnDeserializedMethod(StreamingContext context)
    {
        System.Diagnostics.Trace.WriteLine("OnDeserializedMethod: " + this.GetType().ToString());
    }

et je me demandais dans quel ordre ces méthodes sont être appelé. Maintenant, les deux méthodes appelée avant que le constructeur est appelé. Comment est-ce possible, et pourquoi n'est-elle pas la "OnDeserialized" méthode appelée ainsi d'après le (la désérialisation-) constructeur a été appelé? Et comment un (non statique) de la méthode appelée avant tout constructeur a été exécuté? (Je suis à l'aide d'un BinaryFormatter)

OriginalL'auteur Gerhard | 2013-08-22

.net c#serialization

Maintenant les deux méthodes appelée avant que le constructeur est appelé

Pas, la commande est:

OnDeserializingMethod
.ctor
OnDeserializedMethod

Et comment un (non statique) de la méthode appelée avant tout constructeur a été exécuté?

Parce qu'il triche et le mensonge; il n'a pas créer l'objet avec le constructeur; pas - vraiment. Il utilise FormatterServices.GetUninitializedObject d'allouer à la vanille vide de l'espace. Et puis si il y a une coutume de la désérialisation constructeur qu'il appelle le constructeur au-dessus de ce objet. De méchant. Comme ça, en fait:

var obj = FormatterServices.GetUninitializedObject(typeof(MyClass));
var ctor = obj.GetType().GetConstructor(
    BindingFlags.Instance | BindingFlags.Public| BindingFlags.NonPublic,
    null,
    new[] { typeof(SerializationInfo), typeof(StreamingContext) },
    null);
ctor.Invoke(obj, new object[2]);

De l'OMI, ils devraient probablement en ont fait un deuxième méthode sur la ISerializable de l'interface, mais pour quelque raison que ce soit: ils n'ont pas. Une honte vraiment: qu'il aurait été plus honnête, et d'éviter les personnes ayant besoin de se rappeler de mettre en œuvre le constructeur personnalisé.

Exemple de sortie:

.ctor: MyClass
> serializing
OnSerializingMethod: MyClass
GetObjectData: MyClass
OnSerializedMethod: MyClass
< serializing
> deserializing
OnDeserializingMethod: MyClass
.ctor: MyClass
OnDeserializedMethod: MyClass
< deserializing

Exemple de code:

using System;
using System.IO;
using System.Runtime.CompilerServices;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
[Serializable]
class MyClass : ISerializable
{
public MyClass() { Trace(); }
protected MyClass(SerializationInfo info, StreamingContext context) { Trace(); }
public void GetObjectData(SerializationInfo info, StreamingContext context) { Trace(); }
void Trace([CallerMemberName] string caller = null)
{
System.Console.WriteLine("{0}: {1}", caller, GetType().Name);
}
[OnDeserializing()]
internal void OnDeserializingMethod(StreamingContext context) { Trace(); }
[OnDeserialized()]
internal void OnDeserializedMethod(StreamingContext context) { Trace(); }
[OnSerializing()]
internal void OnSerializingMethod(StreamingContext context) { Trace(); }
[OnSerialized()]
internal void OnSerializedMethod(StreamingContext context) { Trace(); }
static void Main()
{
using (var ms = new MemoryStream())
{
var orig = new MyClass();
var ser = new BinaryFormatter();
System.Console.WriteLine("> serializing");
ser.Serialize(ms, orig);
System.Console.WriteLine("< serializing");
ms.Position = 0;
System.Console.WriteLine("> deserializing");
ser.Deserialize(ms);
System.Console.WriteLine("< deserializing");
}
}
}

ce code va appeler l'objet constuctor var ctor = obj.GetType().GetConstructor(.... Je voudrais utilisé InvokeMember pour appeler la méthode codeproject.com/Articles/19911/...
Merci, préfet réponse, je vais le marquer comme acceptée qu'après j'ai trouvé pourquoi, dans mon scénario, le ctor est appelé en dernier. Peut-être parce que l'objet n'est pas à la racine de la sérialisée de l'arbre.
OK Marc, votre réponse est correcte uniquement pour l'objet racine. Voir ma réponse ci-dessous pour des scénarios plus complexes. Aucune idée de pourquoi il se comporte comme ça? Par la route: très cool [CallerMemberName] Attribut! Je ne savais pas qu'avant (mais seulement .NET 4.5)

OriginalL'auteur Marc Gravell

L'ordre des appels dépend si l'objet est à la racine de la sérialisé arbre ou quelque membre d'un objet, qui est également publié en feuilleton dans le même objet graphique. J'obtiens le résultat suivant avec l'exemple fourni par Marc Gravel:

SerRoot.ctor
SerMember.ctor
> serializing
SerRoot.OnSerializingMethod
GetObjectData
SerMember.OnSerializingMethod
SerMember.GetObjectData
SerRoot.OnSerializedMethod
SerMember.OnSerializedMethod
< serializing
> deserializing
SerRoot.OnDeserializingMethod
SerMember.OnDeserializingMethod
SerMember.OnDeserializedMethod
SerMember.ctor(info, context)
SerRoot.ctor(info, context)
SerRoot.OnDeserializedMethod
< deserializing

Avis que, dans la désérialisation SerMember.ctor est appelée après SerMember.OnDeserializedMethod! C'est le code:

        static void Main(string[] args)
{
using (var ms = new MemoryStream())
{
var orig = new SerRoot();
var ser = new BinaryFormatter();
System.Console.WriteLine("> serializing");
ser.Serialize(ms, orig);
System.Console.WriteLine("< serializing");
ms.Position = 0;
System.Console.WriteLine("> deserializing");
ser.Deserialize(ms);
System.Console.WriteLine("< deserializing");
}
}
[Serializable]
class SerRoot : ISerializable
{
public SerMember m;
public SerRoot()
{
System.Console.WriteLine("SerRoot.ctor");
m = new SerMember();
}
protected SerRoot(SerializationInfo info, StreamingContext context)
{
System.Console.WriteLine("SerRoot.ctor(info, context)");
m = info.GetValue("m", typeof(SerMember)) as SerMember;
}
public void GetObjectData(SerializationInfo info, StreamingContext context)
{
System.Console.WriteLine("GetObjectData");
info.AddValue("m", m);
}
[OnDeserializing()]
internal void OnDeserializingMethod(StreamingContext context) { System.Console.WriteLine("SerRoot.OnDeserializingMethod"); }
[OnDeserialized()]
internal void OnDeserializedMethod(StreamingContext context) { System.Console.WriteLine("SerRoot.OnDeserializedMethod"); }
[OnSerializing()]
internal void OnSerializingMethod(StreamingContext context) { System.Console.WriteLine("SerRoot.OnSerializingMethod"); }
[OnSerialized()]
internal void OnSerializedMethod(StreamingContext context) { System.Console.WriteLine("SerRoot.OnSerializedMethod"); }
}
[Serializable]
class SerMember : ISerializable
{
string text;
public SerMember() 
{ 
System.Console.WriteLine("SerMember.ctor");
text = "test";
}
protected SerMember(SerializationInfo info, StreamingContext context) 
{
System.Console.WriteLine("SerMember.ctor(info, context)");
text = info.GetString("text");
}
public void GetObjectData(SerializationInfo info, StreamingContext context) 
{ 
System.Console.WriteLine("SerMember.GetObjectData");
info.AddValue("text", text);
}
[OnDeserializing()]
internal void OnDeserializingMethod(StreamingContext context) { System.Console.WriteLine("SerMember.OnDeserializingMethod"); }
[OnDeserialized()]
internal void OnDeserializedMethod(StreamingContext context) { System.Console.WriteLine("SerMember.OnDeserializedMethod"); }
[OnSerializing()]
internal void OnSerializingMethod(StreamingContext context) { System.Console.WriteLine("SerMember.OnSerializingMethod"); }
[OnSerialized()]
internal void OnSerializedMethod(StreamingContext context) { System.Console.WriteLine("SerMember.OnSerializedMethod"); }
}

C'est ... fascinant. Je peux voir ce que vous voyez, et je suis tenté de conclure qu'il ressemble beaucoup comme un bug... je suis d'accord l'ordre semble hors de contrôle, mais: je ne vois pas ce que ça va changé. La bonne nouvelle est que si vous mettez en œuvre IDeserializationCallback, qui est appelé à l'heure correcte.
Ce " bug " a été me causer beaucoup de chagrin. Bonne prise. @Marc: à l'Aide de IDeserializationCallback n'est pas toujours une solution. Certains sérialise ne le supporte pas car il n'est pas portable (par ex. Json.NET voir ici). Dirait qu'il y a pas de solution autre que d'éviter la ISerializable des objets au-delà de l'objet racine dans le graphique.

OriginalL'auteur Gerhard

2

[OnDeserializing]
Indique une méthode pour être appelé juste avant la désérialisation
[OnDeserialized]
Indique une méthode pour être appelé juste après la désérialisation

[OnDeserializing] méthode agit comme un pseudoconstructor pour la désérialisation, et
il est utile pour initialiser les champs exclus de la sérialisation:

[OnDeserializing] et [OnDeserialized]
La désérialisation contourne tous vos normale constructeurs sur le terrain ainsi que les initialiseurs.
C'est de peu de conséquence si tous les champs participe à la sérialisation, mais il peut être
problématique si certains domaines sont exclus par [NonSerialized].

J'ai pris ce texte de Albahari livre C# 5.0 en bref page 713 vérifier en ligne beaucoup d'exemple et
description de votre problème.

Grâce

Alors que tout ceci est vrai, il n'est pas évident pour moi qu'il répond aux questions posées
Il suffit d'invoquer la méthode désirée sur OnDeserializingMethod!

OriginalL'auteur Bassam Alugili

Vous devez vous connecter pour publier un commentaire.