Einfachere Methode, um an XML-Daten zu kommen?

[Dalai]

Hallo Leute,

gegeben sei folgendes XML-Dokument:

XML-Code:

<?xml version="1.0" encoding="utf-8"?>
<s:Envelope xmlns:s="http://schemas.xmlsoap.org/soap/envelope/" s:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
  <s:Body>
    <u:GetCommonLinkPropertiesResponse xmlns:u="urn:schemas-upnp-org:service:WANCommonInterfaceConfig:1">
      <NewWANAccessType>DSL</NewWANAccessType>
      <NewLayer1UpstreamMaxBitRate>0</NewLayer1UpstreamMaxBitRate>
      <NewLayer1DownstreamMaxBitRate>0</NewLayer1DownstreamMaxBitRate>
      <NewPhysicalLinkStatus>Down</NewPhysicalLinkStatus>
    </u:GetCommonLinkPropertiesResponse>
  </s:Body>
</s:Envelope>

Es gibt noch andere XML-Dokumente, die analog zu diesem aufgebaut sind - Rückgabe einer Fritzbox eben :).

Da ich mit XML bisher nur am Rande zu tun hatte, aber noch nie in Verbindung mit Delphi, habe ich nach nun anderthalb Tagen endlich funktionierenden Code zusammen, um an die Inhalte des Knotens NewWANAccessType und dessen Siblings zu kommen:

Delphi-Quellcode:

var
  LXMLDoc: IXMLDocument;
  LNode: IXMLNode;
begin
[...]
  if Assigned(LXMLDoc) then begin
    LNode:= LXMLDoc.DocumentElement.ChildNodes[0].ChildNodes.FindNode('u:GetCommonLinkPropertiesResponse', '');
    if Assigned(LNode) then begin
      FConfigDSL.WANAccessType:=  LNode.ChildNodes.FindNode('NewWANAccessType', '').Text;
      FConfigDSL.UpstreamMaxBR:=  LNode.ChildNodes.FindNode('NewLayer1UpstreamMaxBitRate', '').Text;
      [...]
      LNode:= nil;
    end;
    LXMLDoc:= nil;
  end;
end;

Problematisch war für mich die automatische Namespace-Geschichte, die die Unterknoten nicht haben - ein Hinweis bei StackOverflow brachte mich auf die richtige Fährte. Geht das schöner oder einfacher? Ich hab den Code zwar in eine Methode ausgelagert, der man mehr oder weniger nur noch die Knotennamen übergeben muss (nicht in obigem Code), aber ich denke mir, dass das auch besser gehen müsste.

Danke erstmal.

Grüße
Dalai

[mjustin]

Delphi Schema Binding / Data Binding Wizard? Falls eine XML oder DTD Datei existiert, kann man sich von Delphi Wrapperklassen generieren lassen. Die Navigation im DOM Tree wird damit sehr viel einfacher und sicherer.

[Dalai]

Hallo,

danke für deine Antwort. Nach einigen Anlaufschwierigkeiten (kein XML Data Binding Wizard im Delphi vorhanden) habe ich den Wizard ausführen können, mit diesem Ergebnis:

Delphi-Quellcode:

unit GetCommonLinkPropertiesResponse2;

interface

uses xmldom, XMLDoc, XMLIntf;

type

{ Forward-Deklarationen }

  IXMLEnvelopeType = interface;
  IXMLBodyType = interface;
  IXMLGetCommonLinkPropertiesResponseType = interface;

{ IXMLEnvelopeType }

  IXMLEnvelopeType = interface(IXMLNode)
    ['{FB884417-D338-4E86-B4C2-246F39EF76C9}']
    { Eigenschaftszugriff }
    function Get_EncodingStyle: string;
    function Get_Body: IXMLBodyType;
    { Methoden & Eigenschaften }
    property EncodingStyle: string read Get_EncodingStyle;
    property Body: IXMLBodyType read Get_Body;
  end;

