.Net序列化 - 将[Serializable]与继承树中的自定义混合

Question

我正在将Java游戏转换为C＃（Puppy Games的Titan Attacks），除了上一个任务是保存文件的游戏状态序列化之外，我现在已经完成了很多工作。

典型层次结构：资源（基础） - ＆gt;功能 - ＆gt;屏幕/效果/实体 - ＆gt; GameScreen / LaserEffect / Invader

Java代码使用标准的ObjectOutputStream / ObjectInputStream来执行二进制序列化，但是在基类级别（Resource）上烦人地执行一些readResolve / writeResolve工作来自定义序列化过程（如果资源被命名，它不会序列化它并简单地返回一个名称稍后用于从hashmap中获取资源的代理。

我天真的解决方案是盲目地复制这种方法并在基类中实现ISerializable来覆盖TYPE ......

public virtual void GetObjectData(SerializationInfo info, StreamingContext context) {
    if (name != null) {
        // Got a name, so send a SerializedResource that just references us
        info.AddValue("name", this.name);
        info.SetType(typeof(SerializedResource));
        return;
    }

    //Serialize just MY fields (defined in Resource)
    this.SerializeMyFields(info, context, typeof(Resource));
}

问）所以，我很确定所有的注意都是内置序列化的，我必须在继承链中一直实现ISerializable以及序列化构造函数吗？

注意GetObjectData是虚拟的，因此派生类可以序列化它们的字段，然后调用基类。这很有效，但是增加很多课程（100s）是一项繁琐的工作。

某些派生类型（Sprite，InvaderBehaviour等）也会执行自定义序列化工作，以使事情变得更糟。

我查看了Jeffrey Richter关于这个主题的文章，并尝试使用ResourceSurrogateSelector：ISerializationSurrogate类型构造，但是如果被序列化的类型是资源而不是从资源派生的类型，那么只会调用这些序列化方法（即不会叫做序列化Invader或GameScreen）

问）有一种聪明的方法吗？

我设法保持两个代码库彼此非常接近，这使得转换变得更加容易 - 我想在这里继续这种方法（所以没有XmlSerializer，Protobuf等），除非真的有令人信服的理由不是。

我考虑过编写一些Java来自动化该过程并反映实现Serializable接口的类型，并创建一个包含所有.Net序列化代码的.cs文件，这样我就不会污染主类文件（我会让他们偏袒）

PS - 目标平台将是.Net方面的Windows8 / Surface / XBox360（因此版本4），可能是PS Vita /也许iOS使用Mono。保存在序列化的平台上反序列化。

修改 谢尔盖·特普利亚科夫在这篇文章中的回答.... .NET, C#: How to add a custom serialization attribute that acts as ISerializable interface ...让我进入了ISurrogateSelector接口，看起来它有助于选择所需的派生类。

Answer 1

到目前为止，我已经设法提出了这个问题，我对它非常满意:-)只需要添加readResolve / writeReplace就可以了！ （我可能会将Object，SerializationInfo，StreamingContext args包装在ObjectOutputStream中以获得良好的测量结果。）

using System;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;

using java.io; //My implementation of various Java classes

namespace NewSerializationTest {

public sealed class JavaSerializableSurrogateSelector : ISurrogateSelector
{
    public void ChainSelector(ISurrogateSelector selector) { throw new NotImplementedException(); }

    public ISurrogateSelector GetNextSelector() { throw new NotImplementedException(); }

    public ISerializationSurrogate GetSurrogate(Type type, StreamingContext context, out ISurrogateSelector selector)
    {
        if (typeof(Serializable).IsAssignableFrom(type))
        {
            selector = this;
            return new JavaSerializationSurrogate();
        }

        //Type is not marked (java.io.)Serializable
        selector = null;
        return null;
    }
}

public sealed class JavaSerializationSurrogate : ISerializationSurrogate {

    //Method called to serialize a java.io.Serializable object
    public void GetObjectData(Object obj, SerializationInfo info, StreamingContext context) {

        //Do the entire tree looking for the 'marker' methods
        var type = obj.GetType();
        while (type != null) 
        {
            var writeObject = type.GetMethod("writeObject", BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.NonPublic, null, new Type[] { typeof(SerializationInfo), typeof(StreamingContext), typeof(Type) }, null );
            if (writeObject != null) {
                //Class has declared custom serialization so call through to that
                writeObject.Invoke(obj, new object[] { info, context, type });
            } else {
                //Default serialization of all non-transient fields at this level only (not the entire tree)
                obj.SerializeFields(info, context, type);
            }

            type = type.BaseType;   
        }
    }

