Hi
In den letzten Tagen hab ich mich mit OpenXML auseinandergesetzt.
Jedoch sind alle Tutorials, die man findet, für veraltete XDOM Versionen und unterscheiden sich sehr von der aktuellen.
Darum hab ich mich entschlossen, selbst ein Tutorial für OpenXML XDOM 4.1 zu schreiben.
Das Tutorial ist für Einsteiger in XDOM und behandelt nur einfache Funktionen.
Erstellen & Speichern
Beginnen wir damit eine XML Datei zu erstellen.
Auf die Form kommt ein Memo, ein Button und ein TDomImplementation.
Ins Button1Click schreiben wir folgendes:
Delphi-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
| procedure TForm1.Button1Click(Sender: TObject);
var
FDoc: TDomDocument;
FNodeElement: TDomElement;
FNodeText: TDomText;
FNodeComment: TDomComment;
begin
FDoc := TDomDocument.Create(DomImplementation1);
end; |
Damit erstellen wir ein neues DomDocument.
Jetzt müssen wir unseren RootNode erstellen:
Delphi-Quelltext
1:
2:
| FNodeElement := TDomElement.Create(FDoc, 'RootNode');
FDoc.AppendChild(FNodeElement); |
Wir erstellen einen weiteren Knoten als Child:
Delphi-Quelltext
1:
2:
| FNodeElement := TDomElement.Create(FDoc, 'NodeGroup');
FDoc.FindFirstChildElement.AppendChild(FNodeElement); |
FDoc.FindFirstChildElement gibt uns den ersten ChildNode, also hier den RootNode zurück.
Und noch ein Knoten als dessen Child:
Delphi-Quelltext
1:
2:
| FNodeElement := TDomElement.Create(FDoc, 'Node1');
FDoc.FindFirstChildElement.ChildNodes.Item(0).AppendChild(FNodeElement); |
ChildNodes.Item(0) gibt uns ebenfalls den ersten ChildNode zurück.
Man hätte auch
FindFirstChildElement.FindFirstChildElement schreiben können.
Diesem Knoten fügen wir jetzt Text hinzu:
Delphi-Quelltext
1:
2:
3:
| FNodeText := TDomText.Create(FDoc);
FNodeText.NodeValue := 'Text1';
FDoc.FindFirstChildElement.ChildNodes.Item(0).FindFirstChildElement.AppendChild(FNodeText); |
In der XML-Datei sieht das dann so aus
<Node1>Text1</Node1>.
Nun machen wir noch einen zweiten Knoten in unsere NodeGroup und fügen Text hinzu:
Delphi-Quelltext
1:
2:
3:
4:
5:
6:
| FNodeElement := TDomElement.Create(FDoc, 'Node2');
FDoc.GetElementsByTagName('NodeGroup').Item(0).AppendChild(FNodeElement);
FNodeText := TDomText.Create(FDoc);
FNodeText.NodeValue := 'Text2';
FDoc.GetElementsByTagName('Node2').Item(0).AppendChild(FNodeText); |
GetElementsByTagName('NodeGroup').Item(0) gibt uns das erste Element mit dem Namen 'NodeGroup' zurück.
Das zuweisen von Attributen geht ganz einfach:
Delphi-Quelltext
1:
| FDoc.FindFirstChildElement.SetAttribute('Attr1', 'Wert1'); |
So haben wir unserem RootNode ein Attribut gegeben.
Dem zweiten Node in unserer NodeGroup fügen wir 2 Attribute zu:
Delphi-Quelltext
1:
2:
3:
4:
5:
| with TDomElement(FDoc.GetElementsByTagName('NodeGroup').Item(0).ChildNodes.Item(1)) do
begin
SetAttribute('Attr2', 'Wert2');
SetAttribute('Attr3', 'Wert3');
end; |
ChildNodes.Item(1) gibt uns den zweiten Knoten als TDomNode zurück.
Um SetAttribute benutzen zu können, müssen wir es zu TDomElement "erweitern" (Wie nennt man das?).
Delphi-Quelltext
1:
2:
3:
| FNodeComment := TDomComment.Create(FDoc);
FNodeComment.NodeValue := 'Kommentar';
FDoc.FindFirstChildElement.AppendChild(FNodeComment); |
Damit haben wir jetzt noch einen Kommentar eingefügt.
Zum Schluss wollen wir die XML-Datei ausgeben.
Dazu kommt ein TDomToXmlParser auf die Form, dessen DOMImpl wir auf unseren DomImplementation1 verlinken.
Die XML-Datei geben wir jetzt in das Memo aus:
Delphi-Quelltext
1:
2:
3:
| var s: String;
DomToXmlParser1.WriteToString(FDoc, 'UTF-8', s);
Memo1.Text := s; |
Der Umweg über s ist nötig.
XDOM gibt die XML-Datei ohne Formatierung, als einzeiligen String aus.
Wenn man noch ein paar Zeilenumbrüche reinmacht sieht das Ergebnis so aus:
XML-Daten
1:
2:
3:
4:
5:
6:
7:
8:
| <?xml version="1.0" encoding="UTF-8"?>
<RootNode Attr1="Wert1">
<NodeGroup>
<Node1>Text1</Node1>
<Node2 Attr2="Wert2" Attr3="Wert3">Text2</Node2>
</NodeGroup>
</RootNode> |
So speichert man die XML in eine Datei:
Delphi-Quelltext
1:
2:
3:
4:
| var Stream: TFileStream;
Stream := TFileStream.Create('test.xml', fmCreate);
DomToXmlParser1.WriteToStream(FDoc, 'UTF-8', Stream);
Stream.Free; |
Das Projekt hab ich bis hier, als OpenXMLTutorialSpeichern.zip angehängt.
Um die XML-Datei formatiert auszugeben, kann man Zeilenumbrüche und Leerstellen einfügen:
Delphi-Quelltext
1:
2:
3:
| FNodeText := TDomText.Create(FDoc);
FNodeText.NodeValue := #10#32#32;
FDoc.FindFirstChildElement.AppendChild(FNodeText); |
Dies macht einen Zeilenumbruch #10 und zwei Leerstellen #32.
Das komplette Projekt mit formatiertem Erstellen und Speichern, hab ich als OpenXMLTutorialFormatiertSpeichernLaden.zip angehängt.
Laden & Auslesen
Nun wollen wir die XML-Datei laden und die Werte auslesen.
Dazu kommt ein TXmlToDomParser auf die Form, dessen DOMImpl wir wieder auf unseren DomImplementation1 verlinken.
Im Memo steht der XML-Code von oben.
Und ein zweiter Button in den wir schreiben:
Delphi-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
| procedure TForm1.Button2Click(Sender: TObject);
var
FInputSource: TXMLInputSource;
FDoc: TDomDocument;
begin
FInputSource := TXMLInputSource.Create(Memo1.Text, '', '', 1024, False, 0, 0, 0, 0, 1);
FDoc := XmlToDomParser1.Parse(FInputSource);
FInputSource.Free;
end; |
Man kann auch aus einer Datei laden:
Delphi-Quelltext
1:
| FDoc := XMLToDomParser1.ParseFile('test.xml', False); |
Nun wollen wir die Werte auslesen
Für den Namen eines Tags:
Delphi-Quelltext
1:
| ShowMessage(FDoc.FindFirstChildElement.NodeName); |
Gibt 'RootNode' zurück.
Für den Wert eines Tags:
Delphi-Quelltext
1:
| ShowMessage(FDoc.GetElementsByTagName('Node1').Item(0).ChildNodes.Item(0).NodeValue); |
Gibt 'Text1' zurück.
Für das Attribut eines Tags:
Delphi-Quelltext
1:
| ShowMessage(FDoc.FindFirstChildElement.Attributes.Item(0).NodeValue); |
Gibt 'Wert1' zurück.
Oder:
Delphi-Quelltext
1:
| ShowMessage(FDoc.GetElementsByTagName('Node2').Item(0).Attributes.GetNamedItem('Attr3').NodeValue); |
Gibt 'Wert3' zurück.
Und für einen Kommentar:
Delphi-Quelltext
1:
| ShowMessage(FDoc.FindFirstChildElement.ChildNodes.Item(3).NodeValue); |
Gibt 'Kommentar' zurück.
Am Ende sollte man immer FDoc.Free; nicht vergessen.
Das komplette Projekt mit formatiertem Erstellen, Speichern, Laden und Auslesen, hab ich als OpenXMLTutorialFormatiertSpeichernLaden.zip angehängt.
Wer sich weiter mit OpenXML beschäftigen will, kann sich die Tutorials zu älteren Versionen anschauen.
Zum Beispiel den Quelltext der
WDOMXMLDocument.pas von
UGrohne.
Vieles konnte ich mir daraus herleiten. Danke!
Ein anderes Tutorial ist
Dynamically Creating an XML Document in Delphi.
So, das war mein erstes Tutorial.
Kommentare und Verbesserungsvorschläge sind erwünscht!
MfG
Crossposting DP
Moderiert von Christian S.: Topic aus VCL (Visual Component Library) verschoben am So 17.12.2006 um 20:05
