使用 .NET 自定义序列化时测试可选字段

Question

给定这样一个类：

[Serializable]
public class MyClass {
    string name;
    string address;

    public MyClass(SerializationInfo info, StreamingContext context){
        name = info.GetString("name");
        if(/* todo: check if a value for address exists */)
            address = info.GetString("address");
    }

    public void GetObjectData(SerializationInfo info, StreamingContext context){
        info.AddValue(name);
        if(address != null)
            info.AddValue(address);
    }
}

如何在调用 info.GetString(address) 之前测试 address 字段的值是否存在？

是的，我确实知道我可以简单地编写一个空的address字段，但我真正的问题是早期版本的MyClass没有地址字段。

注意：我有充分的理由使用自定义序列化。有一些静态字段被用作单例，默认的反序列化将不尊重这一点。

Answer 1

好吧，一种有趣的方法是您可以使用 < code>GetEnumerator (foreach) 迭代名称/值对，使用名称上的 switch 依次处理每个名称/值对？

不过，实现似乎有点不标准；从示例这里：

    SerializationInfoEnumerator e = info.GetEnumerator();
    Console.WriteLine("Values in the SerializationInfo:");
    while (e.MoveNext())
    {
        Console.WriteLine("Name={0}, ObjectType={1}, Value={2}",
             e.Name, e.ObjectType, e.Value);
    }

但它看起来像您还可以使用SerializationEntry：

[Serializable]
class MyData : ISerializable
{
    public string Name { get; set; }
    public int Value { get; set; }

    public MyData() { }
    public MyData(SerializationInfo info, StreamingContext context)
    {
        foreach (SerializationEntry entry in info)
        {
            switch (entry.Name)
            {
                case "Name":
                    Name = (string)entry.Value; break;
                case "Value":
                    Value = (int)entry.Value; break;
            }
        }
    }

    public void GetObjectData(SerializationInfo info, StreamingContext context)
    {
        info.AddValue("Name", Name);
        info.AddValue("Value", Value);
    }
}

Answer 2

我知道这是一个非常古老的线程，但我对此问题的解决方案是创建 SerializationInfo 类的扩展方法，如下所示：

namespace System.Runtime.Serialization
{
  public static class SerializationInfoExtensions
  {
    public static bool Exists(this SerializationInfo info, string name)
    {
      foreach (SerializationEntry entry in info)
        if (name == entry.Name)
          return true;
      return false;
    }
  }
}

Answer 3

如果您需要检查多个成员，@Lee Griffin 的答案是低效的，因为它将迭代每个属性的所有成员。

我发现创建一个扩展方法可以更有效地从成员创建字典。如果您只需要测试是否存在，则可以创建一个哈希集以利用比基本列表更快的查找速度。

// if you don't care about the object type then you can replace the tuple with just object
public static Dictionary<string, Tuple<Type, object>> GetSerializedMemberDictionary(this SerializationInfo information)
{
    var memberDict = new Dictionary<string, Tuple<Type, object>>(information.MemberCount);
    foreach (SerializationEntry entry in information)
       memberDict.Add(entry.Name, Tuple.Create(entry.ObjectType, entry.Value));
    return memberDict;
}

public static HashSet<string> GetSerializedMemberList(this SerializationInfo information)
{
    var list = new HashSet<string>(information.MemberCount);
    foreach (SerializationEntry entry in information)
       list.Add(entry.Name);
    return list;
}

然后可以简单地使用它：

var members = information.GetSerializedMemberDictionary();
if (members.ContainsKey("Delimiter")) {
   _delimiter = (string)members["Delimiter"].Item2;
}
        

或

var members = information.GetSerializedMemberList();
var delimiter = members.Contains("Delimiter") ? information.GetString("Delimiter") : null;