Arbeiten mit XmlSerializer für Serialisierung nach XML

1. Einführung

XML — Abkürzung für eXtensible Markup Language. Stell dir ein sehr strenges und gesprächiges JSON vor, das ständig sagt „ich bin strukturiert, glaub mir!“. XML ist ein textbasiertes Format, in dem Daten von Tags umschlossen werden:

<Player>
  <Name>Aragorn</Name>
  <Health>100</Health>
</Player>

Warum sollten wir heutzutage Objekte in XML serialisieren?

• XML wird weiterhin häufig bei der Integration zwischen großen (oft „Legacy“-) Systemen verwendet, wo nicht nur die Struktur zählt, sondern auch Validierung gegen strenge Schemata (XSD).
• XML wird oft in Unternehmenskonfigurationen eingesetzt (z.B. App.config und Web.config in älteren .NET-Versionen).
• XML eignet sich sehr gut für Szenarien, in denen die „Selbstbeschreibung“ der Datenstruktur wichtig ist.

Interessante Tatsache: XML wurde von Anfang an so entworfen, dass es möglichst „erweiterbar“ und validierbar ist; daher auch der Name. Man kann XML gegen ein Schema prüfen — etwas, das JSON nicht von Haus aus bietet.

XmlSerializer: unser Hauptdarsteller

In .NET ist für die Serialisierung von Objekten nach XML die Klasse System.Xml.Serialization.XmlSerializer zuständig.

• Er wandelt öffentliche Eigenschaften und Felder eines Objekts in XML-Elemente um und umgekehrt: aus XML stellt er das Objekt wieder her.
• Funktioniert nur mit öffentlichen Typen und Mitgliedern von Klassen.
• Serialisiert keine privaten Felder und Eigenschaften — nur das, was öffentlich ist!
• Erfordert, dass die zu serialisierende Klasse einen parameterlosen Konstruktor hat.

Achte darauf: Wenn deine Klasse diese Voraussetzungen nicht erfüllt, kann der XmlSerializer nicht mit ihr arbeiten — er wird bei Serialisierung oder Deserialisierung eine Ausnahme werfen.

2. Einfaches Beispiel — ein Objekt in XML serialisieren

Schauen wir uns an, wie man unsere Lieblingsklasse Player in XML serialisiert.

Schritt 1. Klasse beschreiben

public class Player
{
    public string Name { get; set; }
    public int Health { get; set; }
    public bool IsAlive { get; set; }

    // Wichtig: ein öffentlicher parameterloser Konstruktor ist nötig!
    public Player() { }

    // Optional: zur Bequemlichkeit
    public Player(string name, int health, bool isAlive)
    {
        Name = name;
        Health = health;
        IsAlive = isAlive;
    }
}

Schritt 2. In eine Datei serialisieren

using System.Xml.Serialization;

Player aragorn = new Player("Aragorn", 100, true);

// 1. Erstellen des Serializers für den Typ Player
XmlSerializer serializer = new XmlSerializer(typeof(Player));

// 2. Datei zum Schreiben öffnen (wird erstellt, wenn sie nicht existiert)
using FileStream fs = new FileStream("player.xml", FileMode.Create);

// 3. Objekt in XML serialisieren
serializer.Serialize(fs, aragorn);

Ergebnis (player.xml):

<?xml version="1.0"?>
<Player xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
        xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <Name>Aragorn</Name>
  <Health>100</Health>
  <IsAlive>true</IsAlive>
</Player>

Visuelle Darstellung des einfachen Ablaufs

Objekt im Speicher  --->  XmlSerializer.Serialize()  --->  XML-Datei auf der Festplatte

3. Deserialisierung — das Objekt aus XML „wiederbeleben“

Wenn wir ein früher serialisiertes Objekt lesen wollen, läuft der Prozess umgekehrt:

using FileStream fs = new FileStream("player.xml", FileMode.Open);
XmlSerializer serializer = new XmlSerializer(typeof(Player));
Player player = (Player)serializer.Deserialize(fs);

Console.WriteLine($"Name: {player.Name}, Gesundheit: {player.Health}, Lebt: {player.IsAlive}");

Als Ergebnis gibt das Programm aus: Name: Aragorn, Gesundheit: 100, Lebt: True

4. Serialisierung in einen String — nicht nur in eine Datei

Serialisierung in einen String

Man will nicht immer in eine Datei serialisieren. Manchmal möchtest du das XML als String über das Netzwerk schicken oder auf dem Bildschirm anzeigen.

using System.IO;
using System.Xml.Serialization;

Player player = new Player("Frodo", 42, true);

XmlSerializer serializer = new XmlSerializer(typeof(Player));
StringWriter stringWriter = new StringWriter();
serializer.Serialize(stringWriter, player);

string xmlString = stringWriter.ToString();
Console.WriteLine(xmlString); // Der gesamte XML-String — auf dem Bildschirm!

Deserialisierung aus einem String

Ähnlich kannst du ein Objekt nicht aus einer Datei, sondern aus einem String deserialisieren:

string xml = "<Player Name=\"Frodo\"><HP>42</HP></Player>";
XmlSerializer serializer = new XmlSerializer(typeof(Player));

using StringReader stringReader = new StringReader(xml);
Player frodo = (Player)serializer.Deserialize(stringReader);
Console.WriteLine(frodo.Name); // Frodo

5. XML-Anpassung: Attribute zur Steuerung der Struktur

Manchmal reicht das Standardverhalten nicht. Das erzeugte XML ist zu wortreich oder die Tags passen nicht zum Ziel. Dafür gibt es verschiedene „magische“ Attribute — sie sagen dem Serializer genau, wie er Mitglieder der Klasse darstellen soll.

Die nützlichsten:

• [XmlElement]

  — benennt das Element.

• [XmlAttribute]

  — macht ein Feld zu einem XML-Attribut statt zu einem Element.

• [XmlIgnore]

  — schließt eine Eigenschaft von der Serialisierung aus.

• [XmlArray]

  und

  [XmlArrayItem]

  — steuern das Packaging von Collections.

Beispiel für die Verwendung:

public class Player
{
    [XmlAttribute]
    public string Name { get; set; }
    [XmlElement("HP")]
    public int Health { get; set; }
    [XmlIgnore]
    public bool IsTempSessionPlayer { get; set; }
}

Resultierendes XML:

<Player Name="Aragorn">
  <HP>100</HP>
</Player>

Tabelle der wichtigsten Attribute für die Serialisierung

[XmlAttribute]

<Player Name="Aragorn">...</Player>

[XmlElement]

<HP>100</HP>

<Health>100</Health>

[XmlIgnore]

[XmlArray]

<Heroes> ... </Heroes>

[XmlArrayItem]

<Hero>...</Hero>

Beispiel für komplexe Serialisierung einer Collection:

public class GameWorld
{
    [XmlArray("Heroes")]
    [XmlArrayItem("Hero")]
    public List<Player> Players { get; set; } = new List<Player>();
}

XML:

<GameWorld>
  <Heroes>
    <Hero Name="Legolas">
      <HP>90</HP>
    </Hero>
    <!-- ... -->
  </Heroes>
</GameWorld>

Mehr zur Anpassung von XML erfährst du in den nächsten Lektionen! :P