Existe-t-il une classe de paire clé / valeur générique sérialisable dans .NET?

Je recherche un object clé / valeur que je peux inclure dans un service Web.

J’ai essayé d’utiliser la classe System.Collections.Generic.KeyValuePair .NET, mais il ne sérialise pas correctement dans un service Web. Dans un service Web, les propriétés Key et Value ne sont pas sérialisées, ce qui rend cette classe inutile, à moins que quelqu’un sache comment résoudre ce problème.

Existe-t-il une autre classe générique pouvant être utilisée pour cette situation?

J’utiliserais la classe System.Web.UI.Pair de .NET, mais elle utilise Object pour ses types. Ce serait bien d’utiliser une classe générique, ne serait-ce que pour la sécurité de type.

Définissez simplement une structure / classe.

 [Serializable] public struct KeyValuePair { public K Key {get;set;} public V Value {get;set;} } 

Je ne pense pas qu’il y ait comme le Dictionary<> lui-même n’est pas XML serializable, quand j’ai eu besoin d’envoyer un object de dictionnaire via un service Web j’ai fini l’object

 ///  /// Represents an XML serializable collection of keys and values. ///  /// The type of the keys in the dictionary. /// The type of the values in the dictionary. [XmlRoot("dictionary")] public class SerializableDictionary : Dictionary, IXmlSerializable { #region Constants ///  /// The default XML tag name for an item. ///  private const ssortingng DEFAULT_ITEM_TAG = "Item"; ///  /// The default XML tag name for a key. ///  private const ssortingng DEFAULT_KEY_TAG = "Key"; ///  /// The default XML tag name for a value. ///  private const ssortingng DEFAULT_VALUE_TAG = "Value"; #endregion #region Protected Properties ///  /// Gets the XML tag name for an item. ///  protected virtual ssortingng ItemTagName { get { return DEFAULT_ITEM_TAG; } } ///  /// Gets the XML tag name for a key. ///  protected virtual ssortingng KeyTagName { get { return DEFAULT_KEY_TAG; } } ///  /// Gets the XML tag name for a value. ///  protected virtual ssortingng ValueTagName { get { return DEFAULT_VALUE_TAG; } } #endregion #region Public Methods ///  /// Gets the XML schema for the XML serialization. ///  /// An XML schema for the serialized object. public XmlSchema GetSchema() { return null; } ///  /// Deserializes the object from XML. ///  /// The XML representation of the object. 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(); } ///  /// Serializes this instance to XML. ///  /// The writer to serialize to. 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 } 

Vous trouverez la raison pour laquelle KeyValuePairs ne peut pas être sérialisé sur ce blog MSDN

La réponse Struct est la solution la plus simple, mais pas la seule. Une “meilleure” solution consiste à écrire une classe KeyValurPair personnalisée qui est sérialisable.

  [Serializable] public class SerializableKeyValuePair { public SerializableKeyValuePair() { } public SerializableKeyValuePair(TKey key, TValue value) { Key = key; Value = value; } public TKey Key { get; set; } public TValue Value { get; set; } } 

Dans le Framework 4.0, il y a aussi l’ajout de la famille de classes Tuple sérialisables et équivoques. Vous pouvez utiliser Tuple.Create(a, b) ou new Tuple(a, b) .

Un KeyedCollection est un type de dictionnaire qui peut être directement sérialisé en XML sans aucune absurdité. Le seul problème est que vous devez accéder aux valeurs par: coll [“key”]. Value;

XmlSerializer ne fonctionne pas avec les dictionnaires. Oh, et il a aussi des problèmes avec KeyValuePairs

http://www.codeproject.com/Tips/314447/XmlSerializer-doesnt-work-with-Dictionaries-Oh-and

Utilisez le DataContractSerializer car il peut gérer la paire de valeurs de clé.

  public static ssortingng GetXMLSsortingngFromDataContract(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(); } } 

Vous pouvez utiliser Tuple

voir ceci pour plus de détails sur l’utilisation de Tuple : Travailler avec Tuple en C # 4.0