edition - ¿Cuál es el analizador XML más rápido disponible para Delphi?

delphi versiones

Question

Tenemos cadenas de XML razonablemente grandes que actualmente analizamos utilizando MSXML2

¡Acabo de intentar usar MSXML6 esperando una mejora de velocidad y no tengo nada!

Actualmente creamos una gran cantidad de documentos DOM y creo que puede haber un poco de sobrecarga en la interacción constante con el dll MSXML2 / 6

¿Alguien sabe de un componente XML mejor / más rápido para Delphi?

Si alguien puede sugerir una alternativa, y es más rápida, buscaríamos integrarla, pero eso sería mucho trabajo, por lo que esperamos que la estructura no sea muy diferente a la utilizada por MSXML.

Estamos usando Delphi 2010

Pablo

Answer 1

Algún día escribí un conjunto de pruebas XML muy simple. Sirve MSXML (D7 MSXML3?), Omni XML (poco antiguo) y Jedi XML (último estable).

Resultados de prueba para archivo de 1,52 MB:

Tiempo de carga del archivo XML MSXML: 240,20 [ms]

Selecciones de nodos XML MSXML: 1,09 [s]

Tiempo de carga de archivos XML OmniXML: 2,25 [s]

Selecciones de nodos XML OmniXML: 1,22 [s]

Tiempo de carga de archivos XML JclSimpleXML: 2,11 [s]

y violación de acceso para selecciones de nodo JclSimpleXML: |

Desafortunadamente, en realidad no tengo mucho tiempo para corregir el AV anterior, pero las hechiceras se encuentran a continuación ...

fmuMain.pas

program XmlEngines;

uses
  FastMM4,
  Forms,
  fmuMain in ''fmuMain.pas'' {fmMain},
  uXmlEngines in ''uXmlEngines.pas'',
  ifcXmlEngine in ''ifcXmlEngine.pas'';

{$R *.res}

begin
  Application.Initialize;
  Application.Title := ''XML Engine Tester'';
  Application.CreateForm(TfmMain, fmMain);
  Application.Run;
end.

fmuMain.pas

unit fmuMain;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, xmldom, XMLIntf, msxmldom, XMLDoc,
  //
  ifcXmlEngine, StdCtrls;

type
  TfmMain = class(TForm)
    mmoDebug: TMemo;
    dlgOpen: TOpenDialog;

    procedure FormCreate(Sender: TObject);
    procedure FormDestroy(Sender: TObject);

    procedure mmoDebugClick(Sender: TObject);

  private
    fXmlEngines: TInterfaceList;
    function Get_Engine(const aIx: Integer): IXmlEngine;

  protected
    property XmlEngine[const aIx: Integer]: IXmlEngine read Get_Engine;

    procedure Debug(const aInfo: string); // inline

  public
    procedure RegisterXmlEngine(const aEngine: IXmlEngine);

  end;

var
  fmMain: TfmMain;

implementation

{$R *.dfm}

uses
  uXmlEngines, TZTools;

{ TForm1 }

function TfmMain.Get_Engine(const aIx: Integer): IXmlEngine;
begin
  Result:= nil;
  Supports(fXmlEngines[aIx], IXmlEngine, Result)
end;

procedure TfmMain.RegisterXmlEngine(const aEngine: IXmlEngine);
var
  Ix: Integer;
begin
  if aEngine = nil then
    Exit; // WARRNING: program flow disorder

  for Ix:= 0 to Pred(fXmlEngines.Count) do
    if XmlEngine[Ix] = aEngine then
      Exit; // WARRNING: program flow disorder

  fXmlEngines.Add(aEngine)
end;

procedure TfmMain.FormCreate(Sender: TObject);
begin
  fXmlEngines:= TInterfaceList.Create();
  dlgOpen.InitialDir:= ExtractFileDir(ParamStr(0));
  RegisterXmlEngine(TMsxmlEngine.Create(Self));
  RegisterXmlEngine(TOmniXmlEngine.Create());
  RegisterXmlEngine(TJediXmlEngine.Create());
end;

