TXMLDocument
 

Hola, A ver si alguien me puede poner algun ejemplo de como trabajar con este componente. Tengo un documento XML y no consigo modificar nada en ese documento, me gustaria poder añadir y modificar en ese doc xml, a ver si alguien me pone ejemplos de como hacerlo, gracias de antemano.

Y porque no trabaja con el ClientDataSet, el permite cargar la información de un DataSet normal o de un archivo XML por medio del loadFromFile

Hola,

Hace cierto tiempo escribí un componente al que dí el original e imaginativo nombre de "XmlComoIni"... creo que puede servirte para hacerte una idea, por lo menos, de ciertos aspectos del componente "TXmlDocument".

Código Delphi [-]
{ *********************************************************************** }
{                                                                         }
{ DecComp - Unos sencillos componentes                                    }
{                                                                         }
{ Copyright (c) 2005 dec - davidesperalta@gmail.com                       }
{ bajo la licencia GNU GPL >> ver en "licencia.txt"                       }
{                                                                         }
{ Créditos: A Lepe, del ClubDelphi.com ;-)                                }
{                                                                         }
{ *********************************************************************** }

unit UXmlComoIni;

interface

uses
  // Delphi 7
  //
  Classes, SysUtils, Graphics, XMLIntf, XMLDoc,

  // Pertenece al proyecto
  //
  UTypesDecComp;

type
  TXmlComoIni = class(TComponent)
  private
    FAcercade: TAcercade;
  published
    property Acercade: TAcercade read
      FAcercade write FAcercade stored false;
  private
    FFileName: TFileName;
    FDocXml: TXMLDocument;
    procedure CrearDocXml;
    procedure AbrirDocXml;
    procedure GuardarDocXml;
  public
    constructor Create(AOwner: TComponent); reintroduce; overload; override;
    constructor Create(AOwner: TComponent; const fileName: TFileName); reintroduce; overload;
    destructor Destroy; override;
    procedure UpdateFile;
    procedure DeleteKey(const seccion, clave: string);
    function SectionExists(const seccion: string) : boolean;
    function KeyExists(const seccion, clave: string) : boolean;
    procedure ReadSections(strings: TStrings);
    procedure DeleteSection(const seccion: string);
    procedure ReadSection(const seccion: string; strings: TStrings);
    procedure ReadSectionValues(const seccion: string; strings: TStrings);
    procedure WriteString(const seccion, clave, valor: string);
    function ReadString(const seccion, clave, defecto: string): string;
    procedure WriteInteger(const seccion, clave: string; const valor: integer);
    function ReadInteger(const seccion, clave: string; const defecto: integer) : integer;
    procedure WriteColor(const seccion, clave: string; const valor: TColor);
    function ReadColor(const seccion, clave: string; const defecto: TColor) : integer;
    procedure WriteBool(const seccion, clave: string; const valor: boolean);
    function ReadBool(const seccion, clave: string; const defecto: boolean) : boolean;
    procedure WriteDateTime(const seccion, clave: string; const valor: TDateTime);
    function ReadDateTime(const seccion, clave: string; const defecto: TDateTime) : TDateTime;
    procedure WriteFloat(const seccion, clave: string; valor: Double);
    function ReadFloat(const seccion, clave: string; const defecto: Double) : Double;
  end;

implementation

// Recursos/cadenas
//
{$I ..\inc\rsDecComp.inc}

{ TXmlComoIni }

// Constructor del componente.
//
constructor TXmlComoIni.Create(AOwner: TComponent);
begin
  inherited;
  FFileName := rsFileName;
  if not (csDesigning in ComponentState) then
  begin
    CrearDocXml;
    FFileName := ChangeFileExt(ParamStr(0), rsExtXml);
    AbrirDocXml;
  end;
end;

// Otro constructor del componente: en
// realidad desde el primero, como puede
// verse, llamamos a este otro.
//
constructor TXmlComoIni.Create(AOwner:
  TComponent; const fileName: TFileName);
