For many Delphi programmers, saving settings is associated with using INI files in your programs. The use of this method, in more or less serious projects, should be avoided, as it limits flexibility, which prevents further expansion of the program. It is worth saying that this approach is quite popular, due to its ease of use and the presence of built-in tools in the development environment.

However, the ideal option for storing program settings are structured XML files. Their advantage is that the number of parameters may not be fixed. To understand this better, let's look at a specific example.

In the USearch program, when you click on an entry, a context menu appears in which a list of items is displayed. These items are commands, which in turn are loaded from the settings file. If the settings were stored in INI file, the program could save and load a certain number of instructions, such as 10 or 50. As soon as a larger value is needed, the code will have to be rewritten and recompiled accordingly.

Taking the approach using XML files, we will be able to load all section parameters dynamically. To all this, the configuration file will become more elegant, without excessive numbering of parameters. But, standard means to work with XML in Delphi have many disadvantages, so I recommend using standard library MSXML. It is usually included by default operating systems Windows family.

To connect MSXML, we need to generate an interface file with a list of all functions by importing it from the COM server. How to import an interface, quite a few detailed articles have been written, but I suggest you download the file MSXML2_TLB.PAS already ready to use. After the file is downloaded, place it next to your project, or drop it into the lib folder of the Delphi environment. Thus, all created programs will be able to use the module MSXML, you just need to add the line MSXML2_TLB to uses .

For clarity, consider the following example of using this library:

LoadProcedureData; var XMLDoc: DOMDocument; Root: IXMLDOMElement; begin XMLDoc:= CoDOMDocument.Create; XMLDoc.Load("settins.xml"); Root:= XMLDoc.DocumentElement; ShowMessage(Root.SelectSingleNode("size/width").Text); Root:= nil; XMLDoc:= nil; end;

First, an instance of the DOMDocument class is created, and then the contents of the settings.xml file are loaded into memory. Since according to the standard any XML the file must contain a root tag (in this case config), then we need to get it using the function DocumentElement. Then the content between the tags is displayed , which in turn are between the tags . Thus, from the settings.xml file, our method will display the text in the MessageBox "100px".

500px 100px

Here the SelectSingleNode method is used, which takes a string as a parameter

Despite the fact that the topic of working with XML in Delphi has been widely discussed on the Internet, questions on this topic quite often arise on all kinds of forums.

I've already posted this as well, but I'd like to get back to a real case of quickly parsing an XML file and extracting data, which I did at work today. It took me no more than 5 minutes to get the necessary data.

Background. Today it was necessary to process data on installed programs on users' computers (yes, yes, we detect pirates :)). The technical department provided me with such information ripped from unsuspecting users over a network using WMI. The program they used generates reports in XML format. Accordingly, they brought me a mountain of XML files with a rather complex structure, from which I needed to extract only the name of the installed software products.

Treatment . After reviewing a couple of files manually, I realized that it would not take long to grow old, and decided to write a small converter. Launching Delphi, I selected the XML DataBinding object in the repository and fed it one of the files. I left all the settings and parameters by default, and as a result, I formed a module with large quantity classes and interfaces to access the elements of this XML file. I did not begin to deal with the class structure for a long time, I immediately proceeded to writing a converter.

In a new console application, I wrote a fairly simple code:

uses
forms,
Classes, SysUtils,
SoftwareXML in "SoftwareXML.pas";

procedure CovertXML2Text;
var
softbase: IXMLSTDSoftwareType;
i: integer;
sr: TSearchRec;
CurDir:string;
ExportFile: TStringList;
begin
CurDir:= IncludeTrailingPathDelimiter(ExtractFilePath(Application.ExeName));
if FindFirst(CurDir+"*.xml", faAnyFile, sr) = 0 then
repeat
ExportFile:= TStringList.Create;
softbase:= LoadSTDSoftware(Pchar(CurDir+sr.Name));
for i:= 0 to softbase.InstalledSoftware.source.software.Count - 1 do
ExportFile.Add(softbase.InstalledSoftware.source.software[i].DisplayName);
ExportFile.Sort;
ExportFile.SaveToFile(CurDir + softbase.InstalledSoftware.Source.servername+".txt");
ExportFile.Free;
until FindNext(sr) 0;
end;