procedure TfmMain.mmoDebugClick(Sender: TObject);

  procedure TestEngines(const aFilename: TFileName);

    procedure TestEngine(const aEngine: IXmlEngine);
    var
      PerfCheck: TPerfCheck;
      Ix: Integer;
    begin
      PerfCheck := TPerfCheck.Create();
      try

        PerfCheck.Init(True);
        PerfCheck.Start();
        aEngine.Load(aFilename);
        PerfCheck.Pause();
        Debug(Format(
          ''XML file loading time %s: %s'',
          [aEngine.Get_ID(), PerfCheck.TimeStr()]));

        if aEngine.Get_ValidNode() then
        begin
          PerfCheck.Start();
          for Ix:= 0 to 999999 do
            if aEngine.Get_ChildsCount() > 0 then
            begin

              aEngine.SelectChild(Ix mod aEngine.Get_ChildsCount());

            end
            else
              aEngine.SelectRootNode();

          PerfCheck.Pause();
          Debug(Format(
            ''XML nodes selections %s: %s'',
            [aEngine.Get_ID(), PerfCheck.TimeStr()]));
        end

      finally
        PerfCheck.Free();
      end
    end;

  var
    Ix: Integer;
  begin
    Debug(aFilename);
    for Ix:= 0 to Pred(fXmlEngines.Count) do
      TestEngine(XmlEngine[Ix])
  end;

var
  CursorBckp: TCursor;
begin
  if dlgOpen.Execute() then
  begin

    CursorBckp:= Cursor;
    Self.Cursor:= crHourGlass;
    mmoDebug.Cursor:= crHourGlass;
    try
      TestEngines(dlgOpen.FileName)
    finally
      Self.Cursor:= CursorBckp;
      mmoDebug.Cursor:= CursorBckp;
    end

  end
end;

procedure TfmMain.Debug(const aInfo: string);
begin
  mmoDebug.Lines.Add(aInfo)
end;

procedure TfmMain.FormDestroy(Sender: TObject);
begin
  fXmlEngines.Free()
end;

end.

ifcXmlEngine.pas

unit ifcXmlEngine;

interface

uses
  SysUtils;

type
  TFileName = SysUtils.TFileName;

  IXmlEngine = interface
    [''{AF77333B-9873-4FDE-A3B1-260C7A4D3357}'']
    procedure Load(const aFilename: TFileName);
    procedure SelectRootNode();
    procedure SelectChild(const aIndex: Integer);
    procedure SelectParent();
    //
    function Get_ID(): string;
    function Get_ValidNode(): Boolean;
    function Get_ChildsCount(): Integer;
    function Get_HaveParent(): Boolean;
    //function Get_NodeName(): Boolean;
  end;

implementation

end.

uXmlEngines.pas

unit uXmlEngines;

interface

uses
  Classes,
  //
  XMLDoc, XMLIntf, OmniXml, JclSimpleXml,
  //
  ifcXmlEngine;

type
  TMsxmlEngine = class(TInterfacedObject, IXmlEngine)
  private
    fXmlDoc: XMLDoc.TXMLDocument;
    fNode: XMLIntf.IXMLNode;

  protected

  public
    constructor Create(const aOwner: TComponent);
    destructor Destroy; override;

    procedure Load(const aFilename: TFileName);
    procedure SelectRootNode();
    procedure SelectChild(const aIndex: Integer);
    procedure SelectParent();
    //
    function Get_ID(): string;
    function Get_ValidNode(): Boolean;
    function Get_ChildsCount(): Integer;
    function Get_HaveParent(): Boolean;
    //function Get_NodeName(): Boolean;

  end;

  TOmniXmlEngine = class(TInterfacedObject, IXmlEngine)
  private
    fXmlDoc: OmniXml.IXmlDocument;
    fNode: OmniXml.IXMLNode;

  protected

  public
    constructor Create;
    destructor Destroy; override;

    procedure Load(const aFilename: TFileName);
    procedure SelectRootNode();
    procedure SelectChild(const aIndex: Integer);
    procedure SelectParent();
    //
    function Get_ID(): string;
    function Get_ValidNode(): Boolean;
    function Get_ChildsCount(): Integer;
    function Get_HaveParent(): Boolean;
    //function Get_NodeName(): Boolean;

  end;

  TJediXmlEngine = class(TInterfacedObject, IXmlEngine)
  private
    fXmlDoc: TJclSimpleXML;
    fNode: TJclSimpleXMLElem;

  protected

  public
    constructor Create();
    destructor Destroy(); override;

    procedure Load(const aFilename: TFileName);
    procedure SelectRootNode();
    procedure SelectChild(const aIndex: Integer);
    procedure SelectParent();
    //
    function Get_ID(): string;
    function Get_ValidNode(): Boolean;
    function Get_ChildsCount(): Integer;
    function Get_HaveParent(): Boolean;
    //function Get_NodeName(): Boolean;

  end;