begin
  CrearDocXml;
  if (fileName <> EmptyStr) then
    FFileName := fileName
  else
    FFileName := ChangeFileExt(ParamStr(0), rsExtXml);
  AbrirDocXml;
end;

// Destructor del componente.
//
destructor TXmlComoIni.Destroy;
begin
  if not (csDesigning in
    ComponentState) then
      GuardarDocXml;
  FDocXml.Free;
  inherited;
end;

// Crear el documento XML.
//
procedure TXmlComoIni.CrearDocXml;
begin
  FDocXml :=  TXMLDocument.Create(Self);
  FDocXml.Options := [doNodeAutoIndent];
end;

// Guardar el documento XML.
//
procedure TXmlComoIni.GuardarDocXml;
begin
  if FDocXml.Modified then
  begin
    FDocXml.SaveToFile(FFileName);
  end;
end;

// Actualizar el archivo XML.
//
procedure TXmlComoIni.UpdateFile;
begin
  GuardarDocXml;
end;

// Abrir el archivo XML.
//
procedure TXmlComoIni.AbrirDocXml;
begin
  if FileExists(FFileName) then
    FDocXml.LoadFromFile(FFileName)
  else
  begin
    FDocXml.Active := true;
    FDocXml.Version := '1.0';
    FDocXml.AddChild(rsRaizXml);
  end;
end;

// Leer el texto contenido en una determinada
// sección (nodo XML) dentro de una determinada
// clave (nodo XML).
//
function TXmlComoIni.ReadString(const
  seccion, clave, defecto: string): string;
var
  nodoClave,
  nodoSeccion: IXMLNode;
begin
  Result := defecto;
  with FDocXml.DocumentElement do
    nodoSeccion := ChildNodes.FindNode(seccion);
  if not Assigned(nodoSeccion) then
    Exit; // No existe la sección
  with nodoSeccion do
    nodoClave := ChildNodes.FindNode(clave);
  if not Assigned(nodoClave) then
    Exit; // No existe la clave
  Result := nodoClave.Text;
end;

// Escribir una cadena en una
// determinada sección y clave.
//
procedure TXmlComoIni.WriteString(const
  seccion, clave, valor: string);
var
  nodoClave,
  nodoSeccion: IXMLNode;
begin
  if ReadString(seccion, clave, EmptyStr) = valor then
    Exit; // El valor a escribir y el actual coinciden
  with FDocXml.DocumentElement do begin
    nodoSeccion := ChildNodes.FindNode(seccion);
    if not Assigned(nodoSeccion) then
      nodoSeccion := AddChild(seccion);
  end;
  with nodoSeccion do begin
    nodoClave := ChildNodes.FindNode(clave);
    if not Assigned(nodoClave) then
      nodoClave := AddChild(clave);
  end;
  nodoClave.Text := valor;
end;

// Leer una cadena del documento XML pero
// devolverla como una valor de tipo Integer.
//
function TXmlComoIni.ReadInteger(const seccion,
  clave: string; const defecto: integer): integer;
begin
  Result := StrToInt(ReadString(
    seccion, clave, IntToStr(defecto)));
end;

// Escribir una cadena en el documento XML
// obteniendo el valor de la misma de un Integer.
//
procedure TXmlComoIni.WriteInteger(const seccion,
  clave: string; const valor: integer);
begin
  WriteString(seccion, clave, IntToStr(valor));
end;

// Leer una cadena del documento XML pero
// devolverla como una valor de tipo TColor.
//
function TXmlComoIni.ReadColor(const seccion,
  clave: string; const defecto: TColor): integer;
begin
  Result := StringToColor(ReadString(
    seccion, clave, ColorToString(defecto)));
end;

// Escribir una cadena en el documento XML
// obteniendo el valor de la misma de un TColor.
//
procedure TXmlComoIni.WriteColor(const seccion,
  clave: string; const valor: TColor);
