5

我正在将 Java 游戏转换为 C#（Puppy Games 的泰坦攻击），除了最后一项任务是保存文件的游戏状态序列化之外，我现在几乎完成了。

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

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

我幼稚的解决方案是盲目复制这种方法并在基类中实现 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 类型构造，但只有在被序列化的类型是 Resource 而不是从资源派生的类型时才会调用这些序列化方法（即不会被称为序列化入侵者或游戏屏幕）

问）有没有聪明的方法来做到这一点？

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

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

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

编辑 Sergey Teplyakov 在这篇文章中的回答.... .NET, C#: How to add a custom serialization attribute that act as ISerializable interface ...让我看到了 ISurrogateSelector 界面，它看起来有助于选择所需的派生类。

4

1 回答 1

1

到目前为止，这是我设法提出的，我对此非常满意 :-) 只需添加 readResolve/writeReplace，我就完成了！（我可能也会将 Object、SerializationInfo、StreamingContext 参数包装在 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));
            }
        }
    }
}
}
于 2012-12-29T00:01:12.663 回答