{ IXMLBodyType }

  IXMLBodyType = interface(IXMLNode)
    ['{5A78AA62-17F2-4D3A-9EF0-887A47D8DC27}']
    { Eigenschaftszugriff }
    function Get_GetCommonLinkPropertiesResponse: IXMLGetCommonLinkPropertiesResponseType;
    { Methoden & Eigenschaften }
    property GetCommonLinkPropertiesResponse: IXMLGetCommonLinkPropertiesResponseType read Get_GetCommonLinkPropertiesResponse;
  end;

{ IXMLGetCommonLinkPropertiesResponseType }

  IXMLGetCommonLinkPropertiesResponseType = interface(IXMLNode)
    ['{0AE1DCD1-8375-4EEB-A82D-74CC3581365F}']
    { Eigenschaftszugriff }
    function Get_NewWANAccessType: string;
    function Get_NewLayer1UpstreamMaxBitRate: string;
    function Get_NewLayer1DownstreamMaxBitRate: string;
    function Get_NewPhysicalLinkStatus: string;
    { Methoden & Eigenschaften }
    property NewWANAccessType: string read Get_NewWANAccessType;
    property NewLayer1UpstreamMaxBitRate: string read Get_NewLayer1UpstreamMaxBitRate;
    property NewLayer1DownstreamMaxBitRate: string read Get_NewLayer1DownstreamMaxBitRate;
    property NewPhysicalLinkStatus: string read Get_NewPhysicalLinkStatus;
  end;

{ Forward-Deklarationen }

  TXMLEnvelopeType = class;
  TXMLBodyType = class;
  TXMLGetCommonLinkPropertiesResponseType = class;

{ TXMLEnvelopeType }

  TXMLEnvelopeType = class(TXMLNode, IXMLEnvelopeType)
  protected
    { IXMLEnvelopeType }
    function Get_EncodingStyle: string;
    function Get_Body: IXMLBodyType;
  public
    procedure AfterConstruction; override;
  end;

{ TXMLBodyType }

  TXMLBodyType = class(TXMLNode, IXMLBodyType)
  protected
    { IXMLBodyType }
    function Get_GetCommonLinkPropertiesResponse: IXMLGetCommonLinkPropertiesResponseType;
  public
    procedure AfterConstruction; override;
  end;

{ TXMLGetCommonLinkPropertiesResponseType }

  TXMLGetCommonLinkPropertiesResponseType = class(TXMLNode, IXMLGetCommonLinkPropertiesResponseType)
  protected
    { IXMLGetCommonLinkPropertiesResponseType }
    function Get_NewWANAccessType: string;
    function Get_NewLayer1UpstreamMaxBitRate: string;
    function Get_NewLayer1DownstreamMaxBitRate: string;
    function Get_NewPhysicalLinkStatus: string;
  end;

{ Globale Funktionen }

function GetEnvelope(Doc: IXMLDocument): IXMLEnvelopeType;
function LoadEnvelope(const FileName: string): IXMLEnvelopeType;
function NewEnvelope: IXMLEnvelopeType;

const
  TargetNamespace = 'http://schemas.xmlsoap.org/soap/envelope/';

implementation

{ Globale Funktionen }

function GetEnvelope(Doc: IXMLDocument): IXMLEnvelopeType;
begin
  Result := Doc.GetDocBinding('Envelope', TXMLEnvelopeType, TargetNamespace) as IXMLEnvelopeType;
end;

function LoadEnvelope(const FileName: string): IXMLEnvelopeType;
begin
  Result := LoadXMLDocument(FileName).GetDocBinding('Envelope', TXMLEnvelopeType, TargetNamespace) as IXMLEnvelopeType;
end;

function NewEnvelope: IXMLEnvelopeType;
begin
  Result := NewXMLDocument.GetDocBinding('Envelope', TXMLEnvelopeType, TargetNamespace) as IXMLEnvelopeType;
end;

{ TXMLEnvelopeType }

procedure TXMLEnvelopeType.AfterConstruction;
begin
  RegisterChildNode('Body', TXMLBodyType);
  inherited;
end;

function TXMLEnvelopeType.Get_EncodingStyle: string;
begin
  Result := AttributeNodes['encodingStyle'].Text;
