如何序列化字典 <int, string> ？

Question

如何序列化C＃ Dictionary<int, string> ？

Answer 1

這是一個簡單的演示：

var lookup = new Dictionary<int, string>();

lookup.Add(1, "123");
lookup.Add(2, "456");

using (var ms = new MemoryStream())
{
    var formatter = 
       new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();

    formatter.Serialize(ms, lookup);
    lookup = null;

    ms.Position = 0;
    lookup = (Dictionary<int, string>) formatter.Deserialize(ms);
}

foreach(var i in lookup.Keys)
{
    Console.WriteLine("{0}: {1}", i, lookup[i]);
}

但是您可能必須更加具體。

Answer 2

假設您正在談論XML序列化，可以按照Kevin的建議使用Paul Welter的SerializableDictionary類，但這是另一種解決方案，不涉及IXmlSerializable的定制實現。

我的想法是，字典可以看作是鍵值對的集合。 XmlSerializer可以序列化一個集合，並且可以序列化一個鍵值對。 因此，您只需要為字典創建一個包裝器即可，它看起來XmlSerializer一個集合，以便XmlSerializer可以毫無抱怨地處理它。

這是我的實現：

一個XmlDictionaryEntry類，用於保存鍵/值對（ KeyValuePair<TKey, TValue>類無法序列化為XML，因為其屬性是只讀的）

public class XmlDictionaryEntry<TKey, TValue>
{
    public TKey Key { get; set; }
    public TValue Value { get; set; }
}

XmlDictionaryEntryCollection類，實現鍵-值對的集合並使用字典來存儲它們

public class XmlDictionaryEntryCollection<TKey, TValue> : ICollection<XmlDictionaryEntry<TKey, TValue>>
{
    public XmlDictionaryEntryCollection()
    {
        this.Dictionary = new Dictionary<TKey, TValue>();
    }

    public XmlDictionaryEntryCollection(IDictionary<TKey, TValue> dictionary)
    {
        dictionary.CheckArgumentNull("dictionary");
        this.Dictionary = dictionary;
    }

    [XmlIgnore]
    public IDictionary<TKey, TValue> Dictionary { get; private set; }

    #region ICollection<XmlDictionaryEntry<TKey,TValue>> Members

    public void Add(XmlDictionaryEntry<TKey, TValue> item)
    {
        this.Dictionary.Add(item.Key, item.Value);
    }

    public void Clear()
    {
        this.Dictionary.Clear();
    }

    public bool Contains(XmlDictionaryEntry<TKey, TValue> item)
    {
        return this.Dictionary.ContainsKey(item.Key);
    }

    public void CopyTo(XmlDictionaryEntry<TKey, TValue>[] array, int arrayIndex)
    {
        int index = arrayIndex;
        if (arrayIndex + this.Dictionary.Count > array.Length)
            throw new ArgumentException(ExceptionMessages.CopyToNotEnoughSpace);

        foreach (var kvp in this.Dictionary)
        {
            var entry = new XmlDictionaryEntry<TKey, TValue>
            {
                Key = kvp.Key,
                Value = kvp.Value
            };
            array[index++] = entry;
        }
    }

    public int Count
    {
        get { return this.Dictionary.Count; }
    }

    public bool IsReadOnly
    {
        get { return this.Dictionary.IsReadOnly; }
    }

    public bool Remove(XmlDictionaryEntry<TKey, TValue> item)
    {
        return this.Dictionary.Remove(item.Key);
    }

    #endregion

    #region IEnumerable<XmlDictionaryEntry<TKey,TValue>> Members

    public IEnumerator<XmlDictionaryEntry<TKey, TValue>> GetEnumerator()
    {
        foreach (var kvp in this.Dictionary)
        {
            yield return new XmlDictionaryEntry<TKey, TValue>
            {
                Key = kvp.Key,
                Value = kvp.Value
            };
        }
    }

    #endregion

    #region IEnumerable Members

    IEnumerator IEnumerable.GetEnumerator()
    {
        return this.GetEnumerator();
    }

    #endregion
}

一種擴展方法，可以更輕松地創建包裝器（利用泛型類型推斷）：

public static class XmlSerializationExtension()
{
    public static XmlDictionaryEntryCollection<TKey, TValue> AsXmlSerializable<TKey, TValue>(this IDictionary<TKey, TValue> dictionary)
    {
        if (dictionary != null)
            return new XmlDictionaryEntryCollection<TKey, TValue>(dictionary);
        else
            return null;
    }
}

使用方法如下：

假設您具有此屬性：

public Dictionary<string, Foo> Foos { get; set; }

您只需要從序列化器中隱藏該屬性（使用XmlIgnore屬性），然后序列化XmlDictionaryEntryCollection ：

[XmlIgnore]
public Dictionary<string, Foo> Foos { get; set; }

[XmlElement("Foos")]
public XmlDictionaryEntryCollection SerializableFoos
{
    get { return Foos.AsXmlSerializable(); }
    set { Foos = value.Dictionary; }
}

相對於SerializableDictionary類，此技術的主要優點在於，它使您可以使用所需的任何種類的字典，而不必局限於特定的實現。

Answer 3

您可以編寫自己的對象，該對象具有以下兩種方法：序列化和反序列化。 Form_Load用於測試

public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();
    }

    private void Form1_Load(object sender, EventArgs e)
    {
        Dictionary<int, string> list = new Dictionary<int, string>();

        list.Add(1, "one");
        list.Add(2, "two");
        list.Add(3, "three");

        Dictionary<int, string> list2 = Deserialize(Serialize(list));

    }

    public  string Serialize(Dictionary<int, string> classObject)
    {
        StringBuilder output = new StringBuilder();

        output.Append("<DictionaryIntString>");

        foreach (int key in classObject.Keys)
        {
            output.Append(String.Format("<Key value=\"{0}\">",key));
            output.Append(String.Format("<Value>{0}</Value></Key>", classObject[key]));

        }
        output.Append("</DictionaryIntString>");
        return output.ToString();


    }

    public Dictionary<int, string> Deserialize(string input)
    {
        Dictionary<int, string> output = new Dictionary<int, string>();

        XmlDocument xml = new XmlDocument();
        xml.LoadXml(input);

        foreach (XmlNode node in xml.GetElementsByTagName("Key"))
        {
            output.Add(Int32.Parse(node.Attributes["value"].InnerText),node.FirstChild.InnerText);

        }

        return output;
    }
}