begin
  WriteString(seccion, clave, ColorToString(valor));
end;

// Leer una cadena del documento XML pero
// devolverla como una valor de tipo boolean.
//
function TXmlComoIni.ReadBool(const seccion,
  clave: string; const defecto: boolean): boolean;
begin
  Result := StrToBool(ReadString(
    seccion, clave, BoolToStr(defecto)));
end;

// Escribir una cadena en el documento XML
// obteniendo el valor de la misma de un boolean.
//
procedure TXmlComoIni.WriteBool(const seccion,
  clave: string; const valor: boolean);
begin
  WriteString(seccion, clave, BoolToStr(valor));
end;

// Leer una cadena del documento XML pero
// devolverla como una valor de tipo TDateTime.
//
function TXmlComoIni.ReadDateTime(const seccion,
  clave: string; const defecto: TDateTime): TDateTime;
begin
  Result := StrToDateTime(ReadString(
    seccion, clave, DateTimeToStr(defecto)));
end;

// Escribir una cadena en el documento XML
// obteniendo el valor de la misma de un TDateTime.
//
procedure TXmlComoIni.WriteDateTime(const seccion,
  clave: string; const valor: TDateTime);
begin
  WriteString(seccion, clave, DateTimeToStr(valor));
end;

// Leer una cadena del documento XML pero
// devolverla como una valor de tipo Double.
//
function TXmlComoIni.ReadFloat(const seccion,
  clave: string; const defecto: Double): Double;
begin
  Result := StrToFloat(ReadString(
    seccion, clave, FloatToStr(defecto)));
end;

// Escribir una cadena en el documento XML
// obteniendo el valor de la misma de un Double.
//
procedure TXmlComoIni.WriteFloat(const
  seccion, clave: string; valor: Double);
begin
  WriteString(seccion, clave, FloatToStr(valor));
end;

// Borrar una determinada clave (nodo XML).
//
procedure TXmlComoIni.DeleteKey(const
  seccion, clave: string);
var
  nodoClave,
  nodoSeccion: IXMLNode;
begin
  with FDocXml.DocumentElement do
    nodoSeccion := ChildNodes.FindNode(seccion);
  if Assigned(nodoSeccion) then
  begin
    nodoClave := nodoSeccion.ChildNodes.FindNode(clave);
    if Assigned(nodoClave) then
      nodoSeccion.ChildNodes.Delete(nodoClave.NodeName);
  end;
end;

// Comprobar la existencia de una
// determinda clave (nodo XML).
//
function TXmlComoIni.KeyExists(const
  seccion, clave: string) : boolean;
var
  nodoSeccion: IXMLNode;
begin
  with FDocXml.DocumentElement do
    nodoSeccion := ChildNodes.FindNode(seccion);
  if Assigned(nodoSeccion) then
  begin
    with nodoSeccion do
      Result := (ChildNodes.IndexOf(clave)<>-1);
  end
  else
    Result := false;
end;

// Comprobar la existencia de una
// determinada sección (nodo XML).
//
function TXmlComoIni.SectionExists(const
  seccion: string) : boolean;
var
  nodoSeccion: IXMLNode;
begin
  with FDocXml.DocumentElement do
    nodoSeccion := ChildNodes.FindNode(seccion);
  Result := Assigned(nodoSeccion);
end;

// Leer los valores (strings) de una determinada
// sección o, como queda dicho, nodo XML. ;-)
// 
procedure TXmlComoIni.ReadSectionValues(const
  seccion: string; strings: TStrings);
var
  i: integer;
  nodoClave,
  nodoSeccion: IXMLNode;
begin
  with FDocXml.DocumentElement do
    nodoSeccion := ChildNodes.FindNode(seccion);
  if Assigned(nodoSeccion) then
  begin
    strings.Clear;
    for i := 0 to nodoSeccion.ChildNodes.Count-1 do
    begin
      nodoClave := nodoSeccion.ChildNodes[i];
      if Assigned(nodoClave)  and
        (nodoClave.IsTextElement) then
          strings.Add(nodoClave.Text);
    end;
  end;