    //Method called to deserialize a java.io.Serializable object
    public Object SetObjectData(Object obj, SerializationInfo info, StreamingContext context, ISurrogateSelector selector) {

        //Do the entire tree looking for the 'marker' methods
        var type = obj.GetType();
        while (type != null) 
        {
            var readObject = type.GetMethod("readObject", BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.NonPublic, null, new Type[] { typeof(SerializationInfo), typeof(StreamingContext), typeof(Type) }, null );
            if (readObject != null) {
                //Class has declared custom serialization so call through to that
                readObject.Invoke(obj, new object[] { info, context, type });
            } else {
                //Default serialization of all non-transient fields at this level only (not the entire tree)
                obj.DeserializeFields(info, context, type);
            }

            type = type.BaseType;   
        }

        return null;
    }
}

[Serializable]
class A  : java.io.Serializable {
    public string Field1;
}

[Serializable]
class B : A {
    public string Field2; 

    private void readObject(SerializationInfo stream, StreamingContext context, Type declaringType) {
        stream.defaultReadObject(context, this, declaringType);

        Debug.WriteLine("B: readObject");
    } 

    private void writeObject(SerializationInfo stream, StreamingContext context, Type declaringType) {
        stream.defaultWriteObject(context, this, declaringType);

        Debug.WriteLine("B: writeObject");
    } 
}

[Serializable]
class C: B {
    public string Field3;

    private void writeObject(SerializationInfo stream, StreamingContext context, Type declaringType) {
        stream.defaultWriteObject(context, this, declaringType);

        Debug.WriteLine("C: writeObject");
    } 
}

public static class SerializationInfoExtensions {

    public static void defaultWriteObject(this SerializationInfo info, StreamingContext context, object o, Type declaringType) {
        o.SerializeFields(info, context, declaringType);
    }

    public static void defaultReadObject(this SerializationInfo info, StreamingContext context, object o, Type declaringType) {
        o.DeserializeFields(info, context, declaringType);
    }
}

class Program {
    static void Main(string[] args) {

        var myC = new C { Field1 = "tom", Field2 = "dick", Field3 = "harry" }; 

        using (var ms = new MemoryStream()) {
            var binaryFormatter = new BinaryFormatter();
            binaryFormatter.SurrogateSelector = new JavaSerializableSurrogateSelector();

            binaryFormatter.Serialize(ms, myC);
            ms.Position = 0;
            var myCDeserialized = binaryFormatter.Deserialize(ms);
        }
    }
}

/// <summary>
/// Extensions to the object class.
/// </summary>
public static class ObjectExtensions
{
    /// <summary>
    /// Serializes an object's class fields.
    /// </summary>
    /// <param name="source">The source object to serialize.</param>
    /// <param name="info">SerializationInfo.</param>
    /// <param name="context">StreamingContext.</param>
    /// <param name="declaringType">The level in the inheritance whose fields are to be serialized - pass null to serialize the entire tree.</param>
    public static void SerializeFields(this object source, SerializationInfo info, StreamingContext context, Type declaringType)
    {
        //Serialize the entire inheritance tree if there is no declaringType passed.
        var serializeTree = declaringType == null;

        //Set the level in the class heirarchy we are interested in - if there is no declaring type use the source type (and the entire tree will be done).
        var targetType = declaringType ?? source.GetType();

        //Get the set of serializable members for the target type
        var memberInfos = FormatterServices.GetSerializableMembers(targetType, context);

        // Serialize the base class's fields to the info object
        foreach (var mi in memberInfos)
        {
            if (serializeTree || mi.DeclaringType == targetType) {
                //Specify the name to use as the key - if the entire tree is being done then the names will already have a prefix. Otherwise, we need to 
                //append the name of the declaring type.
                var name = serializeTree ? mi.Name : mi.DeclaringType.Name + "$" + mi.Name;

                info.AddValue(name, ((FieldInfo)mi).GetValue(source));
            }
        }
    }

    /// <summary>
    /// Deserializes an object's fields.
    /// </summary>
    /// <param name="source">The source object to serialize.</param>
    /// <param name="info">SerializationInfo.</param>
    /// <param name="context">StreamingContext.</param>
    /// <param name="declaringType">The level in the inheritance whose fields are to be deserialized - pass null to deserialize the entire tree.</param>
    public static void DeserializeFields(this object source, SerializationInfo info, StreamingContext context, Type declaringType)
    {
        //Deserialize the entire inheritance tree if there is no declaringType passed.
        var deserializeTree = declaringType == null;

         //Set the level in the class heirarchy we are interested in - if there is no declaring type use the source type (and the entire tree will be done).
        var targetType = declaringType ?? source.GetType();

        var memberInfos = FormatterServices.GetSerializableMembers(targetType, context);

        // Deserialize the base class's fields from the info object
        foreach (var mi in memberInfos)
        {
            //Only serialize the fields at the specific level requested.
            if (deserializeTree || mi.DeclaringType == declaringType) 
            {
                // To ease coding, treat the member as a FieldInfo object
                var fi = (FieldInfo) mi;

                //Specify the name to use as the key - if the entire tree is being done then the names will already have a prefix. Otherwise, we need to 
                //append the name of the declaring type.
                var name = deserializeTree ? mi.Name : mi.DeclaringType.Name + "$" + mi.Name;

                // Set the field to the deserialized value
                fi.SetValue(source, info.GetValue(name, fi.FieldType));
            }
        }
    }
}
}