implementation

uses
  SysUtils;

{ TMsxmlEngine }

constructor TMsxmlEngine.Create(const aOwner: TComponent);
begin
  if aOwner = nil then
    raise Exception.Create(''TMsxmlEngine.Create() -> invalid owner'');

  inherited Create();
  fXmlDoc:= XmlDoc.TXmlDocument.Create(aOwner);
  fXmlDoc.ParseOptions:= [poPreserveWhiteSpace]
end;

destructor TMsxmlEngine.Destroy;
begin
  fXmlDoc.Free();
  inherited Destroy()
end;

function TMsxmlEngine.Get_ChildsCount: Integer;
begin
  Result:= fNode.ChildNodes.Count
end;

function TMsxmlEngine.Get_HaveParent: Boolean;
begin
  Result:= fNode.ParentNode <> nil
end;

function TMsxmlEngine.Get_ID: string;
begin
  Result:= ''MSXML''
end;

//function TMsxmlEngine.Get_NodeName: Boolean;
//begin
//  Result:= fNode.Text
//end;

function TMsxmlEngine.Get_ValidNode: Boolean;
begin
  Result:= fNode <> nil
end;

procedure TMsxmlEngine.Load(const aFilename: TFileName);
begin
  fXmlDoc.LoadFromFile(aFilename);
  SelectRootNode()
end;

procedure TMsxmlEngine.SelectChild(const aIndex: Integer);
begin
  fNode:= fNode.ChildNodes.Get(aIndex)
end;

procedure TMsxmlEngine.SelectParent;
begin
  fNode:= fNode.ParentNode
end;

procedure TMsxmlEngine.SelectRootNode;
begin
  fNode:= fXmlDoc.DocumentElement
end;

{ TOmniXmlEngine }

constructor TOmniXmlEngine.Create;
begin
  inherited Create();
  fXmlDoc:= OmniXml.TXMLDocument.Create();
  fXmlDoc.PreserveWhiteSpace:= true
end;

destructor TOmniXmlEngine.Destroy;
begin
  fXmlDoc:= nil;
  inherited Destroy()
end;

function TOmniXmlEngine.Get_ChildsCount: Integer;
begin
  Result:= fNode.ChildNodes.Length
end;

function TOmniXmlEngine.Get_HaveParent: Boolean;
begin
  Result:= fNode.ParentNode <> nil
end;

function TOmniXmlEngine.Get_ID: string;
begin
  Result:= ''OmniXML''
end;

//function TOmniXmlEngine.Get_NodeName: Boolean;
//begin
//  Result:= fNode.NodeName
//end;

function TOmniXmlEngine.Get_ValidNode: Boolean;
begin
  Result:= fNode <> nil
end;

procedure TOmniXmlEngine.Load(const aFilename: TFileName);
begin
  fXmlDoc.Load(aFilename);
  SelectRootNode()
end;

procedure TOmniXmlEngine.SelectChild(const aIndex: Integer);
begin
  fNode:= fNode.ChildNodes.Item[aIndex]
end;

procedure TOmniXmlEngine.SelectParent;
begin
  fNode:= fNode.ParentNode
end;

procedure TOmniXmlEngine.SelectRootNode;
begin
  fNode:= fXmlDoc.DocumentElement
end;

{ TJediXmlEngine }

constructor TJediXmlEngine.Create;
begin
  inherited Create();
  fXmlDoc:= TJclSimpleXML.Create();
end;

destructor TJediXmlEngine.Destroy;
begin
  fXmlDoc.Free();
  inherited Destroy()
end;

function TJediXmlEngine.Get_ChildsCount: Integer;
begin
  Result:= fNode.ChildsCount
end;

function TJediXmlEngine.Get_HaveParent: Boolean;
begin
  Result:= fNode.Parent <> nil
end;

function TJediXmlEngine.Get_ID: string;
begin
  Result:= ''JclSimpleXML'';
end;

//function TJediXmlEngine.Get_NodeName: Boolean;
//begin
//  Result:= fNode.Name
//end;

function TJediXmlEngine.Get_ValidNode: Boolean;
begin
  Result:= fNode <> nil
end;

procedure TJediXmlEngine.Load(const aFilename: TFileName);
begin
  fXmlDoc.LoadFromFile(aFilename);
  SelectRootNode()
end;

procedure TJediXmlEngine.SelectChild(const aIndex: Integer);
begin
  fNode:= fNode.Items[aIndex]
end;

