动态对象序列化

Question

我尝试使用 BinaryFormatter 序列化 DynamicObject 类，但是：

• 输出文件太大，不完全适合线路
• 循环引用未处理（序列化时卡住）

自 序列化一个DynamicObject本身意义不大，这是我尝试序列化的类：（

[Serializable()]
class Entity
    : DynamicObject, ISerializable
{

    IDictionary<string, object> values = new Dictionary<string, object>();

    public Entity()
    {

    }

    protected Entity(SerializationInfo info, StreamingContext ctx)
    {
        string fieldName = string.Empty;
        object fieldValue = null;

        foreach (var field in info)
        {
            fieldName = field.Name;
            fieldValue = field.Value;

            if (string.IsNullOrWhiteSpace(fieldName))
                continue;

            if (fieldValue == null)
                continue;

            this.values.Add(fieldName, fieldValue);
        }

    }

    public override bool TryGetMember(GetMemberBinder binder, out object result)
    {
        this.values.TryGetValue(binder.Name, out result);

        return true;
    }

    public override bool TrySetMember(SetMemberBinder binder, object value)
    {
        this.values[binder.Name] = value;

        return true;
    }        

    void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
    {            
        foreach (var kvp in this.values)
        {
            info.AddValue(kvp.Key, kvp.Value);                 
        }
    }

}

我想我可以使用ExpandoObject，但那是另一个故事了。）

这是一个简单的测试程序：

    static void Main(string[] args)
    {
        BinaryFormatter binFmt = new BinaryFormatter();

        dynamic obj = new Entity();
        dynamic subObj = new Entity();
        dynamic obj2 = null;

        obj.Value = 100;
        obj.Dictionary = new Dictionary<string, int>() { { "la la la", 1000 } };

        subObj.Value = 200;
        subObj.Name = "SubObject";

        obj.Child = subObj;

        using (var stream = new FileStream("test.txt", FileMode.OpenOrCreate))
        {
            binFmt.Serialize(stream, obj);                
        }

        using (var stream = new FileStream("test.txt", FileMode.Open))
        {
            try
            {
                obj2 = binFmt.Deserialize(stream);                    
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex);
            }                
        }

        Console.ReadLine();

    }

在这里和那里放置一些断点帮助我查看了 obj2 内容，看起来原始数据已正确反序列化，但如果您发挥想象力并移动数据，则仍然存在上述缺点。

我查看了 Marc Gravell 的 protobuf-net，但我不太确定如何在这样的上下文中使用它（我什至不确定我从存储库中选择了正确的版本，但是嘿）。

我知道这更多的是代码而不是文字，但我认为我无法更好地解释这个场景。请告诉我是否可以添加一些内容以使这个问题更清楚。

非常感谢任何帮助。

Answer 1

我 98% 确信该序列适用于动态对象。

1. 将对象转换为 Expando 对象
2. 将 Expando 对象转换为字典类型
3. 使用 ProtoBuf-net Serializer.Serialize / .Deserialize 按照正常操作
4. 将字典转换为 Expando 对象

您可以将对象转换为名称/值对的集合以进行传输。

这只是动态功能的一小部分，但也许对您来说已经足够了。

有一些自定义代码可以处理上面的一些转换，如果有兴趣的话我可以向您展示。

当动态是类的占位符时，我没有解决方案。对于这种情况，我建议获取类型并使用 switch 语句根据需要进行序列化/反序列化。对于最后一种情况，您需要放置一些内容来指示您需要哪种类型的通用反序列化（字符串/id/完全限定类型名称/等）。假设您正在处理预期类型的​​列表。

注意：Expando 实现 IDictionary。 Expando 只是一个键/值对列表。 IE。你点的东西是键，值是实现它的任何函数链的返回值。有一组动态界面用于自定义语法糖体验，但大多数时候您不会看它们。

refs：

• 使用构造函数的 IDictionary 字典 - http: //msdn.microsoft.com/en-us/library/et0ke8sz(v=vs.110).aspx
• IDictionary/Dictionary 到 Expando -- http://theburningmonk.com/2011/05/idictionarystring-object-to-expandoobject-extension-method/

Answer 2