end;

// Leer los nombres de las diferentes secciones.
//
procedure TXmlComoIni.ReadSections(strings: TStrings);
var
  i: integer;
  nodoSeccion: IXMLNode;
begin
  nodoSeccion := FDocXml.DocumentElement;
  if Assigned(nodoSeccion) then
  begin
    strings.Clear;
    for i := 0 to nodoSeccion.ChildNodes.Count-1 do
      strings.Add(nodoSeccion.ChildNodes[i].NodeName);
  end;
end;

// Leer las claves de una determinada sección.
//
procedure TXmlComoIni.ReadSection(const
  seccion: string; strings: TStrings);
var
  i: integer;
  nodoClave,
  nodoSeccion: IXMLNode;
begin
  with FDocXml.DocumentElement do
    nodoSeccion := ChildNodes.FindNode(seccion);
  if Assigned(nodoSeccion) then
  begin
    strings.Clear;
    for i := 0 to nodoSeccion.ChildNodes.Count-1 do
    begin
      nodoClave := nodoSeccion.ChildNodes[i];
      strings.Add(nodoClave.NodeName);
    end;
  end;
end;

// Borrar una sección (nodo XML) completa.
//
procedure TXmlComoIni.DeleteSection(const seccion: string);
var
  nodoSeccion: IXMLNode;
begin
  nodoSeccion := FDocXml.DocumentElement.ChildNodes.FindNode(seccion);
  if Assigned(nodoSeccion) then
    FDocXml.DocumentElement.ChildNodes.Delete(nodoSeccion.NodeName);
end;

end.

TXMLDocument
 

Gracias pero prefiero trabajar con componentes de delphi, si alguien tiene ejemplos de como trabajar con TXMLDocument, se lo agradeceria si los colgase, gracias de antemano.

Hola,

Esto... el código fuente que expongo más arriba trabaja con el componente de Delphi "TXMLDocument"... No he dicho que uses "mi componente", sino que te fijes en que ahí se implementan métodos que usan el componente "TXMLDocument" para escribir, leer, editar un archivo XML, etc.

Es decir, en mi opinión, me ha parecido que el componente que yo escribí (y que no dije que useses) trabaja con el componente que a ti te interesa. Lo puse por si podía servirte de algo, vamos.

Vale, no te entendí, lo mirare gracias

Hola,

Estupendo. Como además me doy cuenta de que el código de arriba tiene ciertas "dependencias", porque el componente que expongo forma parte de un conjunto de componentes que comparten cierto código, digo, que te paso el enlace desde donde puedes descargar todo el conjunto de componentes: no para que los uses, sino para que puedas instalarlos (temporalmente) y echar un vistazo en su plenitud al componente que más puede intersarte: TXmlComoIni.

Paquete de componentes DecComp.

Por otro lado en About Delphi tienes algunos enlaces que pueden ser de tu interés.

Muchas gracias, de momento lo que queria ya lo he conseguido, un saludo a todos.

ayuda
 

podrias ayudarme??

necesito crear un archivo xml con los datos de una clase persona

Código Delphi [-]
type 
persona = class
private
 nombre:string;
 edad:integer;
 sexo; string;

la idea es que el archivo Xml
quede asi

<persona>
<nombre>juan<nombre/>
<edad>24<edad/>
<sexo>Masculino<sexo/>
<persona/>

por fa ayudame!! gracias:eek::confused:

Hola,

A ver si nos entendemos... para tratar con archivos XML en Delphi se cuenta, entre otros, con el componente "TXMLDocument", que está en la pestaña "Internet" de la paleta de componentes. Ahora bien, ¿tienes algún problema en usar este componente? ¿Estás intentando algo pero no te sale? ¿Qué estás intentando? Yo creo que podríamos empezar por ahí... o por mejor decir podrías empezar por ahí... :)

