C# 字典ToList序列化的问题

我尝试使用ToList选项序列化字典的值。 我发现在反序列化过程中，我序列化的所有对象都为null 当我使用内存流时，它没有发生，当我使用.Net对象作为字典中的类型时，它也没有发生。 下面是我创建的一个示例代码，它显示了这个问题 这段代码的输出是 字典：0-0 字典：1-1 名单：0 名单：1 字典：0-Null 字典：1-Null 名单：0

类程序
{
静态void Main（字符串[]参数）
{
A状态=新A（）；
Stream=File.Open（“D:\\temp\\temp.txt”，FileMode.Create）；
BinaryFormatter bFormatter=新的BinaryFormatter（）；
序列化（流、状态）；
stream.Close（）；
state.PrintData（）；
stream=File.Open（“D:\\temp\\temp.txt”，FileMode.Open）；
bFormatter=新的二进制格式化程序（）；
状态=（A）bFormatter.Deserialize（流）；
stream.Close（）；
state.PrintData（）；
}
}
[可序列化（）]
公共类A：ISerializable
{
Dictionary dic=新字典（）；
列表=新列表（）；
公共A（）
{
对于（int i=0；i<4；i++）
{
dic.添加（i，新的B（i））；
增加（新的B（i））；
}
}
public void PrintData（）
{
foreach（dic中的KeyValuePair kvp）
{
Console.WriteLine（“字典：”+kvp.Key.ToString（）+“-”+（（kvp.Value！=null）？kvp.Value.ToString（）：“null”）；
}
foreach（列表中的B）
{
Console.WriteLine（“列表：+b.ToString（））；
}
}
公共A（SerializationInfo、StreamingContext上下文）
{
List keys=info.GetValue（“keys”，typeof（List））作为列表；
列表值=info.GetValue（“值”，类型（列表））作为列表；
int count=键数；
if（count==values.count）
{
for（int i=0；i

---

序列化支持字典。这是我修改的代码，它可以工作

    public A(SerializationInfo info, StreamingContext context)
    {
        dic = info.GetValue("mapping", typeof(Dictionary<int, B>)) as Dictionary<int, B>;
        list = info.GetValue("list", typeof(List<B>)) as List<B>;
    }

    public void GetObjectData(SerializationInfo info, StreamingContext context)
    {
        info.AddValue("mapping", dic, typeof(Dictionary<int, B>));
        List<B> listFromDic = new List<B>(dic.Values.ToList());
        info.AddValue("list", listFromDic, typeof(List<B>));
    }

public A（SerializationInfo，StreamingContext）
{
dic=info.GetValue（“映射”，类型（字典））作为字典；
list=info.GetValue（“list”，typeof（list））作为列表；
}
public void GetObjectData（SerializationInfo信息、StreamingContext上下文）
{
信息添加值（“映射”，dic，类型（字典））；
List listFromDic=新列表（dic.Values.ToList（））；
info.AddValue（“列表”，listFromDic，typeof（列表））；
}

编辑： 提到的op必须使用列表。修订代码如下。无法在公共构造函数A（SerializationInfo，StreamingContext上下文）中初始化字典dic。
因为：
无法保证对象反序列化的顺序。例如，如果一个类型引用了尚未反序列化的类型，则会发生异常。如果要创建具有此类依赖关系的类型，可以通过实现IDeserializationCallback接口和OnDeserialization方法来解决此问题。

上述段落来自：

这意味着B不是在A的构造函数中创建的

修订守则：

[Serializable()]
public class A : ISerializable, IDeserializationCallback 
{
    Dictionary<int, B> dic = new Dictionary<int, B>();
    List<B> list = new List<B>();
    private List<int> keys = new List<int>();

    public A()
    {
        for (int i = 0; i < 4; i++)
        {
            dic.Add(i, new B(i));
            list.Add(new B(i));
        }
    }

    public void PrintData()
    {
        foreach (KeyValuePair<int, B> kvp in dic)
        {
            Console.WriteLine("Dictionary: " + kvp.Key.ToString() + "-" + ((kvp.Value != null) ? kvp.Value.ToString() : "Null"));
        }
        foreach (B b in list)
        {
            Console.WriteLine("List: " + b.ToString());
        }
    }

    public A(SerializationInfo info, StreamingContext context)
    {
        keys = info.GetValue("keys", typeof(List<int>)) as List<int>;
        List<B> values = info.GetValue("values", typeof(List<B>)) as List<B>;

        list = info.GetValue("list", typeof(List<B>)) as List<B>;
    }

    public void GetObjectData(SerializationInfo info, StreamingContext context)
    {
        info.AddValue("keys", dic.Keys.ToList(), typeof(List<int>));
        info.AddValue("values", dic.Values.ToList(), typeof(List<B>));
        List<B> listFromDic = new List<B>(dic.Values.ToList());
        info.AddValue("list", listFromDic, typeof(List<B>));
    }

    public void OnDeserialization(object sender)
    {
        dic = new Dictionary<int, B>();
        int count = keys.Count;
        if (count == list.Count)
        {
            for (int i = 0; i < count; i++)
            {
                dic[keys[i]] = list[i];
            }
        }
    }
}

[Serializable（）]
公共类A：ISerializable，IDeserializationCallback
{
Dictionary dic=新字典（）；
列表=新列表（）；
私有列表密钥=新列表（）；
公共A（）
{
对于（int i=0；i<4；i++）
{
dic.添加（i，新的B（i））；
增加（新的B（i））；
}
}
public void PrintData（）
{
foreach（dic中的KeyValuePair kvp）
{
Console.WriteLine（“字典：”+kvp.Key.ToString（）+“-”+（（kvp.Value！=null）？kvp.Value.ToString（）：“null”）；
}
foreach（列表中的B）
{
Console.WriteLine（“列表：+b.ToString（））；
}
}
公共A（SerializationInfo、StreamingContext上下文）
{
keys=info.GetValue（“keys”，typeof（List））作为列表；
列表值=info.GetValue（“值”，类型（列表））作为列表；
list=info.GetValue（“list”，typeof（list））作为列表；
}
public void GetObjectData（SerializationInfo信息、StreamingContext上下文）
{
info.AddValue（“keys”，dic.keys.ToList（），typeof（List））；
info.AddValue（“values”，dic.values.ToList（），typeof（List））；
List listFromDic=新列表（dic.Values.ToList（））；
info.AddValue（“列表”，listFromDic，typeof（列表））；
}
公共序列化（对象发送方）
{
dic=新字典（）；
int count=键数；
if（count==list.count）
{
for（int i=0；i

+1，很好。对我有用。顺便说一句，删除

A（）

构造函数中注释掉的代码，这样答案的质量会更好。我并没有使用字典序列化，因为字典序列化是

[Serializable()]
public class A : ISerializable, IDeserializationCallback 
{
    Dictionary<int, B> dic = new Dictionary<int, B>();
    List<B> list = new List<B>();
    private List<int> keys = new List<int>();

    public A()
    {
        for (int i = 0; i < 4; i++)
        {
            dic.Add(i, new B(i));
            list.Add(new B(i));
        }
    }

    public void PrintData()
    {
        foreach (KeyValuePair<int, B> kvp in dic)
        {
            Console.WriteLine("Dictionary: " + kvp.Key.ToString() + "-" + ((kvp.Value != null) ? kvp.Value.ToString() : "Null"));
        }
        foreach (B b in list)
        {
            Console.WriteLine("List: " + b.ToString());
        }
    }

    public A(SerializationInfo info, StreamingContext context)
    {
        keys = info.GetValue("keys", typeof(List<int>)) as List<int>;
        List<B> values = info.GetValue("values", typeof(List<B>)) as List<B>;

        list = info.GetValue("list", typeof(List<B>)) as List<B>;
    }

    public void GetObjectData(SerializationInfo info, StreamingContext context)
    {
        info.AddValue("keys", dic.Keys.ToList(), typeof(List<int>));
        info.AddValue("values", dic.Values.ToList(), typeof(List<B>));
        List<B> listFromDic = new List<B>(dic.Values.ToList());
        info.AddValue("list", listFromDic, typeof(List<B>));
    }

    public void OnDeserialization(object sender)
    {
        dic = new Dictionary<int, B>();
        int count = keys.Count;
        if (count == list.Count)
        {
            for (int i = 0; i < count; i++)
            {
                dic[keys[i]] = list[i];
            }
        }
    }
}