end;

function TXMLEnvelopeType.Get_Body: IXMLBodyType;
begin
  Result := ChildNodes['Body'] as IXMLBodyType;
end;

{ TXMLBodyType }

procedure TXMLBodyType.AfterConstruction;
begin
  RegisterChildNode('GetCommonLinkPropertiesResponse', TXMLGetCommonLinkPropertiesResponseType);
  inherited;
end;

function TXMLBodyType.Get_GetCommonLinkPropertiesResponse: IXMLGetCommonLinkPropertiesResponseType;
begin
  Result := ChildNodes['GetCommonLinkPropertiesResponse'] as IXMLGetCommonLinkPropertiesResponseType;
end;

{ TXMLGetCommonLinkPropertiesResponseType }

function TXMLGetCommonLinkPropertiesResponseType.Get_NewWANAccessType: string;
begin
  Result := ChildNodes['NewWANAccessType'].Text;
end;

function TXMLGetCommonLinkPropertiesResponseType.Get_NewLayer1UpstreamMaxBitRate: string;
begin
  Result := ChildNodes['NewLayer1UpstreamMaxBitRate'].Text;
end;

function TXMLGetCommonLinkPropertiesResponseType.Get_NewLayer1DownstreamMaxBitRate: string;
begin
  Result := ChildNodes['NewLayer1DownstreamMaxBitRate'].Text;
end;

function TXMLGetCommonLinkPropertiesResponseType.Get_NewPhysicalLinkStatus: string;
begin
  Result := ChildNodes['NewPhysicalLinkStatus'].Text;
end;

end.

Ausprobiert habe ich den Code nicht, weil er in dieser Form für den Zweck unbrauchbar ist:

1. Es gibt keine XML-Datei irgendwo auf der Platte. Die Daten kommen als String von der Fritzbox. Daraus folgt, dass der Code so umgeschrieben werden müsste, dass er z.B.
   Delphi-Quellcode:

   LoadFromXML

   statt
   Delphi-Quellcode:

   LoadXMLDocument

   benutzt. Derzeit habe ich keine Idee, wie man das in eine globale Funktion einarbeiten würde (LoadFromXML ist eine Methode von IXMLDocument).
2. Weiß der generierte Code die unterschiedlichen Namespaces in den Knoten zu beachten?
3. Einfach und besser finde ich dieses Mehr an Code nicht. Ich müsste für jeden Datenknoten (Eigenschaft) analoge Methoden und Klassen implementieren. Das sind ne ganze Menge - derzeit knapp 20 in mindestens 7 unterschiedlichen Namespaces/Attributen (oder wie auch immer man das korrekt bezeichnet, gemeint ist "GetCommonLinkPropertiesResponse").

Grüße
Dalai

[mensch72]

ich denke du willst einfach aus:

Code:

<?xml version="1.0" encoding="utf-8"?>
<s:Envelope xmlns:s="http://schemas.xmlsoap.org/soap/envelope/" s:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
  <s:Body>
    <u:GetCommonLinkPropertiesResponse xmlns:u="urn:schemas-upnp-org:service:WANCommonInterfaceConfig:1">
      <NewWANAccessType>DSL</NewWANAccessType>
      <NewLayer1UpstreamMaxBitRate>0</NewLayer1UpstreamMaxBitRate>
      <NewLayer1DownstreamMaxBitRate>0</NewLayer1DownstreamMaxBitRate>
      <NewPhysicalLinkStatus>Down</NewPhysicalLinkStatus>
    </u:GetCommonLinkPropertiesResponse>
  </s:Body>
</s:Envelope>

nur die reinen "Daten" haben:

Code:

      DSL
      0
      0
      Down

Das klappt sogar per MicroControler ohne viel RAM... man beginnt im XML ab "<" einfach alles bis ">" zu ignorieren!
Wenn man weiß wie das "oft/hoffentlich konstante" XLS Format aufgebaut ist, dann klappt diese sehr simple Herangehensweise!

