有空Dictionary<int, string>如何用 XML 中的键和值填充它
<items>
<item id='int_goes_here' value='string_goes_here'/>
</items>
并将其序列化回 XML 而不使用 XElement？
问问题
194265 次
10 回答
111
在临时item课程的帮助下
public class item
{
[XmlAttribute]
public int id;
[XmlAttribute]
public string value;
}
样本字典：
Dictionary<int, string> dict = new Dictionary<int, string>()
{
{1,"one"}, {2,"two"}
};
.
XmlSerializer serializer = new XmlSerializer(typeof(item[]),
new XmlRootAttribute() { ElementName = "items" });
序列化
serializer.Serialize(stream,
dict.Select(kv=>new item(){id = kv.Key,value=kv.Value}).ToArray() );
反序列化
var orgDict = ((item[])serializer.Deserialize(stream))
.ToDictionary(i => i.id, i => i.value);
-------------------------------------------------- ----------------------------
如果您改变主意，这是使用 XElement完成的方法。
序列化
XElement xElem = new XElement(
"items",
dict.Select(x => new XElement("item",new XAttribute("id", x.Key),new XAttribute("value", x.Value)))
);
var xml = xElem.ToString(); //xElem.Save(...);
反序列化
XElement xElem2 = XElement.Parse(xml); //XElement.Load(...)
var newDict = xElem2.Descendants("item")
.ToDictionary(x => (int)x.Attribute("id"), x => (string)x.Attribute("value"));
于 2012-09-23T19:50:50.633 回答
33
Paul Welter 的ASP.NET 博客有一个可序列化的字典。但它不使用属性。我将在代码下方解释原因。
using System;
using System.Collections.Generic;
using System.Text;
using System.Xml.Serialization;
[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)
{
XmlSerializer keySerializer = new XmlSerializer(typeof(TKey));
XmlSerializer 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");
TKey key = (TKey)keySerializer.Deserialize(reader);
reader.ReadEndElement();
reader.ReadStartElement("value");
TValue value = (TValue)valueSerializer.Deserialize(reader);
reader.ReadEndElement();
this.Add(key, value);
reader.ReadEndElement();
reader.MoveToContent();
}
reader.ReadEndElement();
}
public void WriteXml(System.Xml.XmlWriter writer)
{
XmlSerializer keySerializer = new XmlSerializer(typeof(TKey));
XmlSerializer 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
}
首先，此代码有一个问题。假设您从另一个来源阅读了一本字典，其中包含以下内容：
<dictionary>
<item>
<key>
<string>key1</string>
</key>
<value>
<string>value1</string>
</value>
</item>
<item>
<key>
<string>key1</string>
</key>
<value>
<string>value2</string>
</value>
</item>
</dictionary>
这将在 de-seariazation 中引发异常，因为您只能拥有一个字典键。
您必须在序列化字典中使用 XElement 的原因是字典未定义为Dictionary<String,String>，字典是Dictionary<TKey,TValue>。
要看到这个问题，问问你自己：假设我们有一个TValue序列化为使用元素的东西，它把自己描述为 XML（假设一个字典字典Dictionary<int,Dictionary<int,string>>（不是那种不常见的模式，它是一个查找表）），如何您的 Attribute only 版本会完全代表属性内的字典吗？
于 2012-09-23T18:33:58.930 回答
5
默认情况下，字典在 C# 中不可序列化，我不知道为什么，但这似乎是一种设计选择。
现在，我建议使用Json.NET将其转换为 JSON 并从那里转换为字典（反之亦然）。除非您真的需要 XML，否则我建议您完全使用 JSON。
于 2012-09-23T17:07:20.137 回答
4
基于LB的回答。
用法：
var serializer = new DictionarySerializer<string, string>();
serializer.Serialize("dictionary.xml", _dictionary);
_dictionary = _titleDictSerializer.Deserialize("dictionary.xml");
通用类：
public class DictionarySerializer<TKey, TValue>
{
[XmlType(TypeName = "Item")]
public class Item
{
[XmlAttribute("key")]
public TKey Key;
[XmlAttribute("value")]
public TValue Value;
}
private XmlSerializer _serializer = new XmlSerializer(typeof(Item[]), new XmlRootAttribute("Dictionary"));
public Dictionary<TKey, TValue> Deserialize(string filename)
{
using (FileStream stream = new FileStream(filename, FileMode.Open))
using (XmlReader reader = XmlReader.Create(stream))
{
return ((Item[])_serializer.Deserialize(reader)).ToDictionary(p => p.Key, p => p.Value);
}
}
public void Serialize(string filename, Dictionary<TKey, TValue> dictionary)
{
using (var writer = new StreamWriter(filename))
{
_serializer.Serialize(writer, dictionary.Select(p => new Item() { Key = p.Key, Value = p.Value }).ToArray());
}
}
}
于 2016-06-23T15:43:18.367 回答
3
您可以使用ExtendedXmlSerializer。如果你有一堂课：
public class TestClass
{
public Dictionary<int, string> Dictionary { get; set; }
}
并创建此类的实例：
var obj = new TestClass
{
Dictionary = new Dictionary<int, string>
{
{1, "First"},
{2, "Second"},
{3, "Other"},
}
};
您可以使用 ExtendedXmlSerializer 序列化此对象：
var serializer = new ConfigurationContainer()
.UseOptimizedNamespaces() //If you want to have all namespaces in root element
.Create();
var xml = serializer.Serialize(
new XmlWriterSettings { Indent = true }, //If you want to formated xml
obj);
输出 xml 将如下所示：
<?xml version="1.0" encoding="utf-8"?>
<TestClass xmlns:sys="https://extendedxmlserializer.github.io/system" xmlns:exs="https://extendedxmlserializer.github.io/v2" xmlns="clr-namespace:ExtendedXmlSerializer.Samples;assembly=ExtendedXmlSerializer.Samples">
<Dictionary>
<sys:Item>
<Key>1</Key>
<Value>First</Value>
</sys:Item>
<sys:Item>
<Key>2</Key>
<Value>Second</Value>
</sys:Item>
<sys:Item>
<Key>3</Key>
<Value>Other</Value>
</sys:Item>
</Dictionary>
</TestClass>
您可以从nuget安装 ExtendedXmlSerializer或运行以下命令：
Install-Package ExtendedXmlSerializer
于 2016-09-22T13:24:05.550 回答
3
我有一个结构KeyValuePairSerializable：
[Serializable]
public struct KeyValuePairSerializable<K, V>
{
public KeyValuePairSerializable(KeyValuePair<K, V> pair)
{
Key = pair.Key;
Value = pair.Value;
}
[XmlAttribute]
public K Key { get; set; }
[XmlText]
public V Value { get; set; }
public override string ToString()
{
return "[" + StringHelper.ToString(Key, "") + ", " + StringHelper.ToString(Value, "") + "]";
}
}
然后，属性的 XML 序列化Dictionary是：
[XmlIgnore]
public Dictionary<string, string> Parameters { get; set; }
[XmlArray("Parameters")]
[XmlArrayItem("Pair")]
[DebuggerBrowsable(DebuggerBrowsableState.Never)] // not necessary
public KeyValuePairSerializable<string, string>[] ParametersXml
{
get
{
return Parameters?.Select(p => new KeyValuePairSerializable<string, string>(p)).ToArray();
}
set
{
Parameters = value?.ToDictionary(i => i.Key, i => i.Value);
}
}
只是属性必须是数组，而不是列表。
于 2016-11-18T14:49:27.310 回答
2
编写一个包含 B 类数组的 A 类。B 类应该有一个 id 属性和一个 value 属性。将 xml 反序列化为 A 类。将 A 中的数组转换为所需的字典。
要序列化字典，请将其转换为 A 类的实例，然后序列化...
于 2012-09-23T18:06:34.887 回答
2
KeyedCollection 像字典一样工作并且是可序列化的。
首先创建一个包含键和值的类：
/// <summary>
/// simple class
/// </summary>
/// <remarks></remarks>
[Serializable()]
public class cCulture
{
/// <summary>
/// culture
/// </summary>
public string culture;
/// <summary>
/// word list
/// </summary>
public List<string> list;
/// <summary>
/// status
/// </summary>
public string status;
}
然后创建一个 KeyedCollection 类型的类，并将您的类的属性定义为键。
/// <summary>
/// keyed collection.
/// </summary>
/// <remarks></remarks>
[Serializable()]
public class cCultures : System.Collections.ObjectModel.KeyedCollection<string, cCulture>
{
protected override string GetKeyForItem(cCulture item)
{
return item.culture;
}
}
对序列化此类数据很有用。
于 2019-01-25T03:14:56.703 回答
1
我将可序列化的类用于不同模块之间的 WCF 通信。下面是一个可序列化类的示例，它也用作 DataContract。我的方法是使用 LINQ 的强大功能将 Dictionary 转换为 KeyValuePair<> 的开箱即用的可序列化 List<>：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
using System.Xml.Serialization;
namespace MyFirm.Common.Data
{
[DataContract]
[Serializable]
public class SerializableClassX
{
// since the Dictionary<> class is not serializable,
// we convert it to the List<KeyValuePair<>>
[XmlIgnore]
public Dictionary<string, int> DictionaryX
{
get
{
return SerializableList == null ?
null :
SerializableList.ToDictionary(item => item.Key, item => item.Value);
}
set
{
SerializableList = value == null ?
null :
value.ToList();
}
}
[DataMember]
[XmlArray("SerializableList")]
[XmlArrayItem("Pair")]
public List<KeyValuePair<string, int>> SerializableList { get; set; }
}
}
用法很简单——我将一个字典分配给我的数据对象的字典字段 - DictionaryX。通过将分配的字典转换为 KeyValuePair<> 的可序列化 List<>，在 SerializableClassX 内部支持序列化：
// create my data object
SerializableClassX SerializableObj = new SerializableClassX(param);
// this will call the DictionaryX.set and convert the '
// new Dictionary into SerializableList
SerializableObj.DictionaryX = new Dictionary<string, int>
{
{"Key1", 1},
{"Key2", 2},
};
于 2014-01-22T15:18:11.573 回答
0
Sharpeserializer（开源）有一种简单的方法：
http://www.sharpserializer.com/
它可以直接序列化/反序列化字典。
无需使用任何属性标记您的对象，也无需在 Serialize 方法中指定对象类型（参见此处 ）。
通过 nuget 安装：Install-package sharpserializer
然后很简单：
Hello World（来自官方网站）：
// create fake obj
var obj = createFakeObject();
// create instance of sharpSerializer
// with standard constructor it serializes to xml
var serializer = new SharpSerializer();
// serialize
serializer.Serialize(obj, "test.xml");
// deserialize
var obj2 = serializer.Deserialize("test.xml");
于 2016-11-29T06:33:39.083 回答