hola
 

gracias por contestar.. lo que yo quiero es muy simple

como utilizo el TXMLDocument para crear un archivo XML como el del ejemplo de la persona (es decir llenar el XML de datos de un objeto)...

la verdad no tengo ni idea de como hacerlo y me gustaria ver un ejemplo muy basico de como crear el xml y como leerlo

gracias

Hola,

Tal vez te interese echar un vistazo al componente "TXmlComoIni", que encontrarás dentro del paquete de componentes "DecComp", que a su vez puedes descargar desde el Directorio de archivos del ClubDelphi. Ahí puedes ver cómo se crea un archivo XML a partir del componente "TXmlDocument"; cómo se crean "nodos" en el mismo y se escriben valores en ellos; también puedes ver cómo se leen archivos XML con el mismo componente.

nooo
 

hola de nuevo...
mira que baje tu componente y lo instale, pero no me da la funcionalidad que necesito... lo que yo quiero hacer es:

tengo un array de objetos (array of Persona), necesito recorrer el array y guardar todos los datos en un XML...

HELPPPPPPPP:eek:

Hola,

Bueno... eso de que no te da la funcionalidad que necesitas está por ver. Además de que no te dije que usases sin más el componente "TXmlComoIni", sino que lo estudiaras, que no es lo mismo. Porque en dicho componente puedes ver cómo se crea un archivo XML, cómo puede escribrirse en el mismo, cómo pueden leerse los datos... guardar un archivo, cargar un archivo, entre otras cosas. Tendrías que fijarte un poco más, en mi opinión, de modo que pudieras adaptar el código fuente (y los conocimientos implícitos en el mismo) a tus propias necesidades.

Hola Dec
 

que pena mi ignorancia, pero es que he analizado tu codigo y la verdad es que no logro crear el archivo como yo quiero

Código Delphi [-]
procedure TFrmPrincipal.ToolButton4Click(Sender: TObject);
var
  FDocXml: TXMLDocument;
  nodoClave, nodoSeccion: IXMLNode;

begin
SaveDialog1.Filter:='Archivo XML(*.xml)|*.XML';
if SaveDialog1.Execute then
begin
   FDocXml :=  TXMLDocument.Create(Self);
   FDocXml.Options := [doNodeAutoIndent];
   FDocXml.Active:=true;
   nodoSeccion := FDocXml.AddChild('PERSONA');
   nodoClave := nodoSeccion.AddChild('Nombre');
   FDocXml.SaveToFile(SaveDialog1.FileName+'.xml');;

end;
end;

lo que necesito crear es algo asi

<PERSONA>
<NOMBRE> JUANK <NOMBRE/>
<OTROVALOR>1983<OTROVALOR/>
<PERSONA/>

se que el codigo esta mal, pero te juro que he buscado en muchas partes y no logro encontrar un ejemplo asi de basico

te agradeceria si me ayudas:eek::confused:

lo hice
 

bueno creo que lo hice...

Código Delphi [-]
procedure TFrmPrincipal.ToolButton4Click(Sender: TObject);
var
  FDocXml: TXMLDocument;
  nodoClave, nodoSeccion, nodoObjeto: IXMLNode;
  i:Integer;
begin
SaveDialog1.Filter:='Archivo XML(*.xml)|*.XML';
if SaveDialog1.Execute then
begin

   FDocXml :=  TXMLDocument.Create(Self);
   FDocXml.Options := [doNodeAutoIndent];
   FDocXml.Active:=true;
   nodoSeccion := FDocXml.AddChild('OBJETOS');
    for i := 0 to High(ArrayObjetos) do
     begin
      nodoClave := nodoSeccion.AddChild('Objeto');
      nodoObjeto := nodoClave.AddChild('Nomre');
      nodoObjeto.Text := ArrayObjetos[i].getNombreObj;
      nodoObjeto := nodoClave.AddChild('año');
      nodoObjeto.Text := ArrayObjetos[i].getaño;

     end;


   FDocXml.SaveToFile(SaveDialog1.FileName+'.xml');;