我不确定 JSON 在您的环境中是否可以接受，但如果是，我已经使用了 Json.net (http://json .codeplex.com）来序列化动态类型。它工作得很好，速度很快，而且输出的大小很小。虽然 Json.net 不直接返回动态对象，但将 Json.Net 的反序列化输出转换为任何动态类型非常容易。在下面的示例中，我使用 ExpandoObject 作为动态类型。下面的代码是我在 Facebook Graph Toolkit 中使用的代码。请参阅此链接以获取原始来源： http://facebookgraphtoolkit.codeplex.com/SourceControl /changeset/view/48442#904504

public static dynamic Convert(string s) {
            object obj = Newtonsoft.Json.JsonConvert.DeserializeObject(s);
            if (obj is string) {
                return obj as string;
            } else {
                return ConvertJson((JToken)obj);
            }
    }

    private static dynamic ConvertJson(JToken token) {
        // FROM : http://blog.petegoo.com/archive/2009/10/27/using-json.net-to-eval-json-into-a-dynamic-variable-in.aspx
        // Ideally in the future Json.Net will support dynamic and this can be eliminated.
        if (token is JValue) {
            return ((JValue)token).Value;
        } else if (token is JObject) {
            ExpandoObject expando = new ExpandoObject();
            (from childToken in ((JToken)token) where childToken is JProperty select childToken as JProperty).ToList().ForEach(property => {
                ((IDictionary<string, object>)expando).Add(property.Name, ConvertJson(property.Value));
            });
            return expando;
        } else if (token is JArray) {
            List<ExpandoObject> items = new List<ExpandoObject>();
            foreach (JToken arrayItem in ((JArray)token)) {
                items.Add(ConvertJson(arrayItem));
            }
            return items;
        }
        throw new ArgumentException(string.Format("Unknown token type '{0}'", token.GetType()), "token");
    }

Answer 3

首先，文件的大小取决于两件事（如果我理解 BinaryFormatter 的工作原理，如果我错了，请纠正我）：

1. 正在序列化的实际值的大小，以及
2. 用于序列化对象值的名称SerializationInfo.AddValue 方法，该方法存储在输出文件中，以便在反序列化期间可以使用同名的值。

显然，#1 会导致最大的速度减慢，只能通过优化您尝试序列化的对象来减少速度。

因为您使用的是动态对象，所以#2 引起的几乎不明显的小尺寸增加是不可避免的。如果您提前知道对象成员的类型和名称，则可以在迭代时为对象的每个成员指定非常短的、按顺序确定的名称（“1”、“2”、“3”等）覆盖对象的成员，通过 SerializationInfo.AddValue 添加它们。然后，在反序列化期间，您可以使用具有相同顺序确定名称的 SerializationInfo.GetValue ，并且只要您迭代，无论被反序列化的值的实际名称是什么，反序列化都会正常工作对象的成员按照添加的顺序排列。当然，这可能只能为每个成员平均节省 4 或 5 个字节，但这些少量的内容加起来就可以形成大对象。

@Raine：（我想我可以使用 ExpandoObject，但那是另一个故事了。）

并非如此；我更改了您的代码示例以使用 ExpandoObject 而不是您的 Entity 类，并向我抛出了 SerializationException 。 ExpandoObject 未使用 SerializedAttribute 进行标记，并且它没有用于反序列化或序列化的适当构造函数。但是，这并不意味着如果您确实想要的话，您不能使用 ExpandoObject：它实现了 IDictionary，后者又实现了 ICollection< ;KeyValuePair<字符串，对象>>。因此，ExpandoObject 实例是 KeyValuePair 实例的集合，这些实例标记为可序列化。因此，您可以序列化 ExpandoObject，但必须将其转换为 ICollection> 并序列化每个 KeyValuePair分别在其中。不过，就优化原始代码示例而言，这毫无意义，因为它占用了同样多的文件空间。

总之，我真的不认为有任何方法可以优化动态对象的序列化 - 每次序列化时都必须循环遍历对象的成员，并且您无法事先知道对象的大小（根据动态的定义） 。

Answer 4

我不知道 SharpSerializer 是否支持动态对象，但可能值得一试：

http://www .sharpserializer.com/en/index.html

Answer 5

序列化动态对象的一个​​建议是将它们转换为 String 然后序列化，然后您可以反序列化回您的对象（如果适用于您的情况）。