begin
Application.Initialize;
CovertXML2Text;
end.

As a result of which, I got one textbook for each computer in the grid, containing a list of installed software.

I feel that this code will require explanations. For example, why did I use the Forms module in a console application and call the Application.Initialize; procedure?

In fact, everything is simple - this is a small hack that allows you to use XML Data Binding in a console application. Because it stubbornly refused to initialize the class for working with XML. I haven’t figured out the true reasons yet - today time was important, and so I spent 4 out of 5 minutes fighting this error. :) I think later to deal with this problem and write what is the real reason.

The strange softbase class was created based on an XML file - that was the name of the root element, and softbase.InstalledSoftware.source.software[i].DisplayName - just navigating through nested elements to the desired one and getting its value.

This is what one of the most looks like. quick ways working with XML in Delphi.

XML is increasingly being used to store information and exchange it between applications and Web sites. In many applications, this language is used as a base language for storing data, in others - for exporting and importing XML data. It follows from this that it is time for developers to think about how XML data can be used in their own applications.

In this article, we'll take a look at the XML Document Object Model (DOM) and Microsoft's implementation of it, the Microsoft XML DOM.

The XML DOM is an object model that provides the developer with objects for loading and manipulating XML files. The object model consists of the following main objects: XMLDOMDocument, XMLDOMNodeList, XMLDOMNode, XMLDOMNamedNodeMap, and XMLDOMParseError. Each of these objects (except XMLDOMParseError) contains properties and methods that allow you to get information about the object, manipulate the values ​​and structure of the object, and navigate the structure of the XML document.

Let's look at the main XML DOM objects and give some examples of their use in Borland Delphi.

Using XML DOM in Borland Delphi

In order to use the Microsoft XML DOM in Delphi applications, you must include the appropriate type library in your project. To do this, we execute the command Project | Import Type Library and in the Import Type Library dialog box, select the Microsoft XML version 2.0 (Version 2.0) library, which is usually located in the Windows\System\MSXML.DLL file

After clicking the Create Unit button, the MSXML_TLB interface module will be created, which will allow us to use the XML DOM objects: DOMDocument, XMLDocument, XMLHTTPRequest and a number of others implemented in the MSXML.DLL library. A reference to the MSXML_TLB module must be specified in the Uses list.

XML DOM device

The Document Object Model represents an XML document as a tree structure consisting of branches. The XML DOM APIs allow applications to traverse the document tree and manipulate its branches. Each branch can have a specific type (DOMNodeType), according to which the parent and child branches are defined. In most XML documents, you will find element, attribute, and text branches. Attributes are a special kind of branch and are not child branches. Attributes are managed. special methods, provided by XML DOM objects.

In addition to implementing the World Wide Web Consortium (W3C) recommended interfaces, the Microsoft XML DOM contains methods that support XSL, XSL Patterns, Namespaces, and data types. For example, the SelectNodes method allows you to use the XSL Pattern Syntax to find branches in a specific context, and the TransformNode method supports using XSL to perform transformations.

Test XML Document

As an example of an XML document, let's take a music CD-ROM directory, which has the following structure:

Bob Dylan USA Columbia 10.90 1985 Bonnie Tylor UK CBS Records 9.90 1988 ... Joe Cocker USA EMI 8.20 1987

Now we're ready to start looking at the XML DOM object model, which we'll start with the XMLDOMDocument object.

XML document - XMLDOMDocument object