end;
end;

pero creo que no me sirve por que dentro del array de objetos tengo valores que no son string como Ticon,

hay alguna forma de guardar el objeto completo??
es decir algo asi como serializarlos

Responder Esta
 

BUENO AL FINAL DEL DIA TOME LA DESICION DE IMPLEMETARLO ASI

Código Delphi [-]

procedure TFrmPrincipal.ToolButton4Click(Sender: TObject);
var
  FDocXml: TXMLDocument;
  nodoClave, nodoSeccion, nodoObjeto, nodoRegla: IXMLNode;
  i,j,k:Integer;
  escena:String;
begin
SaveDialog1.Filter:='Archivo XML(*.xml)|*.XML';
if SaveDialog1.Execute then
begin
   escena:='';
   FDocXml :=  TXMLDocument.Create(Self);
   FDocXml.Options := [doNodeAutoIndent];
   FDocXml.Active:=true;
   FDocXml.Version := '1.0';
   nodoSeccion := FDocXml.AddChild('MODELO');
    for i := 0 to High(ArrayObjetos) do
     begin
      nodoClave := nodoSeccion.AddChild('OBJETO');
        nodoObjeto := nodoClave.AddChild('Nombre');nodoObjeto.Text := ArrayObjetos[i].getNombreObj;
        nodoObjeto := nodoClave.AddChild('Tipo');nodoObjeto.Text :=IntToStr(ArrayObjetos[i].getTipoObj);
        nodoObjeto := nodoClave.AddChild('Color');nodoObjeto.Text :=ColorToString(ArrayObjetos[i].getColor);
        nodoObjeto := nodoClave.AddChild('Movimiento');
          nodoObjeto.Attributes['Activa']:= BoolToStr(ArrayObjetos[i].getMovimiento);
          nodoObjeto.Attributes['UP']:= BoolToStr(ArrayObjetos[i].getUP);
          nodoObjeto.Attributes['DOWN']:= BoolToStr(ArrayObjetos[i].getDOWN);
          nodoObjeto.Attributes['LEFT']:= BoolToStr(ArrayObjetos[i].getLEFT);
          nodoObjeto.Attributes['RIGT']:= BoolToStr(ArrayObjetos[i].getRIGHT);
       nodoObjeto := nodoClave.AddChild('Expansion');
          nodoObjeto.Attributes['Activa']:= BoolToStr(ArrayObjetos[i].getMovimiento);
          nodoObjeto.Attributes['UP']:= BoolToStr(ArrayObjetos[i].getEUP);
          nodoObjeto.Attributes['DOWN']:= BoolToStr(ArrayObjetos[i].getEDOWN);
          nodoObjeto.Attributes['LEFT']:= BoolToStr(ArrayObjetos[i].getELEFT);
          nodoObjeto.Attributes['RIGT']:= BoolToStr(ArrayObjetos[i].getERIGHT);
       nodoObjeto := nodoClave.AddChild('Decadencia');
          nodoObjeto.Attributes['Activa']:= BoolToStr(ArrayObjetos[i].getDecadencia);
       nodoObjeto := nodoClave.AddChild('Eliminacion');
          nodoObjeto.Attributes['Activa']:= BoolToStr(ArrayObjetos[i].getEliminacion);
          nodoObjeto.Attributes['ObjAElimin']:= IntToStr(ArrayObjetos[i].getObjAElimin);
      nodoObjeto := nodoClave.AddChild('Neutralizacion');
          nodoObjeto.Attributes['Activa']:= BoolToStr(ArrayObjetos[i].getNeutralizacion);
          nodoObjeto.Attributes['ObjANeutra']:= IntToStr(ArrayObjetos[i].getObjANeutra);
      nodoObjeto := nodoClave.AddChild('Reproduccion');
          nodoObjeto.Attributes['Activa']:= BoolToStr(ArrayObjetos[i].getReproduccion);
      nodoObjeto := nodoClave.AddChild('Retraccion');
          nodoObjeto.Attributes['Activa']:= BoolToStr(ArrayObjetos[i].getRetraccion);
      nodoObjeto := nodoClave.AddChild('Transformacion');
          nodoObjeto.Attributes['Activa']:= BoolToStr(ArrayObjetos[i].getTransformacion);
          nodoObjeto.Attributes['NewObjtransf']:= IntToStr(ArrayObjetos[i].getNewObjtransf);
     end; //end for
     //------------mapa----------------------
        for j := 0 to ColumnaEsc - 1 do
          for k := 0 to FilaEsc - 1 do
             escena:=escena+IntToStr(ArrayEsc[j,k].getTipoObj)+'|';

      nodoClave := nodoSeccion.AddChild('ESCENARIO');
      nodoClave.Attributes['NombreEsc']:=NombreEsc;
      nodoClave.Attributes['ColorEsc']:=ColorToString(ColorEsc);
      nodoClave.Attributes['ColumnaEsc']:=IntToStr(ColumnaEsc);
      nodoClave.Attributes['FilaEsc']:=IntToStr(FilaEsc);
      nodoObjeto := nodoClave.AddChild('Mapa');nodoObjeto.Text := escena;


   FDocXml.SaveToFile(SaveDialog1.FileName+'.xml');;
