it-swarm.com.de

Wie serialisiere/deserialize zu `Dictionary <int, string>` von benutzerdefiniertem XML, das XElement nicht verwendet?

Mit leerem Dictionary<int, string>, wie man ihn mit Schlüsseln und Werten aus XML füllen kann 

<items>
<item id='int_goes_here' value='string_goes_here'/>
</items>

und serialisieren Sie es wieder in XML, ohne XElement zu verwenden?

42
myWallJSON

Mit Hilfe einer temporären item-Klasse

public class item
{
    [XmlAttribute]
    public int id;
    [XmlAttribute]
    public string value;
}

Beispielwörterbuch:

Dictionary<int, string> dict = new Dictionary<int, string>()
{
    {1,"one"}, {2,"two"}
};

.

XmlSerializer serializer = new XmlSerializer(typeof(item[]), 
                                 new XmlRootAttribute() { ElementName = "items" });

Serialisierung

serializer.Serialize(stream, 
              dict.Select(kv=>new item(){id = kv.Key,value=kv.Value}).ToArray() );

Deserialisierung

var orgDict = ((item[])serializer.Deserialize(stream))
               .ToDictionary(i => i.id, i => i.value);

-------------------------------------------------- ----------------------------

So können Sie es tun mit XElement, wenn Sie Ihre Meinung ändern.

Serialisierung

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(...);

Deserialisierung

XElement xElem2 = XElement.Parse(xml); //XElement.Load(...)
var newDict = xElem2.Descendants("item")
                    .ToDictionary(x => (int)x.Attribute("id"), x => (string)x.Attribute("value"));
94
L.B

Paul Welter's ASP.NET Blog hat ein Wörterbuch, das serialisierbar ist. Es werden jedoch keine Attribute verwendet. Ich erkläre warum unter dem Code.

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
}

Erstens gibt es ein Problem mit diesem Code. Angenommen, Sie lesen ein Wörterbuch aus einer anderen Quelle, das Folgendes enthält:

<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>

Dies führt zu einer Ausnahme bei der De-Seariazation, da für ein Wörterbuch nur ein Schlüssel vorhanden ist.


Der Grund, warum Sie ein XElement in einem seriazed-Wörterbuch verwenden MÜSSEN, ist, dass das Wörterbuch nicht als Dictionary<String,String> definiert ist. Ein Wörterbuch ist Dictionary<TKey,TValue>.

Um das Problem zu sehen, fragen Sie sich selbst: Nehmen wir an, wir haben eine TValue, die in etwas serialisiert, das Elemente verwendet, die sich selbst als XML beschreiben (sagen wir ein Wörterbuch mit Wörterbüchern Dictionary<int,Dictionary<int,string>> (nicht ungewöhnlich eines Musters, es ist eine Nachschlagetabelle) , wie würde Ihre reine Attributversion ein Wörterbuch vollständig innerhalb eines Attributs darstellen?

27

Wörterbücher sind standardmäßig nicht in C # serialisierbar, ich weiß nicht warum, aber es scheint eine Designwahl gewesen zu sein.

Im Moment empfehle ich die Verwendung von Json.NET , um es in JSON und von dort in ein Wörterbuch (und umgekehrt) zu konvertieren. Wenn Sie das XML wirklich nicht benötigen, würde ich empfehlen, JSON vollständig zu verwenden.

5

Ich habe eine struct 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, "") + "]";
    }
}

Anschließend erfolgt die XML-Serialisierung einer Dictionary-Eigenschaft wie folgt:

[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);
    }
}

Nur die Eigenschaft muss das Array sein, nicht die Liste.

3
xmedeko

Basierend auf der Antwort von L. B.

Verwendungszweck:

var serializer = new DictionarySerializer<string, string>();
serializer.Serialize("dictionary.xml", _dictionary);
_dictionary = _titleDictSerializer.Deserialize("dictionary.xml");

Generische Klasse:

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());
        }
    }
}
3
Jbjstam

Sie können ExtendedXmlSerializer verwenden. Wenn Sie eine Klasse haben:

public class TestClass
{
    public Dictionary<int, string> Dictionary { get; set; }
}

und erstellen Sie eine Instanz dieser Klasse:

var obj = new TestClass
{
    Dictionary = new Dictionary<int, string>
    {
        {1, "First"},
        {2, "Second"},
        {3, "Other"},
    }
};

Sie können dieses Objekt mit ExtendedXmlSerializer serialisieren:

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);

Ausgabe-XML sieht wie folgt aus:

<?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>

Sie können ExtendedXmlSerializer von nuget installieren oder den folgenden Befehl ausführen:

Install-Package ExtendedXmlSerializer
2
Wojtpl2

Schreiben Sie eine Klasse A, die ein Array der Klasse B enthält. Klasse B sollte eine id-Eigenschaft und eine value-Eigenschaft haben. Deserialisieren Sie die XML in Klasse A. Konvertieren Sie das Array in A in das gewünschte Wörterbuch. 

Um das Wörterbuch zu serialisieren, konvertieren Sie es in eine Instanz der Klasse A und serialisieren Sie ...

2
erikH

Ich verwende serialisierbare Klassen für die WCF-Kommunikation zwischen verschiedenen Modulen . Nachfolgend finden Sie ein Beispiel für serialisierbare Klassen, die auch als DataContract dienen . Mein Ansatz besteht darin, LINQ zu verwenden, um das Dictionary in out-of-of- Die serialisierbare Liste <> von KeyValuePair <>:

    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; }
        }
    }

Die Verwendung ist unkompliziert. Ich ordne dem Wörterbuchfeld meines Datenobjekts ein Wörterbuch zu - DictionaryX. Die Serialisierung wird innerhalb der SerializableClassX durch Konvertierung des zugewiesenen Wörterbuchs in die serialisierbare Liste <> von KeyValuePair <> unterstützt:

    // 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},
    };
1
Michael G

KeyedCollection funktioniert wie ein Wörterbuch und ist serialisierbar.

Erstellen Sie zuerst eine Klasse mit Schlüssel und Wert:

/// <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;
}

erstellen Sie dann eine Klasse vom Typ KeyedCollection und definieren Sie eine Eigenschaft Ihrer Klasse als Schlüssel.

/// <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;
    }
}

Nützlich, um solche Datentypen zu serialisieren.

1
Smartoweb

Mit Sharpeserializer (Open Source) gibt es einen einfachen Weg:

http://www.sharpserializer.com/

Es kann das Wörterbuch direkt serialisieren/de-serialisieren.

Sie müssen Ihr Objekt nicht mit einem beliebigen Attribut markieren, und Sie müssen den Objekttyp in der Serialize-Methode angeben (siehe hier ).

Installation über Nuget: Install-package sharpserializer

Dann ist es sehr einfach:

Hello World (von der offiziellen Website):

// 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");
0
Malick