C# 在应用程序设置中保存字典，并在启动时加载

我有

字典

，我想在重启应用程序时保存并还原它。据我所知，您无法将字典存储在c#中，因此请尝试解决此问题

目前，我已经在名为

DB

的设置中创建了字符串变量，并尝试使用如下内容：

var settings = dict.ToArray();

var prop = Properties.Settings.Default.DB;

{[john, 0,53]}
{[ivone, 0,44]}
etc.

并进行类似

prop=settings的设置

到目前为止，我已经做到了这一点，尽管它现在正在发挥作用

private void SaveSettings()
{
    var settings = spamPercentage.ToArray();

    var prop = Properties.Settings.Default.DB;

    string res = String.Join(",", settings);

    prop = res;
}

private void LoadSettings()
{
    var prop = Properties.Settings.Default.DB;

    var dictionary = prop.ToDictionary(item => item.Key,
                               item => item.Value);
}

编辑
字典中的值如下所示：

var settings = dict.ToArray();

var prop = Properties.Settings.Default.DB;

{[john, 0,53]}
{[ivone, 0,44]}
etc.

@编辑
利用Julien JSON的想法，我提出：

 string prop = Properties.Settings.Default.DB;
    private void SaveSettings()
    {

        prop = JsonConvert.SerializeObject(dict);
Properties.Settings.Default.Save();
    }

    private void LoadSettings()
    {
        dict= JsonConvert.DeserializeObject<Dictionary<string, double>>(prop);
    }

string prop=Properties.Settings.Default.DB；
私有void SaveSettings（）
{
prop=JsonConvert.SerializeObject（dict）；
Properties.Settings.Default.Save（）；
}
私有void加载设置（）
{
dict=JsonConvert.DeserializeObject（prop）；
}

当我点击程序并使用SaveSettings方法时，我可以看到它有值。然后我重新启动程序，并尝试加载设置，它们为空。
我不久前遇到了类似的问题。最后，我使用将字典序列化为字符串，将其存储在应用程序设置中，并在需要时将其反序列化回字典

string strDictionaryAsString = JsonConvert.SerializeObject(dtnDictionary);

var dtnDictionary = JsonConvert.DeserializeObject<Dictionary<string, double>>(strDictionaryAsString );

string strdictionaryastring=JsonConvert.SerializeObject（dtnDictionary）；
var dtnDictionary=JsonConvert.DeserializeObject（strDictionaryaString）；
我使用它在wpf中存储我的datagrid设置

[XmlRoot("Dictionary")]
public class SerializableDictionary<TKey, TValue> : Dictionary<TKey, TValue>, IXmlSerializable
{

    #region IXmlSerializable Members
    public System.Xml.Schema.XmlSchema GetSchema()
    {
        return null;
    }

    public void ReadXml(System.Xml.XmlReader reader)
    {
        var keySerializer = new XmlSerializer(typeof(TKey));
        var valueSerializer = new XmlSerializer(typeof(TValue));

        bool wasEmpty = reader.IsEmptyElement;
        reader.Read();

        if (wasEmpty)
            return;

        while (reader.NodeType != System.Xml.XmlNodeType.EndElement)
        {
            reader.ReadStartElement("item");

            reader.ReadStartElement("key");
            var key = (TKey)keySerializer.Deserialize(reader);
            reader.ReadEndElement();

            reader.ReadStartElement("value");
            var value = (TValue)valueSerializer.Deserialize(reader);
            reader.ReadEndElement();

            this.Add(key, value);

            reader.ReadEndElement();
            reader.MoveToContent();
        }
        reader.ReadEndElement();
    }

    public void WriteXml(System.Xml.XmlWriter writer)
    {
        var keySerializer = new XmlSerializer(typeof(TKey));
        var valueSerializer = new XmlSerializer(typeof(TValue));

        foreach (TKey key in this.Keys)
        {
            writer.WriteStartElement("item");

            writer.WriteStartElement("key");
            keySerializer.Serialize(writer, key);
            writer.WriteEndElement();

            writer.WriteStartElement("value");
            TValue value = this[key];
            valueSerializer.Serialize(writer, value);
            writer.WriteEndElement();

            writer.WriteEndElement();
        }
    }
    #endregion
}

