AGB  ·  Datenschutz  ·  Impressum  







Anmelden
Nützliche Links
Registrieren
Zurück Delphi-PRAXiS Tutorials Delphi OpenXML XDOM 4.1 Tutorial

OpenXML XDOM 4.1 Tutorial

Ein Tutorial von Coder90 · begonnen am 17. Dez 2006 · letzter Beitrag vom 4. Mär 2009
Antwort Antwort
Benutzerbild von Coder90
Coder90
Registriert seit: 8. Nov 2004
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-Quellcode:
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-Quellcode:
  FNodeElement := TDomElement.Create(FDoc, 'RootNode');
  FDoc.AppendChild(FNodeElement);
Wir erstellen einen weiteren Knoten als Child:
Delphi-Quellcode:
  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-Quellcode:
  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-Quellcode:
  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-Quellcode:
  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:
  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-Quellcode:
  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-Quellcode:
  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-Quellcode:
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-Code:
<?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-Quellcode:
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-Quellcode:
  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-Quellcode:
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:
  FDoc := XMLToDomParser1.ParseFile('test.xml', False); Nun wollen wir die Werte auslesen
Für den Namen eines Tags:
  ShowMessage(FDoc.FindFirstChildElement.NodeName); Gibt 'RootNode' zurück.

Für den Wert eines Tags:
  ShowMessage(FDoc.GetElementsByTagName('Node1').Item(0).ChildNodes.Item(0).NodeValue); Gibt 'Text1' zurück.

Für das Attribut eines Tags:
  ShowMessage(FDoc.FindFirstChildElement.Attributes.Item(0).NodeValue); Gibt 'Wert1' zurück.
Oder:
  ShowMessage(FDoc.GetElementsByTagName('Node2').Item(0).Attributes.GetNamedItem('Attr3').NodeValue); Gibt 'Wert3' zurück.

Und für einen Kommentar:
  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 DF
Angehängte Dateien
Dateityp: zip openxmltutorialformatiertspeichernladen_250.zip (9,4 KB, 477x aufgerufen)
Dateityp: zip openxmltutorialspeichern_196.zip (7,9 KB, 305x aufgerufen)
 
14. Feb 2007, 08:43
Dieses Thema wurde von "Matze" von "Neuen Beitrag zur Code-Library hinzufügen" nach "Tutorials und Kurse" verschoben.
Das ist ein Tutorial.
kaeff
 
#3
  Alt 3. Jan 2008, 12:15
Sehr hilfreiches Tutorial, vielen Dank. Allerdings hat dieses bei mir nicht geklappt:
Zitat von Coder90:
Für den Wert eines Tags:
  ShowMessage(FDoc.GetElementsByTagName('Node1').Item(0).ChildNodes.Item(0).NodeValue); Gibt 'Text1' zurück.
Hierfür benutze ich einfach das Attribut "TextContent":
  ShowMessage(FDoc.FindFirstChildElement.Attributes.Item(0).TextContent); Viele Grüße,
kaeff
  Mit Zitat antworten Zitat
zeras

 
Delphi 11 Alexandria
 
#4
  Alt 18. Dez 2008, 20:53
Wo bekomme ich denn die Bibliothek her "Xdom_4_1"?

Das scheint genau das zu sein, was ich brauche und dann noch die Beschreibung dazu. Super.
  Mit Zitat antworten Zitat
Benutzerbild von Coder90
Coder90

 
Delphi 2007 Architect
 
#5
  Alt 18. Dez 2008, 21:04
http://www.delphi-treff.de/tutorials...dom-41/page/1/

Auf http://www.philo.de/xml/downloads.shtml gibt es bereits neuere Versionen die mittlerweile ADOM statt XDOM heisen
  Mit Zitat antworten Zitat
supu
 
#6
  Alt 22. Jan 2009, 19:39
.....
Und für einen Kommentar:
Delphi-Quellcode: markieren
ShowMessage(FDoc.FindFirstChildElement.ChildNodes. Item(3).NodeValue);
Gibt 'Kommentar' zurück.
......


Kleine Korrektur:
ShowMessage(FDoc.FindFirstChildElement.ChildNodes. Item(1).NodeValue);

Danke
supu
  Mit Zitat antworten Zitat
gints

 
Delphi 5 Enterprise
 
#7
  Alt 4. Mär 2009, 13:52
Und wo kann man OpenXMLTutorialFormatiertSpeichernLaden.zip finden???
Danke, Gints
  Mit Zitat antworten Zitat
Benutzerbild von Coder90
Coder90

 
Delphi 2007 Architect
 
#8
  Alt 4. Mär 2009, 14:30
Zitat von gints:
Und wo kann man OpenXMLTutorialFormatiertSpeichernLaden.zip finden???
Danke, Gints
Ist im ersten Post angehängt.

MfG,
Coder90
  Mit Zitat antworten Zitat
Themen-Optionen Tutorial durchsuchen
Tutorial durchsuchen:

Erweiterte Suche
Ansicht

Forumregeln

Es ist dir nicht erlaubt, neue Themen zu verfassen.
Es ist dir nicht erlaubt, auf Beiträge zu antworten.
Es ist dir nicht erlaubt, Anhänge hochzuladen.
Es ist dir nicht erlaubt, deine Beiträge zu bearbeiten.

BB-Code ist an.
Smileys sind an.
[IMG] Code ist an.
HTML-Code ist aus.
Trackbacks are an
Pingbacks are an
Refbacks are aus

Gehe zu:

Impressum · AGB · Datenschutz · Nach oben
Alle Zeitangaben in WEZ +1. Es ist jetzt 09:17 Uhr.
Powered by vBulletin® Copyright ©2000 - 2021, Jelsoft Enterprises Ltd.
LinkBacks Enabled by vBSEO © 2011, Crawlability, Inc.
Delphi-PRAXiS (c) 2002 - 2021 by Daniel R. Wolf