LINQ to XML: XDocument, XElement

1. Einführung

Das Auftauchen von LINQ war eine Revolution beim Arbeiten mit XML in .NET. Wenn man früher um XML zu ändern umständliche Konstrukte mit NodeList und XmlElement schreiben musste, kann man jetzt alle Operationen im LINQ-Stil ausdrücken. Das ist, als würdest du nach langem Umherirren über Schotterstraßen auf die schnelle Autobahn wechseln.

LINQ to XML löst drei Hauptaufgaben:

• Vereinfacht die Syntax zum Erstellen und Lesen von XML.
• Macht die Navigation durch das Dokument ähnlich wie die Arbeit mit Collections.
• Ermöglicht die Integration von XML in beliebige LINQ-Queries.

Hauptklassen: XDocument, XElement, XAttribute

Bevor wir uns in die tiefen Gewässer von LINQ to XML stürzen, lernen wir die drei Säulen kennen:

• XDocument — das Root des gesamten Dokuments, analog zum Buchrücken, in dem alles enthalten ist.
• XElement — ein einzelner XML-Knoten (Element). Das ist wie eine einzelne Kiste im Lager, die andere Kisten oder Waren (Elemente, Attribute und Text) enthalten kann.
• XAttribute — ein Attribut eines Elements, z.B. <User id="42" />.

Visuelle Darstellung

+-----------------+
|   XDocument     |---------------------+
+-----------------+                     |
            |                      (Root XElement)
            v                           |
      +-------------+              +-----------------+
      |   XElement  |<-------------| XElement (root) |
      +-------------+              +-----------------+
            |                              |
        (XAttribute)                (nested XElements)

2. XML lesen mit LINQ to XML

Angenommen, in unserer Lernanwendung (z.B. ein Adressbuch) wollen wir Kontakte aus einer XML-Datei lesen. Die Datei hat zum Beispiel diese Struktur:

<Contacts>
  <Person id="1">
    <Name>Ivan Ivanov</Name>
    <Email>ivan@example.com</Email>
    <Phones>
      <Phone type="mobile">+12 999 123-45-67</Phone>
      <Phone type="home">+12 812 123-45-67</Phone>
    </Phones>
  </Person>
  <Person id="2">
    <Name>Maria Petrova</Name>
    <Email>maria@example.com</Email>
    <Phones>
      <Phone type="mobile">+12 921 123-45-67</Phone>
    </Phones>
  </Person>
</Contacts>

XML in den Speicher lesen

Zuerst fügen wir die using-Direktive ins Projekt:

using System.Xml.Linq;

Nun lesen wir die Datei oder den String:

// Angenommen xmlString enthält das XML-Dokument, oder man kann XDocument.Load("contacts.xml") verwenden
var doc = XDocument.Parse(xmlString);

// Liste von Person bekommen
var persons = doc.Root.Elements("Person");

foreach (var person in persons)
{
    string name = person.Element("Name")?.Value ?? "Bez imeni";
    string email = person.Element("Email")?.Value ?? "Bez e-mail";
    string id = person.Attribute("id")?.Value ?? "net id";
    
    Console.WriteLine($"Imya: {name}, Email: {email}, id: {id}");
}

- doc.Root liefert das Root-Element (Contacts).
- Elements("Person") gibt alle <Person>-Elemente zurück.
- Danach greifen wir auf benötigte Elemente/Attribute mit .Element("...") oder .Attribute("...") zu.
- Der Operator ?. schützt vor Fehlern, falls ein Element/Attribut nicht gefunden wird.

Analogie

Mit XElement zu arbeiten ist wie Matroschka auspacken: du nimmst eine heraus, darin sind weitere, und so weiter. Nur dass das jetzt mit einer kurzen Query und nicht mit umständlichen Traversals passiert.

3. LINQ-Queries über XML schreiben

Willst du alle mobilen Telefonnummern aller Personen bekommen? Kein Problem, das geht im LINQ-Stil!

var mobilePhones = doc
    .Descendants("Phone") // sucht alle Phone auf beliebigem Level
    .Where(p => (string)p.Attribute("type") == "mobile")
    .Select(p => p.Value);

foreach (string phone in mobilePhones)
{
    Console.WriteLine($"Mobilnyj: {phone}");
}

- Descendants("Phone") sucht alle <Phone>-Tags im Dokument.
- Attribute("type") — Attribut holen.
- Das Casten (string) auf ein Attribut liefert automatisch einen String oder null.

Coole Tricks

Du kannst über mehrere Ebenen hinweg suchen, ohne dir Sorgen über komplexe Verschachtelungen zu machen. Das würde mit einfachem XmlDocument deutlich umständlicher.

4. XML "on the fly" erstellen und ändern

XML lässt sich bequem im Speicher mit den Konstruktoren von XElement und XDocument erzeugen. Hier ein Beispiel, wie man eine neue Person zum Dokument hinzufügt (Teil unserer "wachsenden Lern-App"):