[XmlRoot（“字典”）]
公共类SerializableDictionary:Dictionary，IXmlSerializable
{
#区域IXmlSerializable成员
public System.Xml.Schema.XmlSchema GetSchema（）
{
返回null；
}
public void ReadXml（System.Xml.XmlReader）
{
var keySerializer=新的XmlSerializer（typeof（TKey））；
var-valueSerializer=新的XmlSerializer（typeof（TValue））；
bool waspempy=reader.isemptyelment；
reader.Read（）；
如果（为空）
返回；
while（reader.NodeType！=System.Xml.XmlNodeType.EndElement）
{
reader.ReadStartElement（“项目”）；
reader.ReadStartElement（“密钥”）；
var key=（TKey）keySerializer.反序列化（reader）；
reader.ReadEndElement（）；
reader.ReadStartElement（“价值”）；
var value=（TValue）valueSerializer.Deserialize（reader）；
reader.ReadEndElement（）；
添加（键、值）；
reader.ReadEndElement（）；
reader.MoveToContent（）；
}
reader.ReadEndElement（）；
}
public void WriteXml（System.Xml.XmlWriter）
{
var keySerializer=新的XmlSerializer（typeof（TKey））；
var-valueSerializer=新的XmlSerializer（typeof（TValue））；
foreach（此.Keys中的TKey键）
{
编写人。书面启动项（“项目”）；
writer.writeStart元素（“键”）；
序列化（编写器，键）；
writer.writeedelement（）；
writer.writeStarteElement（“值”）；
t值=此[键]；
序列化（写入程序，值）；
writer.writeedelement（）；
writer.writeedelement（）；
}
}
#端区
}

设置：

[SettingsManageabilityAttribute(SettingsManageability.Roaming)]
public abstract class GridSettingsBase : ApplicationSettingsBase, IGridSettings
{
    [UserScopedSettingAttribute()]
    [DefaultSettingValue("")]
    [SettingsSerializeAs(SettingsSerializeAs.Xml)]
    public SerializableDictionary<string, int> GridDisplayIndexList
    {
        get { return (SerializableDictionary<string, int>)this["GridDisplayIndexList"]; }
        set { this["GridDisplayIndexList"] = value; }
    }

    [UserScopedSettingAttribute()]
    [DefaultSettingValue("")]
    [SettingsSerializeAs(SettingsSerializeAs.Xml)]
    public SerializableDictionary<string, Visibility> GridColumnVisibilityList
    {
        get { return (SerializableDictionary<string, Visibility>)this["GridColumnVisibilityList"]; }
        set { this["GridColumnVisibilityList"] = value; }
    }

    [UserScopedSettingAttribute()]
    [DefaultSettingValue("")]
    [SettingsSerializeAs(SettingsSerializeAs.Xml)]
    public SerializableDictionary<string, double> GridColumnWidthList
    {
        get { return (SerializableDictionary<string, double>)this["GridColumnWidthList"]; }
        set { this["GridColumnWidthList"] = value; }
    }

    [UserScopedSettingAttribute()]
    [DefaultSettingValue("")]
    [SettingsSerializeAs(SettingsSerializeAs.Xml)]
    public List<SortDescription> GridSortDescriptionList
    {
        get { return (List<SortDescription>)this["GridSortDescriptionList"]; }
        set { this["GridSortDescriptionList"] = value; }
    }

    protected GridSettingsBase()
    {
        Application.Current.Exit += OnExit;
    }

    private void OnExit(object sender, ExitEventArgs e)
    {
        this.Save();
    }
}

[SettingsManageabilityAttribute（SettingsManageability.Roaming）]
公共抽象类GridSettingsBase:ApplicationSettingsBase，IGridSettings
{
[UserScopedSettingAttribute（）]
[默认设置值（“”）
[SettingsSerializeAs（SettingsSerializeAs.Xml）]
public SerializableDictionary GridDisplayIndexList
{
获取{return（SerializableDictionary）this[“GridDisplayIndexList”]；}
设置{this[“GridDisplayIndexList”]=value；}
}
[UserScopedSettingAttribute（）]
[默认设置值（“”）
[SettingsSerializeAs（SettingsSerializeAs.Xml）]
public SerializableDictionary GridColumnVisibilityList
{
获取{return（SerializableDictionary）this[“GridColumnVisibilityList”]；}
设置{this[“GridColumnVisibilityList”]=value；}
}
[UserScopedSettingAttribute（）]
[默认设置值（“”）
[SettingsSerializeAs（SettingsSerializeAs.Xml）]
公共序列化字典GridColumnWidthList
{
获取{return（SerializableDictionary）this[“GridColumnWidthList”]；}
设置{this[“GridColumnWidthList”]=value；}
}
[UserScopedSettingAttribute（）]
[默认设置值（“”）
[SettingsSerializeAs（SettingsSerializeAs.Xml）]
公共列表GridSortDescriptionList
{
获取{return（List）this[“GridSortDescriptionList”]；}
设置{this[“GridSortDescriptionList”]=value；}
}
受保护的GridSettingsBase（）
{
Application.Current.Exit+=OnExit；
}
私有void OnExit（对象发送方，ExitEventArgs e）
{
这是Save（）；
}
}
不应将此类数据写入设置。一个更好的主意是以xml文件为例。你能看看这里吗，我想它会回答你的问题，而第一个可行，在程序重新启动后序列化，反序列化看到变量中只有null。你能检查我的编辑吗？我感觉设置没有保存。请确保您的设置是用户范围的，而不是应用程序范围的。（你可以在项目页面的“设置”选项卡中进行更改）。这太棒了。这太棒了！