Because Microsoft XML Core services is a separate library, to use it in Microsoft Access, you must "load" it. To do this, you have two options. One option is to graphical load the library. Another option is to programmatically do it. To graphically load MSXML, on the main menu of Microsoft Visual Basic, click Tools -> References... In the References dialog box, click the check box of the latest version of Microsoft XML. Click OK. To programmatically load MSXML, you should first (make sure you get the latest release of the MSXML library from the Microsoft web site and) know the version of MSXML installed on your computer or the version that is installed in your users' computers. Declare a variable of type Object. To initialize it, call the global CreateObject() function and pass it the MSXML library you want to use. This can be done as follows: Private Sub cmdLoadXMLLibrary_Click()
Dim xmlDocument As Object
Set xmlDocument = CreateObject("MSXML2.DOMDocument.3.0")
Set xmlDocument = Nothing
End Sub
From then, you can use Microsoft XML Core services in your Microsoft Access project.
Like a traditional programming library, Microsoft XML Core services provides many types of objects. As you may know already, a class is a building block or a way to describe what an object looks like. It is like the architural design of a house. It is not the house itself but it describes how a house built from that design should look like. A class is supposed to be complete in the sense that it gives a complete description (or provides a complete structural description) of the objects that will be created or built from it. Another type of object in a library is called an interface. An interface is like a class, which specifies the structure of an object. In the traditional programming sense, an interface is (usually) a (n incomplete) structure from which actual classes can be built (we say that it is an abstract from which actual classes can be created). This means that, in the traditional sense of computer programming, an interface is a vague description of a structure. An example of an interface would be a residence (Is it a house? Is it a commercial building? Is it an appartment complex? Is it a moving house? Is it a tent? etc). Once an interface exists, more appropriate and precise classes are created from it (such as houses, tents, etc). By tradition, the name of an interface starts with I (this distinguishes it from a class; but this is not a rule, just an indication). Without going through all the boring (and probably uncessary) details (there is no way we can go through all the issues to know about object-oriented programming (OOP) here), the few things to know are that:
The MSXML library provides many classes and interfaces. To use any of them, you can (in most cases, you must) declare a variable of the desired type and appropriately initialize it.
While creating an XML document, you must follow some rules in order to get a valid document. An XML document that follows all the necessary rules is said to be "well-formed". The XML rules are standardized by the W3C Document Object Model (DOM). To support these standards, Microsoft XML Core services provides a class named DOMDocument that makes it possible to start an XML document, to populate it with the desired contents, and to perform many other related operations on the contents of the document. Before using a DOM, declare a variable of type DOMDocument and initialize it using the New operator. This can be done as follows: Private Sub cmdCreateDOMDocument_Click()
Dim docXMLDOM As DOMDocument
Set docXMLDOM = New DOMDocument
End Sub
This causes the DOM object to be loaded into the computer's memory and start using resources. Eventually, after using the object, you should remove it from memory. This is done by assigning Nothing to it. This can be done as follows: Private Sub cmdCreateDOMDocument_Click()
Dim docXMLDOM As DOMDocument
Set docXMLDOM = New DOMDocument
Set docXMLDOM = Nothing
End Sub
If you already know or have the XML code you want to use, the DOMDocument class allows you to provide it. This is done using one of the class's methods named loadXml. Its syntax is: Public Function loadXml(ByVal bstrXML As String) As Boolean This method takes a String as argument and returns a Boolean value. The DOMDocument.loadXml() method doesn't create an XML file, it only allows you to provide or create XML code. The code can be created as argument. You can also first declare and initialize a String variable with the XML code, then pass it as argument to the DOMDocument.loadXml() method.
Probably the most common way to create an XML document in Microsoft Windows consists of using Notepad or any other text editor. After opening the text editor, you can enter the necessary lines of code. After creating the file, you must save it. When saving it, you can include the name of the file in double-quotes. You can also first set the Save As Type combo box to All Files and then enter the name of the file with the .xml extension.
If you call the DOMDocument.loadXml() method, only the XML code is created, not the file. To let you create the Windows file, the DOMDocument is equipped with a method named save(). Its syntax is: Public Sub save(ByVal FileName As String) This method takes one argument that can be a valid file name and must include the .xml extension. You can also pass the whole path where the file must be located.
Probably the easiest way to open an XML file is with a text editor such as Notepad. You can also open the file using a Web browser or an appropriate application that recognizes XML code. To let you open an XML file, the DOMDocument class is equipped with a method named load. Its syntax is: Public Function load(ByVal FileName As String) The method takes as argument the name or path of the file. Here is an example of calling it: Private Sub cmdCreateDOMDocument_Click()
Dim docXMLDOM As Object
Set docXMLDOM = CreateObject("MSXML2.DOMDocument.3.0")
docXMLDOM.Load "Employees.xml"
Set docXMLDOM = Nothing
End Sub
You can also provide a complete path to the file.
An XML document appears as an upside-down tree with many branches and leaves. Each of these objects is called a node. To support the nodes of an XML document, the MSXML library provides an interface named IXMLDOMNode. This is the ancestor to all types of nodes.
An XML document can contain various types of nodes. The categories or possible types of nodes are identified by an enumeration named DOMNodeType. Each of the different types of nodes we will use has a corresponding member in that enumeration. An XML document can start with the type of character scheme it is using. This is known as the encoding declaration. That declaration gives instructions to the parser on the types or groups of characters and symbols used in your document. This is done with a line as follows: <?xml version="1.0" encoding="utf-8"?> Remember that, in your VBA code, you can use the single-quote inside a string, or you can double the double-quote. Here are examples: Private Sub cmdCreateProcessingInstructions_Click()
Dim docXMLDOM As Object
Set docXMLDOM = CreateObject("MSXML2.DOMDocument.3.0")
docXMLDOM.loadXML "<?xml version=""1.0"" encoding=""utf-8""?>"
Set docXMLDOM = Nothing
End Sub
To support processing instructions, the MSXML library provides an interface named IXMLDOMNode. On the other hand, to help you create an encoding declaration, the DOMDocument class is equipped with a method named createProcessingInstruction. Its syntax is: Public Function createProcessingInstruction(ByVal target, ByVal data As String) As IXMLDOMProcessingInstruction This method takes two arguments. The first argument can be passed as "xml". The second argument specifies the version of XML used. In most cases, this should be set to "version='1.0'". This method returns an object of type IXMLDOMProcessingInstruction. This means that you can call the DOMDocument.createProcessingInstruction() method and assign it to an IXMLDOMProcessingInstruction variable you would have previously declared. In reality, you have two versions. You can declare a variable of type IXMLDOMProcessingInstruction and use it. Here is an example: Private Sub cmdCreateProcessingInstructions_Click()
Dim docXMLDOM As DOMDocument
Dim piDeclaration As IXMLDOMProcessingInstruction
Set docXMLDOM = New DOMDocument
Set piDeclaration = docXMLDOM.createProcessingInstruction("xml", "version='1.0'")
Set docXMLDOM = Nothing
End Sub
An alternative is to use a variable of type IXMLDOMNode.
An XML document is made of small objects or sections named elements. Each element is created based on strict rules. A classic XML element is made of three parts:
There are rules you must follow when naming an element
The value can be anything, but some letters may not automatically display rightly. Such letters must be appropriatly formatted. To support XML elements, the MSXML library is equipped with an interface named IXMLDOMElement. In the DOMNodeType enumeration, the XML element is represented by the NODE_ELEMENT member.
Every XML document must have one particular element that either is the only element in the document or acts as the parent of all the other elements of the same document. This element is referred to as the root. If there are many elements in an XML document, one of them must serve as the root. To give you access to the root element of an XML document, the DOMDocument class of the MSXML library has a property named documentElement. To specify that an element is the root, you can assign its reference to this property (we will see many examples). If an XML document exists already, to access its root, get a reference to the DOMDocument.documentElement property.
Since IXMLDOMElement is an interface, in order to use it, you must obtain its value from another class. To assist you with creating an element, the DOMDocument class is equipped with a method named createElement. Its syntax is: Public Function createElement(ByVal tagName As String) As IXMLDOMElement This method takes one argument and returns an element as a IXMLDOMElement object. When calling this method, you get a reference to the newly created element. If that element is the root, assign it to the documentElement property of the DOMDocument class. Here is an example: Private Sub cmdCreateElement_Click()
Dim docXMLDOM As DOMDocument
Dim nodElement As IXMLDOMElement
Set docXMLDOM = New DOMDocument
Set nodElement = docXMLDOM.createElement(...)
Set docXMLDOM.documentElement = nodElement
Set docXMLDOM = Nothing
End Sub
As mentioned earlier, the primary formula of an element is a start tag, a name, and an end tag. The name of an element is the string that represents the tag. For example, in <Director>, the word Director is the name of the element. An element must have at least a start-tag. As mentioned in the previous section, you can create an element by calling the DOMDocument.createElement() method. This method takes one argument as the name of the element to be created. When calling this method, assign its returned value to an IXMLDOMNode-based variable, such as an IXMLDOMElement object, you would have declared. Here is an example: Private Sub cmdCreateElement_Click()
Dim docXMLDOM As DOMDocument
Dim nodElement As IXMLDOMElement
Set docXMLDOM = New DOMDocument
Set nodElement = docXMLDOM.createElement("houses")
Set docXMLDOM.documentElement = nodElement
docXMLDOM.Save "C:\Exercises\Houses1.xml"
Set docXMLDOM = Nothing
End Sub
This would produce: <?xml version="1.0"?> <house/> If an element exists already, to let you get its name, the IXMLDOMNode interface is equipped with a property named tagName. Here is an example of accessing it: Private Sub cmdCreateDOMDocument_Click()
Dim docXMLDOM As DOMDocument
Dim nodElement As IXMLDOMElement
Set docXMLDOM = New DOMDocument
Set nodElement = docXMLDOM.createElement("houses")
Set docXMLDOM.documentElement = nodElement
MsgBox nodElement.tagName
Set docXMLDOM = Nothing
End Sub
This would produce:
The value of an element is referred to as its text. To support such a value, the IXMLDOMNode interface is equipped with a String-based property named Text. To specify the name of an element, assign the desired string to its variable. Here is an example: Private Sub cmdCreate_Click()
Dim docXMLDOM As DOMDocument
Dim nodElement As IXMLDOMElement
Set docXMLDOM = New DOMDocument
Set nodElement = docXMLDOM.createElement("house")
nodElement.Text = "Single Family"
Set docXMLDOM.documentElement = nodElement
docXMLDOM.Save "C:\Exercises\Houses2.xml"
Set docXMLDOM = Nothing
End Sub
This would produce: <?xml version="1.0"?> <house>Single Family</house> If an element exists already, to find out about its value, you can get its Text value.
To let you get all the values of an XML document, the IXMLDOMNode interface is equipped with a property named xml. Here is an example of accessing it: Private Sub cmdCreate_Click()
Dim docXMLDOM As DOMDocument
Set docXMLDOM = New DOMDocument
docXMLDOM.Load "C:\Exercises\Videos.xml"
MsgBox docXMLDOM.xml
Set docXMLDOM = Nothing
End Sub
If an element exists already, to find out about its value, you can get its Text value.
Besides the obvious types of values, you may want to display special characters as values of elements. Consider the following example: <FullName>Sylvie <Nellie> Aronson</FullName> If you try using this XML document, for example, if you try displaying it in a browser, you would receive an error. The reason is that when the parser reaches the <FullName>Sylvie <Nellie> Aronson</FullName> line, it thinks that <Nellie> is a tag but then <Nellie> is not closed. The parser concludes that the document is not well-formed, that there is an error. For this reason, to display a special symbol as part of a value, you can use its character code. For example, the < (less than) character is represented with < and the > (greater than) symbol can be used with >. Therefore, the above code can be corrected as follows: <FullName>Sylvie <Nellie> Aronson</FullName> Here is a list of other codes you can use for special characters: |
|
|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Practical
Learning: Introducing MSXML
and click the form. If the wizard starts, click Cancel