procedure TJediXmlEngine.SelectParent;
begin
  fNode:= fNode.Parent
end;

procedure TJediXmlEngine.SelectRootNode;
begin
  fNode:= fXmlDoc.Root
end;

end.

Answer 2

Recientemente tuve un problema similar en el que el uso del analizador MSXML DOM resultó ser demasiado lento para la tarea dada. Tuve que analizar documentos bastante grandes> 1 MB y el consumo de memoria del analizador DOM era prohibitivo. Mi solución fue no utilizar un analizador DOM en absoluto, sino ir con el analizador MSXML SAX impulsado por eventos. Esto resultó ser mucho, mucho más rápido. Lamentablemente, el modelo de programación es totalmente diferente, pero dependiendo de la tarea, podría valer la pena. Craig Murphy ha publicado un excelente artículo sobre cómo usar el analizador MSXML SAX en Delphi : SAX, Delphi y Ex Em El

Answer 3

Sé que es una vieja pregunta, pero la gente puede encontrarla interesante:

Escribí una nueva biblioteca XML para Delphi (OXml): http://www.kluug.net/oxml.php

Cuenta con manejo directo de XML (lectura + escritura), analizador SAX, DOM y un analizador DOM secuencial. Una de las ventajas es que OXml admite Delphi 6-Delphi XE5, FPC / Lazarus y C ++ Builder en todas las plataformas (Win, MacOSX, Linux, iOS, Android).

OXml DOM está basado en registros / punteros y ofrece un mejor rendimiento que cualquier otra biblioteca XML:

La prueba de lectura devuelve el tiempo que el analizador necesita para leer un DOM XML personalizado desde un archivo (columna "cargar") y para escribir valores de nodo en una función ficticia constante (columna "navegar"). El archivo está codificado en UTF-8 y su tamaño es de aproximadamente 5,6 MB.

La prueba de escritura devuelve el tiempo que el analizador necesita para crear un DOM (columna "crear") y escribe este DOM en un archivo (columna "guardar"). El archivo está codificado en UTF-8 y su tamaño es de aproximadamente 11 MB.

+ El pobre rendimiento de escritura de OmniXML (original) fue el resultado del hecho de que OmniXML no usó el almacenamiento en búfer para escribir. Por lo tanto, escribir en un TFileStream fue muy lento. Actualicé OmniXML y agregué soporte de almacenamiento en búfer. Puede obtener el último código OmniXML del SVN.

Answer 4

himXML a himXML por himitsu .

Se lanza bajo la licencia MPL v1.1 , GPL v3.0 o LGPL v3.0 .

Tendrá que registrarse en el excelente sitio Delphi-Praxis (alemán) de Delphi para poder descargar:

• himxml_246.7z

Tiene un rendimiento muy impresionante y la distribución incluye demostraciones que demuestran eso. Lo utilicé con éxito en Delphi 2007, Delphi 2010 y Delphi XE.

Answer 5

Hace algún tiempo tuve que serializar el record al formato XML; por ejemplo:

 TTest = record
    a : integer;
    b : real; 
 end;

a

<Data> <a type="tkInteger">value</a> <b type="tkFloat">value</b> </Data>

Utilicé RTTI para navegar recursivamente por los campos de registro y almacenar valores en XML. He probado algunos XML Parsers. No necesitaba el modelo DOM para crear xml, pero lo necesitaba para cargarlo.

XML contenía aproximadamente 310k nodos (10-15MBytes); los resultados presentados en la tabla a continuación, hay 6 columnas con tiempo en segundos;
1 - tiempo para crear nodos y escribir valores
2 - SaveToFile ();
3 = 1 + 2
4 - LoadFromFile ();
5 - navegar a través de los nodos y leer valores
6 = 4 + 5

MSXML/Xerces/ADOM - son diferentes proveedores para TXMLDocument ( DOMVendor )
JanXML no funciona con Unicode; Solucioné algunos errores y guardé XML, pero cargar causa AV (o desbordamiento de pila, no recuerdo);
manual : significa escribir manualmente XML utilizando TStringStream .

Usé Delphi2010, Win7x32, CPU Q8200 / 2.3GHz, 4Gb de RAM.

actualización: Puede descargar el código fuente para esta prueba (registro de serialización a XML usando RTTI) aquí http://blog.karelia.pro/teran/files/2012/03/XMLTest.zip Todos los analizadores (Omni, Native, Jan) son incluido (ahora los nodos cuentan en XML es de aproximadamente 270k), lo siento, no hay comentarios en el código.