Änderung von XML-Baumstrukturen im Arbeitsspeicher im Vergleich zur funktionalen Konstruktion (LINQ to XML)

Zur Änderung der Form eines XML-Dokuments wird üblicherweise die XML-Struktur an Ort und Stelle geändert. Eine typische Anwendung lädt ein Dokument in einen Datenspeicher wie DOM oder LINQ to XML. verwendet eine Programmierschnittstelle, um Knoten einzufügen oder zu löschen oder deren Inhalt zu ändern; und speichert dann den XML-Code in einer Datei oder überträgt ihn über ein Netzwerk.

LINQ to XML ermöglicht einen anderen Ansatz, der in vielen Szenarien nützlich ist: funktionale Konstruktion. Die funktionale Konstruktion behandelt das Ändern von Daten als Problem der Transformation und nicht als detaillierte Manipulation eines Datenspeichers. Wenn Sie eine Darstellung von Daten übernehmen und sie effizient von einem Formular in ein anderes transformieren können, entspricht das Ergebnis dem, wenn Sie einen Datenspeicher genommen und auf irgendeine Weise bearbeitet haben, um ein anderes Shape zu übernehmen. Ein Schlüssel zum funktionalen Konstruktionsansatz besteht darin, die Ergebnisse von Abfragen an die Konstruktoren von XDocument und XElement zu übergeben.

In vielen Fällen können Sie den Transformationscode in einem Bruchteil der Zeit schreiben, die zum Bearbeiten des Datenspeichers erforderlich wäre, und der resultierende Code ist robuster und einfacher zu verwalten. In diesen Fällen kann der Transformationsansatz zwar mehr Verarbeitungsleistung nutzen, aber es ist eine effektivere Möglichkeit, Daten zu ändern. Wenn ein Entwickler mit dem funktionalen Ansatz vertraut ist, ist der resultierende Code in vielen Fällen einfacher zu verstehen, und es ist einfach, den Code zu finden, der jeden Teil der Struktur ändert.

Der Ansatz, bei dem Sie eine XML-Struktur an Ort und Stelle ändern, ist vielen DOM-Programmierern vertrauter, während Code, der nach dem funktionalen Ansatz geschrieben wurde, möglicherweise einem Entwickler, der diesen Ansatz noch nicht versteht, nicht vertraut ist. Wenn Sie nur eine kleine Änderung an einer großen XML-Struktur vornehmen müssen, führt der Ansatz, bei dem Sie den Baum direkt anpassen, in vielen Fällen zu einer geringeren CPU-Zeit.

Dieser Artikel enthält Beispiele für beide Ansätze. Angenommen, Sie möchten das folgende einfache XML-Dokument so ändern, dass die Attribute zu Elementen werden:

<?xml version="1.0" encoding="utf-8" ?>
<Root Data1="123" Data2="456">
  <Child1>Content</Child1>
</Root>

Die ersten der folgenden Beispiele verwenden den herkömmlichen In-Situ-Änderungsansatz und der zweite verwendet den funktionalen Konstruktionsansatz.

Beispiel: Transformieren von Attributen in Elemente mit dem herkömmlichen direkten Ansatz

Sie können einen prozeduralen Code schreiben, um Elemente aus den Attributen zu erstellen, und dann die Attribute wie folgt löschen:

XElement root = XElement.Load("Data.xml");
foreach (XAttribute att in root.Attributes()) {
    root.Add(new XElement(att.Name, (string)att));
}
root.Attributes().Remove();
Console.WriteLine(root);

Dim root As XElement = XElement.Load("Data.xml")
For Each att As XAttribute In root.Attributes()
    root.Add(New XElement(att.Name, att.Value))
Next
root.Attributes().Remove()
Console.WriteLine(root)

Dieses Beispiel erzeugt die folgende Ausgabe:

<Root>
  <Child1>Content</Child1>
  <Data1>123</Data1>
  <Data2>456</Data2>
</Root>

Beispiel: Transformieren von Attributen in Elemente mit dem funktionalen Konstruktionsansatz

Im Gegensatz dazu besteht ein funktionaler Ansatz aus Code, um eine neue Struktur zu bilden, Elemente und Attribute aus der Quellstruktur auszuwählen und entsprechend zu transformieren, sobald sie der neuen Struktur hinzugefügt werden.

XElement root = XElement.Load("Data.xml");
XElement newTree = new XElement("Root",
    root.Element("Child1"),
    from att in root.Attributes()
    select new XElement(att.Name, (string)att)
);
Console.WriteLine(newTree);

Dim root As XElement = XElement.Load("Data.xml")
Dim newTree As XElement = _
    <Root>
        <%= root.<Child1> %>
        <%= From att In root.Attributes() _
            Select New XElement(att.Name, att.Value) %>
    </Root>
Console.WriteLine(newTree)

In diesem Beispiel wird derselbe XML-Code wie im ersten Beispiel ausgegeben. Beachten Sie jedoch, dass Sie die resultierende Struktur des neuen XML im funktionalen Ansatz tatsächlich sehen können. Sie können die Erstellung des Root Elements, den Code, der das Child1 Element aus der Quellstruktur abruft, und den Code sehen, der die Attribute aus der Quellstruktur in Elemente in der neuen Struktur transformiert.

Das funktionale Beispiel in diesem Fall ist weder kürzer noch einfacher als das erste Beispiel. Wenn Sie jedoch viele Änderungen an einer XML-Struktur vornehmen müssen, kann der prozedurale Ansatz ziemlich komplex und unübersichtlich werden. Im Gegensatz dazu, wenn Sie den funktionalen Ansatz verwenden, formen Sie nach wie vor das gewünschte XML, indem Sie Abfragen und Ausdrücke nach Bedarf einbetten, um den gewünschten Inhalt abzurufen. Der funktionale Ansatz liefert Code, der einfacher verwaltet werden kann.

Beachten Sie, dass in diesem Fall der funktionale Ansatz wahrscheinlich nicht ganz so gut wie der Baummanipulationsansatz ausgeführt würde. Das Hauptproblem besteht darin, dass der funktionale Ansatz mehr kurzlebige Objekte erstellt. Der Kompromiss ist jedoch ein effektiver, wenn die Verwendung des funktionalen Ansatzes eine höhere Produktivität des Programmierers ermöglicht.

Dies ist ein sehr einfaches Beispiel, aber es dient dazu, den Unterschied in der Philosophie zwischen den beiden Ansätzen zu zeigen. Der funktionale Ansatz führt zu höheren Produktivitätsgewinnen für die Transformation größerer XML-Dokumente.