Sto cercando un oggetto coppia chiave/valore che possa includere in un servizio web.
Ho provato ad usare .NET System.Collections.Generic.KeyValuePair<>
class, ma non serializza correttamente in un servizio web. In un servizio Web, le proprietà Key e Value non sono serializzate, rendendo questa classe inutile, a meno che qualcuno non conosca un modo per risolvere questo problema.
C'è qualche altra classe generica che può essere utilizzata per questa situazione?
Userei la classe .NET System.Web.UI.Pair
, ma usa Object per i suoi tipi. Sarebbe bello usare una classe generica, se non altro per la sicurezza del tipo.
Basta definire una struct/class.
[Serializable]
public struct KeyValuePair<K,V>
{
public K Key {get;set;}
public V Value {get;set;}
}
Non penso che ci sia come Dictionary<>
stesso non è serializzabile in XML, quando ho avuto bisogno di inviare un oggetto dizionario tramite un servizio web ho finito per avvolgere l'oggetto Dictionary<>
me stesso e aggiungendo il supporto per IXMLSerializable
.
/// <summary>
/// Represents an XML serializable collection of keys and values.
/// </summary>
/// <typeparam name="TKey">The type of the keys in the dictionary.</typeparam>
/// <typeparam name="TValue">The type of the values in the dictionary.</typeparam>
[XmlRoot("dictionary")]
public class SerializableDictionary<TKey, TValue> : Dictionary<TKey, TValue>, IXmlSerializable
{
#region Constants
/// <summary>
/// The default XML tag name for an item.
/// </summary>
private const string DEFAULT_ITEM_TAG = "Item";
/// <summary>
/// The default XML tag name for a key.
/// </summary>
private const string DEFAULT_KEY_TAG = "Key";
/// <summary>
/// The default XML tag name for a value.
/// </summary>
private const string DEFAULT_VALUE_TAG = "Value";
#endregion
#region Protected Properties
/// <summary>
/// Gets the XML tag name for an item.
/// </summary>
protected virtual string ItemTagName
{
get
{
return DEFAULT_ITEM_TAG;
}
}
/// <summary>
/// Gets the XML tag name for a key.
/// </summary>
protected virtual string KeyTagName
{
get
{
return DEFAULT_KEY_TAG;
}
}
/// <summary>
/// Gets the XML tag name for a value.
/// </summary>
protected virtual string ValueTagName
{
get
{
return DEFAULT_VALUE_TAG;
}
}
#endregion
#region Public Methods
/// <summary>
/// Gets the XML schema for the XML serialization.
/// </summary>
/// <returns>An XML schema for the serialized object.</returns>
public XmlSchema GetSchema()
{
return null;
}
/// <summary>
/// Deserializes the object from XML.
/// </summary>
/// <param name="reader">The XML representation of the object.</param>
public void ReadXml(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 != XmlNodeType.EndElement)
{
reader.ReadStartElement(ItemTagName);
reader.ReadStartElement(KeyTagName);
TKey key = (TKey)keySerializer.Deserialize(reader);
reader.ReadEndElement();
reader.ReadStartElement(ValueTagName);
TValue value = (TValue)valueSerializer.Deserialize(reader);
reader.ReadEndElement();
this.Add(key, value);
reader.ReadEndElement();
reader.MoveToContent();
}
reader.ReadEndElement();
}
/// <summary>
/// Serializes this instance to XML.
/// </summary>
/// <param name="writer">The writer to serialize to.</param>
public void WriteXml(XmlWriter writer)
{
XmlSerializer keySerializer = new XmlSerializer(typeof(TKey));
XmlSerializer valueSerializer = new XmlSerializer(typeof(TValue));
foreach (TKey key in this.Keys)
{
writer.WriteStartElement(ItemTagName);
writer.WriteStartElement(KeyTagName);
keySerializer.Serialize(writer, key);
writer.WriteEndElement();
writer.WriteStartElement(ValueTagName);
TValue value = this[key];
valueSerializer.Serialize(writer, value);
writer.WriteEndElement();
writer.WriteEndElement();
}
}
#endregion
}
Troverete il motivo per cui KeyValuePairs non può essere serializzato in questo Post del blog MSDN
La risposta di Struct è la soluzione più semplice, tuttavia non è l'unica soluzione. Una soluzione "migliore" è scrivere una classe KeyValurPair personalizzata che sia serializzabile.
[Serializable]
public class SerializableKeyValuePair<TKey, TValue>
{
public SerializableKeyValuePair()
{
}
public SerializableKeyValuePair(TKey key, TValue value)
{
Key = key;
Value = value;
}
public TKey Key { get; set; }
public TValue Value { get; set; }
}
Nel 4.0 Framework, c'è anche l'aggiunta della famiglia di classi Tuple che è serializzabile ed equabile. Puoi usare Tuple.Create(a, b)
o new Tuple<T1, T2>(a, b)
.
Utilizzare DataContractSerializer poiché può gestire la coppia di valori chiave.
public static string GetXMLStringFromDataContract(object contractEntity)
{
using (System.IO.MemoryStream writer = new System.IO.MemoryStream())
{
var dataContractSerializer = new DataContractSerializer(contractEntity.GetType());
dataContractSerializer.WriteObject(writer, contractEntity);
writer.Position = 0;
var streamReader = new System.IO.StreamReader(writer);
return streamReader.ReadToEnd();
}
}
Un KeyedCollection è un tipo di dizionario che può essere serializzato direttamente su xml senza alcuna assurdità. L'unico problema è che devi accedere ai valori di: coll ["chiave"]. Valore;
DataTable
è la mia raccolta preferita per (solo) il wrapping dei dati da serializzare su JSON, dal momento che è facile espandersi senza la necessità di un struct
extra e agisce come una sostituzione serializzabile per Tuple<>[]
Forse non è il modo più pulito, ma preferisco includerlo e usarlo direttamente nelle classi (che devono essere serializzate), invece di dichiarare un nuovo struct
name__
class AnyClassToBeSerialized
{
public DataTable KeyValuePairs { get; }
public AnyClassToBeSerialized
{
KeyValuePairs = new DataTable();
KeyValuePairs.Columns.Add("Key", typeof(string));
KeyValuePairs.Columns.Add("Value", typeof(string));
}
public void AddEntry(string key, string value)
{
DataRow row = KeyValuePairs.NewRow();
row["Key"] = key; // "Key" & "Value" used only for example
row["Value"] = value;
KeyValuePairs.Rows.Add(row);
}
}
XmlSerializer non funziona con dizionari. Oh, e ha anche problemi con KeyValuePairs
http://www.codeproject.com/Tips/314447/XmlSerializer-doesnt-work-with-Dictionaries-Oh-and