Speicher einer Generischen Liste in den Application Storage

Im letzten Post haben ich gezeigt wie wir eine Klasse in ein XML Serializieren und Deserializieren können, nun wollen wir unsere erzeugten XML Daten auch als StorageFile im Lokalen Applikation Verzeichnis Speicher.

 //Vergeben des Dateinamen
 string fileName = „TrackinData“;

 //Erzeugen des XML
 string localData = ObjectSerializer>.ToXml(list);
 if (!string.IsNullOrEmpty(localData))
 {
    //Erstellen der Datei und Speichern im Lokalen Verzeichnis
    StorageFile localFile = await ApplicationData.Current.LocalFolder.CreateFileAsync(string.Format("{0}.xml", fileName), CreationCollisionOption.ReplaceExisting);
    await FileIO.WriteTextAsync(localFile, localData);
 }

Um die Daten wieder zu laden muss die Entsprechende Datei aus dem Lokalen Applikation Verzeichnis geladen werden und das erhaltene XML wieder Deserializieren werden.

  StorageFile localFile;
  ObservableCollection itemCollection = new ObservableCollection();
  Try
  {
      localFile = await ApplicationData.Current.LocalFolder.GetFileAsync("localData.xml");
  }
  catch (FileNotFoundException)
  {
      localFile = null;
  }
  
  if (localFile != null)
  {
      string localData = await FileIO.ReadTextAsync(localFile);
      itemCollection = ObjectSerializer>.FromXml(localData);
  }

Serializing / Deserializing objects in und aus einem XML

Zum Speicher und Austausch von Daten und Einstellungen greife ich gerne auf XML-Dateien zurück. Um diese zu erstellen habe ich bei http://www.getcodesamples.com/ eine recht elegante Lösung gefunden.

Mit Hilfe der ObjectSerializer Klasse kann man ganz einfach eine Klasse oder eine generische Liste in ein XML umwandeln.

ObjectSerializer Klasse

    internal static class ObjectSerializer
    {
        // Serialize to xml 
        public static string ToXml(T value)
        {
            XmlSerializer serializer = new XmlSerializer(typeof(T));
            StringBuilder stringBuilder = new StringBuilder();
            XmlWriterSettings settings = new XmlWriterSettings()
            {
                Indent = true,
                OmitXmlDeclaration = true,
            };
            using (XmlWriter xmlWriter = XmlWriter.Create(stringBuilder, settings))
            {
                serializer.Serialize(xmlWriter, value);
            }
            return stringBuilder.ToString();
        }

        // Deserialize from xml 
        public static T FromXml(string xml)
        {
            T value;
            object empty = null;
            value = (T)empty;
            Try
            {
                XmlSerializer serializer = new XmlSerializer(typeof(T));
                using (StringReader stringReader = new StringReader(xml))
                {
                    object deserialized = serializer.Deserialize(stringReader);
                    value = (T)deserialized;
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);               
            }

Hierfür müssen in den zu Serializierenden Klassen XMLRootElemet Attribute gesetzt werden. Damit diese als root gekennzeichnet wird.

    [XmlRoot(ElementName = " XMLExampleClass ")]
    public class XMLExampleClass
    {

Entsprechend kann dann die Klasse unter Verwendung der Methode ToXml in ein XML Serializiert werde und mit der Methode FromXml wieder Deserializiert.

    XMLExampleClass instance = new XMLExampleClass();
    instance.Id = 0;
    instance.Name = “Test”

    // Serialize to xml 
    string localXml = ObjectSerializer.ToXml(instance);

   // Deserialize from xml
   XMLExampleClass instanceFromXml = ObjectSerializer.FromXml(localXml);