Wenn so doch einige wichtige Steuerinfortmationen zu den reinen Daten verloren gehen, dann filtere man diese vorher getrennt.
Auch wenn das nicht versionsstabil und selbstsicher bei Änderungen ist, diese simple Variante schlägt in der Praxis in bekannten Umfeld oft alle baumbasieren FullXML Parser!

[mjustin]

* Der Funktion GetEnvelope(Doc: IXMLDocument) kann ein XML Document übergeben werden dass nicht als Datei "auf der Platte" vorliegen muss. Damit sollte es auch über einen String gehen, so wie er von der Fritzbox kommt (einfach ein IXmlDocument mit dem vorhanden String erzeugenm dann an GetEnvelope(Doc: IXMLDocument) übergeben.

* Namespaces werden unterstützt

* das "Mehr an Code" wird ja nur einmal, automatisch, generiert. Ab dann spart es sehr viel Zeit für das Schreiben des Codes, um auf die gewünschten Elemente zuzugreifen

Man kann natürlich auch selbst "handgeschnitzten" Code verwenden. Meistens hat es in den Fällen, in denen ich aus Delphi XML basierte Daten einlesen musste, funktioniert (RosettaNet, UPS Track & Trace, UPS Invoice Data).

[Dalai]

Zitat:

Zitat von mensch72 (Beitrag 1383558)

ich denke du willst einfach aus:
[...]
nur die reinen "Daten" haben:

Korrekt. Das sagt ja aber nichts darüber aus, wie diese Daten vorliegen, woher sie kommen; eine Datei ist anders zu behandeln als ein String. Und ich schrieb ja im OP schon

Zitat:

Es gibt noch andere XML-Dokumente, die analog zu diesem aufgebaut sind - Rückgabe einer Fritzbox eben

Zitat:

Zitat von mjustin (Beitrag 1383559)

* Der Funktion GetEnvelope(Doc: IXMLDocument) kann ein XML Document übergeben werden dass nicht als Datei "auf der Platte" vorliegen muss.

Oh, das hab ich in der Tat übersehen :oops:. Mal sehen, was ich daraus basteln kann.

Zitat:

* Namespaces werden unterstützt

OK, ich führe es wohl doch noch etwas weiter aus, wo ich Probleme hatte, und warum ich diese Frage stellte. Ich begann mit

Delphi-Quellcode:

LXMLDoc.ChildNodes['s:Envelope'].ChildNodes['s:Body'].ChildNodes['u:GetCommonLinkPropertiesResponse']

, bekam aber immer eine Exception mit dem Inhalt "Node ... not found". Der Node war nachvollziehbar vorhanden, zumal der Zugriff via

Delphi-Quellcode:

ChildNodes[0]

einwandfrei funktionierte. Also grenzte ich etwas ein, und fand heraus, dass das letzte ChildNodes der Auslöser der Exception war. Irgendwann schwante mir, dass die verschiedenen Namespaces der Knoten damit zu tun haben müssten. Deswegen die Änderung auf

Delphi-Quellcode:

FindNode

mit leerem Namespace wie im OP zu sehen.

Da ich in dem vom Wizard generierten Code außer der Konstanten

Delphi-Quellcode:

TargetNamespace

keinerlei Namespaces sehe, frage ich mich, wie das funktionieren soll, wenn Body und der Datenknoten darunter jeweils andere Namespaces verwenden. Geht das automatisch oder muss ich das explizit angeben, und wenn ja wie?

Zitat:

* das "Mehr an Code" wird ja nur einmal, automatisch, generiert. Ab dann spart es sehr viel Zeit für das Schreiben des Codes, um auf die gewünschten Elemente zuzugreifen

Stimmt, aber durch die bereits im OP genannte Auslagerung in eine Methode hab ich auch kaum mehr Schreibarbeit - ohne dieses Mehr an Code. OK, wahrscheinlich ist es nicht so "typsicher" wie der Code des Wizard.

Grüße
Dalai

[Dalai]

Meine Befürchtung hat sich bestätigt: der Code funktioniert so nicht, weil die Namespaces nicht passen.

Delphi-Quellcode:

uses ..., GetCommonLinksPropertiesResponse;

var
  LXMLBody: IXMLBodyType;
  LXMLGCLP: IXMLGetCommonLinkPropertiesResponseType;
begin
    LXMLDoc:=      FRITZBox_SOAPDownload(FRITZBOX_UPNP_WANCommonIFC1_URL, FRITZBOX_URN_WANCOMMONIFC, cGCLP, False);
    LXMLBody:= GetCommonLinkPropertiesResponse.GetEnvelope(LXMLDoc).Body;
    LXMLGCLP:= LXMLBody.GetCommonLinkPropertiesResponse;

Bei der letzten Zeile rummst es mit "Node ... not found". Wahrscheinlich noch wichtig: Die Exception kommt nur, wenn

Delphi-Quellcode:

LXMLDoc.ReadOnly:= True

und

Delphi-Quellcode:

LXMLDoc.Options

den Wert

Delphi-Quellcode:

doNodeAutoCreate

nicht beinhaltet. Trifft beides nicht zu, werden leere Knoten in LXMLDoc angelegt, und logischerweise kommen so auch keine Werte für die Eigenschaften NewWANAccessType & Co zurück.

Die Sache muss also anders aufgebaut sein, damit sie funktioniert und den geänderten Namespace berücksichtigt. Da sind wir wieder zurück beim FindNode, oder wie würde man das normalerweise machen, wenn nicht damit?

Grüße
Dalai

[bra]

Du kannst auch einfach ohne FindNodes die Unter-Nodes rekursiv durchgehen und nach dem NodeNamen prüfen, also jeweils ChildNodes[0] bis [x] und davon wieder die ChildNodes[x]. Wäre das nicht einfacher?

[Dalai]

Da die Daten immer in derselben Ebene zu finden sind, habe ich mich entschieden, bei meiner Funktion zu bleiben. Nach etwas Überarbeitung sieht diese nun so aus:

Delphi-Quellcode:

function ValueOfElement(const AXMLNode: IXMLNode; const AResponseName, ANodeName: string): string;
var
  LNode: IXMLNode;
begin
    Result:= '';
    if Assigned(AXMLNode) then begin
        if AXMLNode.HasChildNodes then begin
            { ChildNodes[0] = s:Body }
            LNode:= AXMLNode.ChildNodes[0];
            if LNode.HasChildNodes then begin
                { u:<ResponseName> }
                LNode:= LNode.ChildNodes.FindNode(AResponseName, '');
                if Assigned(LNode) then begin
                    if LNode.HasChildNodes then begin
                        LNode:= LNode.ChildNodes.FindNode(ANodeName, '');
                        if Assigned(LNode) then begin
                            if LNode.IsTextElement then
                                Result:= LNode.Text;
                        end;
                    end;
                end;
            end;
            LNode:= nil;
        end;
    end;
end;

Der Aufruf erfolgt dann z.B. so:

Delphi-Quellcode:

FConfigDSL.WANAccessType:=    ValueOfElement(LXMLDoc.DocumentElement, FBACTION_RESPONSE_GCLP, 'NewWANAccessType');

wobei

Delphi-Quellcode:

const FBACTION_RESPONSE_GCLP = 'GetCommonLinkPropertiesResponse';

ist. Mit den vielen if-Bedingungen sollte so ziemlich alles abgefangen sein, was schiefgehen könnte. Wenn eine andere Knotentiefe vorliegt, klappt das natürlich nicht mehr. Aber darum muss ich mir derzeit keine Gedanken machen, weil ich sowieso noch mitten in der Testphase stecke.

Eine rekursive Funktion habe ich zwar auch geschrieben (um Daten aus einem anderen Dokument zu ermitteln), habe es aber noch nicht hinbekommen, auf den Knotennamen des Knotens und den/die Knotennamen der Kinder desselben zu prüfen, ohne den Code massiv aufzublähen oder kompliziert zu machen. Baumstruktur ist nicht so ganz einfach.

Grüße
Dalai