end;
end;

LO QUE ME GENERA ESTO

AHORA COMO HAGO PARA POR EJEMPLO AL NOMBRE DEL SEGUNDO OBJETO??

AYUDDAAAA

MEJOR DICHO COMO HAGO PARA ACCEDER A CADA UNO DE LOS DATOS

:confused::confused::confused::confused::confused::confused:

Oye amigo DEC, ya no se encuentra disponible la liga que diste aquí... de donde puedo descargar tu suite de componentes???

Hola,

Bueno. Te pido disculpas. Esto de cambiar de sitio las cosas no puede llevar sino a confundir al personal. En todo caso llamar "suite de componentes" a DecComp... no sé yo, ¿eh? Son más bien unos muy sencillos componentes, que, bueno, llegado el caso puede que te sirvan de algo. Ahora mismo los encuentras disponibles en el Directorio de archivos del ClubDelphi. :)

XML con ClientDataSet...
 

Hola Madmai...

Creo saber lo que ocupas, mira, Yo hice algo mas o menos como lo que necesitas y para ello eche mano del XMLMapper que viene con Delphi, ahi puedes generar el XMLDocument y dos transformaciones que son ToDp.xtr y ToXML.xtr. El archivo ToDp.xtr te sirve para convertir lo que esta en el XMLDocument a un DataPacket y el archivo ToXML.xtr hace lo contrario, convierte el DataPacket a un XML.

Aqui tienes algo sobre XML Mapper:

http://dn.codegear.com/article/28010


Una vez que generes estos 3 archivos: XMLDocument.XML, XMLDocumentToDp.xtr, XMLDocumentToXML.xtr, ahora en Delphi ocupas de los siguientes componentes:

XMLTransformProvider (En la paleta de DataAccess)
ClientDataSet (En la paleta DataAccess o tu preferido)

Ahora bien, primero tienes que configurar el XMLTransformProvider las siguientes propiedades en el inspector de objetos:

* Name = XMLDsp

* TransformRead.TransformationFile = Ruta completa de tu archivo XMLDocumentToDp.xtr

* TransformWrite.TransformationFile = Ruta completa de tu archivo XMLDocumentToXML.xtr

* XMLDataFile = Ruta compleata de tu archivo XMLDocument.XML


Una vez que ya tengas echo lo anterior, ahora en el Componente ClientDataSet solo tienes que ajustar la propiedad

ProviderName = XMLDsp

Espero te sirva....

Edgar Perez...