带有OnDeserializing和OnDeserilized的.NET反序列化

本文关键字：NET 反序列化 OnDeserilized OnDeserializing 带有 | 更新日期: 2023-09-27 18:28:32

我使用了一个可序列化的简单类。它有一个用于反序列化的构造函数：

protected MyClass(SerializationInfo info, StreamingContext context)

以及用于串行化的GetObjectData方法。它运行良好。

现在我添加了两种方法来监控去序列化：

        [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());
    }

我想知道这些方法的调用顺序。现在，在调用构造函数之前，两个方法都会被调用。这怎么可能呢？为什么在调用（反序列化-）构造函数之后不调用"OnDeserialized"方法？在执行任何构造函数之前，如何调用（非静态）方法？（我使用的是BinaryFormatter）

带有OnDeserializing和OnDeserilized的.NET反序列化

现在，在构造函数被调用之前，两个方法都被调用了

不，订单是：

  • OnDeserializingMethod
  • .ctor
  • OnDeserializedMethod

在执行任何构造函数之前，如何调用（非静态）方法？

因为它欺骗和撒谎；它不使用构造函数创建对象；不——真的。它使用FormatterServices.GetUninitializedObject来分配普通的空空间。然后，如果有一个自定义的反序列化构造函数，它会在该对象的顶部调用构造函数。肮脏的基本上是这样的：

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]);

IMO他们可能应该将其作为ISerializable接口上的第二种方法，但无论出于什么原因：他们没有。真的很遗憾：这会让它更诚实，并避免人们需要记住实现自定义构造函数。

示例输出：

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

示例代码：

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");
        }
    }
}

调用的顺序取决于对象是序列化树的根还是对象的某个成员，该对象也在同一对象图中序列化。通过Marc Gravell提供的扩展示例，我得到了以下输出：

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

请注意，在反序列化中，SerMember.ctor是在SerMember.OnSerializedMethod之后调用的！这是代码：

        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"); }
}

[OnDeserializing]指示在反序列化之前要调用的方法[已反序列化]指示在反序列化之后要调用的方法

[OnDeserializing]方法充当反序列化的伪构造函数，并且它对于初始化从序列化中排除的字段很有用：

[OnDeserializing]和[OnDeselialized]反序列化绕过所有的普通构造函数以及字段初始化器。如果每个字段都参与序列化，那么这几乎没有什么影响，但它可以如果通过[NonSerialized]排除某些字段，则会出现问题。

我从Albahari的书C#5.0中摘录了这段文字，概括地说，第713页在网上查看了很多例子描述您的问题。

感谢

相关文章：