Working with an XML document begins with loading it. To do this, we use the Load method, which has only one parameter, which specifies the URL of the document to be loaded. When loading files from a local disk, only the full file name is specified (the file:/// protocol can be omitted in this case). If the XML document is stored as a string, you should use the LoadXML method to load the document.

To control how the document is loaded (synchronous or asynchronous), use the Async property. By default, this property is set to True to indicate that the document is loaded asynchronously and control is returned to the application before the document is fully loaded. Otherwise, the document is loaded synchronously, and then you have to check the value of the ReadyState property to see if the document has loaded or not. You can also create an event handler for the OnReadyStateChange event that will receive control when the value of the ReadyState property changes.

The following shows how to load an XML document using the Load method:

Uses ... MSXML_TLB ... procedure TForm1.Button1Click(Sender: TObject); var XMLDoc: IXMLDOMDocument; begin XMLDoc:= CoDOMDocument.Create; XMLDoc.Async:= False; XMLDoc.Load('C:\DATA\DATA.xml'); // // Here is the code that manipulates // the XML document and its branches // XMLDoc:= Nil; end;

After the document is loaded, we can access its properties. For example, the NodeName property will contain the value #document, the NodeTypeString property will contain the value document, and the URL property will contain the value file:///C:/DATA/DATA.xml.

Error Handling

Of particular interest are the properties associated with the processing of the document when it is loaded. For example, the ParseError property returns an XMLDOMParseError object containing information about an error that occurred while processing the document.

To write an error handler, you can add the following code:

Var XMLError: IXMLDOMParseError; ... XMLDoc.Load('C:\DATA\DATA.xml'); XMLError:= XMLDoc.ParseError; If XMLError.ErrorCode<>0 Then // // Here we handle the error // Else Memo1.Lines.Add(XMLDoc.XML); ... XMLDoc:= Nil;

To find out what information is returned in case of an error, change the following directory entry:

Bob Dylan USA Columbia 10.90 1985

remove closing element .

Now let's add a new branch. Below is the code showing how to add a new music CD-ROM entry:

Var NewNode: IXMLDOMNode; Child: IXMLDOMNode; ... // Create a new branch - NewNode:= XMLDoc.CreateNode(1, 'CD', ''); // Add element Bob Dylan USA Columbia 10.90 1985 Bonnie Tylor UK CBS Records 9.90 1988 ... Joe Cocker USA EMI 8.20 1987

Now we're ready to start looking at the XML DOM object model, which we'll start with the XMLDOMDocument object.

XML document - XMLDOMDocument object

Working with an XML document begins with loading it. To do this, we use the Load method, which has only one parameter, which specifies the URL of the document to be loaded. When loading files from a local disk, only the full file name is specified (the file:/// protocol can be omitted in this case). If the XML document is stored as a string, you should use the LoadXML method to load the document.

To control how the document is loaded (synchronous or asynchronous), use the Async property. By default, this property is set to True to indicate that the document is loaded asynchronously and control is returned to the application before the document is fully loaded. Otherwise, the document is loaded synchronously, and then you have to check the value of the ReadyState property to see if the document has loaded or not. You can also create an event handler for the OnReadyStateChange event that will receive control when the value of the ReadyState property changes.

The following shows how to load an XML document using the Load method:

Uses ... MSXML_TLB ... procedure TForm1.Button1Click(Sender: TObject); var XMLDoc: IXMLDOMDocument; begin XMLDoc:= CoDOMDocument.Create; XMLDoc.Async:= False; XMLDoc.Load('C:\DATA\DATA.xml'); // // Here is the code that manipulates // the XML document and its branches // XMLDoc:= Nil; end;

After the document is loaded, we can access its properties. For example, the NodeName property will contain the value #document, the NodeTypeString property will contain the value document, and the URL property will contain the value file:///C:/DATA/DATA.xml.

Error Handling

Of particular interest are the properties associated with the processing of the document when it is loaded. For example, the ParseError property returns an XMLDOMParseError object containing information about an error that occurred while processing the document.

To write an error handler, you can add the following code:

Var XMLError: IXMLDOMParseError; ... XMLDoc.Load('C:\DATA\DATA.xml'); XMLError:= XMLDoc.ParseError; If XMLError.ErrorCode<>0 Then // // Here we handle the error // Else Memo1.Lines.Add(XMLDoc.XML); ... XMLDoc:= Nil;

To find out what information is returned in case of an error, change the following directory entry:

Bob Dylan USA Columbia 10.90 1985

remove closing element .

Now let's add a new branch. Below is the code showing how to add a new music CD-ROM entry:

Var NewNode: IXMLDOMNode; Child: IXMLDOMNode; ... // Create a new branch - NewNode:= XMLDoc.CreateNode(1, 'CD', ''); // Add element