// Neue Person erstellen
var newPerson = new XElement("Person",
    new XAttribute("id", "3"),
    new XElement("Name", "Sergej Novikov"),
    new XElement("Email", "sergey@example.com"),
    new XElement("Phones",
        new XElement("Phone", new XAttribute("type", "work"), "+12 812 987-65-43")
    )
);

// Zum Root hinzufügen
doc.Root.Add(newPerson);

// Zurück in die Datei speichern (oder in einen String)
doc.Save("contacts.xml");

Kommentare:

- Du kannst Elemente mit "Matroschka"-Konstruktoren verschachteln: das erste Argument ist das Tag, die restlichen sind der Inhalt (können Elemente, Attribute, Text sein).
- Attribute stehen immer vor dem direkten Inhalt (also <Phone type="work">...).

5. Interaktion mit C#-Collections — die Magie von LINQ

Oft will man eine normale Collection von Objekten (z.B. List<Person>) in XML serialisieren oder umgekehrt. Das geht sehr einfach, praktisch in einer LINQ-Zeile:

var people = new List<Person>
{
    new Person { Id = 1, Name = "Ivan Ivanov", Email = "ivan@example.com" },
    // usw.
};

var doc = new XDocument(
    new XElement("Contacts",
        people.Select(p =>
            new XElement("Person",
                new XAttribute("id", p.Id),
                new XElement("Name", p.Name),
                new XElement("Email", p.Email)
            )
        )
    )
);

Die Klasse Person sieht so aus (für das Gesamtbild):

public class Person
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string Email { get; set; }
}

Jetzt hast du eine einfache, verständliche und kontrollierte Transformation einer C#-Collection in XML!

6. Nützliche Methoden und Tricks für XElement und XDocument

Navigation

• .Elements("TagName") — alle direkten Child-Elemente (direkte Nachkommen).
• .Descendants("TagName") — alle verschachtelten Elemente irgendwo innerhalb des aktuellen Elements.
• .Parent — das Elternelement.
• .Ancestors() — alle Vorfahren des Elements (nützlich, um einen Pfad zu finden).
• .FirstNode, .LastNode, .NextNode, .PreviousNode — Navigation zwischen Nachbarn.

Suche mit Bedingungen

var personsWithEmail = doc.Root
    .Elements("Person")
    .Where(p => !string.IsNullOrEmpty((string)p.Element("Email")));

Hinzufügen und Entfernen

// Ein Telefon zu einem existierenden Nutzer hinzufügen
var maria = doc.Root.Elements("Person")
    .FirstOrDefault(p => (string)p.Element("Name") == "Maria Petrova");

maria?.Element("Phones")?.Add(
    new XElement("Phone", new XAttribute("type", "work"), "+12 812 111-22-33")
);

// Nutzer nach id löschen
doc.Root.Elements("Person")
    .Where(p => (string)p.Attribute("id") == "3")
    .Remove();

Zurück in String/Datei konvertieren

string xmlText = doc.ToString(); // mit Einrückungen
doc.Save("contacts.xml");

7. Nützliche Feinheiten

Vergleich: LINQ to XML vs. andere Ansätze in .NET

XmlDocument

XmlSerializer

LINQ to XML

Anwendung in echten Projekten und im Vorstellungsgespräch

• Parsing von Konfigurationsdateien, wo keine klare Abbildung auf C#-Klassen existiert.
• Import/Export von Daten (z.B. Export/Import von Benutzerdaten).
• Migrationsszenarien, Verarbeitung von "schmutzigem" oder komplexem XML.
• Schnelle Transformationen (z.B. Umwandlung von einem XML-Format in ein anderes).

"Warum sollte ich das wissen?" — im Vorstellungsgespräch könnte man dich bitten, ein komplexes XML zu transformieren oder zu parsen. Mit LINQ to XML gelingt das oft einfacher und eleganter als mit älteren APIs.

8. Typische Fehler beim Arbeiten mit LINQ to XML

Fehler Nr.1: Versuch, auf ein fehlendes Element ohne Prüfung zuzugreifen.
Wenn ein Element fehlen kann, benutze den Operator ?. oder prüfe vorher auf null. Ansonsten bekommst du eine NullReferenceException und einen unerwarteten Laufzeitfehler.

Fehler Nr.2: Verwechslung zwischen Attributen und Elementen.
Attribute und Elemente sind unterschiedliche Entitäten im XML. Manchmal sind Daten auf die beiden verteilt. Zum Beispiel:

<User login="admin"><Status>active</Status></User>

Um den Wert des Attributs login zu bekommen, verwende .Attribute("login"), für den Inhalt des Tags <Status> nutze .Element("Status").

Fehler Nr.3: Missverständnis über das Verhalten von .Remove().
Die Methode .Remove() verändert die XML-Struktur im Speicher sofort. Sie gibt nichts zurück und das Löschen kann nicht rückgängig gemacht werden. Anfänger erwarten manchmal, dass sie die entfernten Elemente zurückbekommen oder dass die Methode etwas signalisiert — das tut sie nicht.