dom_xml for c#

MỤC LỤC

Lời Mở Đầu..............................................................................................................4

1. Thuật ngữ..........................................................................................................5

Thuật ngữ.................................................................................................................5

2. Tổng quan về XML...........................................................................................6

3. Tổng quan về DOM.........................................................................................11

4. Microsoft .NET và XML.................................................................................12

5. Đọc tài liệu XML.............................................................................................16

6. Các lớp XmlWrite............................................................................................21

Hàm Close..............................................................................................................21

Tìm hiểu thi công DOM........................................................................................23

Tìm hiểu thi công DOM........................................................................................23

7. Lớp XmlNote...................................................................................................23

Lớp XmlNote..........................................................................................................23

8. Lớp xmlDocument...........................................................................................23

Lớp xmlDocument.................................................................................................23

9. Nạp một tài liệu...............................................................................................24

Nạp một tài liệu......................................................................................................24

10. Lưu trữ một tàu liệu....................................................................................25

Lưu trữ một tàu liệu..............................................................................................25

11. Lớp xmlDocumentFragment.......................................................................25

Lớp xmlDocumentFragment.................................................................................25

1

12. Lớp XmlElement..........................................................................................27

Lớp XmlElement....................................................................................................27

Thêm nút vào một phần tử....................................................................................28

Đi lấy nút gốc (root node)......................................................................................29

Gỡ bỏ và thay thế các nút......................................................................................29

Chèn các mảnh vào tài liệu XML.........................................................................32

Thêm các thuộc tính vào một nút..........................................................................33

13. Biến đổi và XSLT.........................................................................................34

Biến đổi và XSLT...................................................................................................34

XSLT trên .NET.....................................................................................................34

Hàm hành sự Tranform........................................................................................35

Chuyển đổi một tài liệu..........................................................................................35

Thí dụ vè XSM transformation.............................................................................35

14. ADO.NET và XML......................................................................................36

ADO.NET và XML................................................................................................36

Đọc XML sử dụng DataSet...................................................................................36

Hàm hành sự ReasXml..........................................................................................36

Hàm hành sự ReasXmlShema..............................................................................37

Viết XML sử dụng DataSet...................................................................................38

Hàm hành sự WriteXml........................................................................................38

Hàm hành sự WriteXmlSchema...........................................................................40

XmlDataDocument và XML..................................................................................42

2

Nạp dữ liệu sử dụng các hàm Load và LoadXml của lớp XmlDataDocument...42

Nạp dữ liệu sử dụng DataSet................................................................................43

Cho hiển thị dữ liệu XML theo dạng thức DataSet.............................................43

Cất trữ dữ liệu từ một DataSet lên một tài liệu XML...........................................44

15. Đi lại dọc ngang trên XML.........................................................................46

Lèo lái dọc ngang trên XML.................................................................................46

Lớp XPathNavigator..............................................................................................47

Các hàm hành sự Move của lớp XPathNavigator................................................48

Tìm kiếm thong tin sử dụng XpathNivigator........................................................50

16. Visual Studio.NET trong hỗ trợ XML........................................................51

Visual Studio.NET trong hỗ trợ XML..................................................................51

Kết sinh một schema mới.......................................................................................51

Thêm các schema item...........................................................................................52

Làm việc với DataSet.............................................................................................54

Kết sinh ADO.NET Type DataSet từ một Schema...............................................55

Thêm một XML Schema hiện hữu vào dự án......................................................55

Kết sinh một Type DataSet từ một Schema..........................................................56

Kết Luận.................................................................................................................57

Tài liệu tham khảo.................................................................................................58

3

Lời Mở Đầu

1. Microsoft .NET và XML

.Net sử dụng các chức năng của XML để chuyển dữ liệu giữa các ứng dụng ở

ngoài cũng như ở trong

Namespace System.Xml

Namespace System.Xml định nghĩa chức năng thông dụng và chủ yếu của

XML.

Lớp XMLNode : là lớp cơ bản đối với XmlDocument và XmlData,

tượng trung cho một nút đơn lẻ trên một tài liệu.

Các lớp tài liệu :

o Lớp XmlDocument và XmlDocumentFragment tượng trưng lần

lượt cho toàn bộ dữ liệu XML và một phần tài liệu.

o Lớp XmlDataDocument cho phép làm việc với dữ liệu quan hệ

sử dụng đối tượng DataSet. Lớp này cung cấp chức năng cất trữ,

tìm kiếm và thao tác dữ liệu.

o Lớp XmlDocumentType tượng trưng cho kiểu dữ liệu tài liệu.

Lớp XmlNode thi công các hàm Create để tạo những nội dung của một

tài liệu như : Comment, Element, Text...

Các lớp viết và đọc tài liệu XML :

o Bao gồm: XmlReader, XmlWriter, XmlTextWriter,

XmlTextReader, XmlValidatingReader, XmlNodeReader.

o Lớp XmlReader, XmlWriter cho phép truy cập nhanh chóng dữ

liệu trên tài liệu XML

Các lớp khác :

o Lớp XmlConvert cho phép chuyển đổi thành XML

o XmlNamespaceManager giải quyết, thêm và gỡ bỏ các

namespace đối với một collection và cung cấp quản lý phạm vi

đối với những namespace này.

4

o XmlLinkedNode trả về node nằm ngay liền trước và sau node

này.

o XmlNodeList tượng trưng cho một collection các nút.

o

Namespace System.Xml.Schema

Chứa những lớp dùng làm việc với schema XML: XmlSchema,

XmlSchemaAll, XmlSchemaXPath và XmlSchemaType.

Những lớp này hỗ trợ XML schema đối với những cấu trúc và XML schema

đối với những kiểu dữ liệu.

Namespace System.Xml.Serialzation

Namespace này chứa lớp dùng sản sinh hàng loạt các đối tượng thành những

tài liệu dạng XML hoặc streams.

Serialization là tiến trình đọc và viết một đối tượng từ hoặc lưu trữ lên đĩa cứng

Namespace này còn định nghĩa nhiều lớp khác.

Namespace System.Xml.Xpath

Chứa 4 lớp : XPathDocument, XpathExpression, XpathNavigator và

XpathNode.

Lớp XPathDocument cho phép xử lý nhanh tài liệu XML sử dụng XSLT. Lớp

này được tối ưu hóa đối với xử lý XSLT và mô hình dữ liệu Xpath.

Lớp XPathNavigator đọc dữ liệu và đối xử với dữ liệu như là một cây và cung

cấp những hàm thực thi cho phép đi qua một tài liệu thông qua hàm Move.

Namespace System.Xml.Xsl

Namespace này định nghĩa chức năng cho XSLT transfomation, hỗ trợ XSLT 1.0

Lớp XsltTransform định nghĩa chức năng biến đổi dữ liệu sử dụng một XSLT

stylesheet.

5

DOM Interfaces

.NET cung cấp một lớp vỏ bọc bao quanh những giao diện : đó là DOM API

Các lớp này che dấu tất cả mọi sự phức tập của lập trình giao diện và cung cấp

một mô hình lập trình cấp cao đối với các nhà triển khai.

Ngoài DOM, .NET XML API còn cung cấp những lớp tương ứng đối với công

nghệ XPath, XSD và XSLT. Các lớp này được phối hợp với ADO.NET để tương

tác với căn cứ dữ liệu.

Kiến trúc XML .NET

XML .NET API là một lớp vỏ bọc bao quanh các giao diện DOM và cung cấp

một lập trình cấp cao đối với các tài liệu XML.

Phần cốt lõi của kiến trúc XML .NET bao gồm 3 lớp : XmlDocument.

XmlReader và XmlWriter.

Lớp XmlReader gồm: XmlTextReader, XmlValidatingReader và

XmlNodeReader.

Lớp XmlWriter : XmlTextWriter và XmlNodeWriter.

Lớp XmlDocument: XmlNode, XmlElement và XmlAttribute.

Giao diện System.Xml.Xsl gồm những lớp thực thi XSLT.

Thêm System.Xml.Namespace Reference

Trước khi dùng các lớp thuộc namespace System.Xml , cần thêm một quy

chiếu về System.Xml.dll bằng cách Project / Add Reference và thêm lệnh

using System.Xml

2. Đọc tài liệu XML

XmlReader là một lớp cơ bản đối với những lớp đọc tài liệu XML.

6

XmlReader

Các lớp XmlReader

Dùng các lớp XmlTextReader, XmlValidatingReader và XmlNodeReader để

đọc tài liệu XML.

Các lớp này định nghĩa những hàm constructor được nạp chồng (overloaded)

để đọc các tập tin XML, các chuỗi, stream, các đối tượng TextReader,

XmlNameTable, cũng như những tổ hợp các đối tượng trên.

Hàm Read đọc tài liệu từ mắt nút gốc trở đi.

Ví dụ :

XmlTextReader reader = new XmlTextReader(@"C:\books.xml");

System.Console.WriteLine("General Infomation");

System.Console.WriteLine(reader.Name);

System.Console.WriteLine(reader.BaseURI);

System.Console.WriteLine(reader.LocalName);

Đi lấy thông tin về một nút

Thuộc tính Value trả về trị của mắt nút hiện hành

Ví dụ :


while (reader.Read())

{

if(reader.HasValue)

System.Console.WriteLine("Value:" + reader.Value);

}

7

XmlValidatingReaderXmlNodeReaderXmlTextReader

Thuộc tính NodeType trả về kiểu của mắt gút hiện hành dưới dạng

enumeration XmlNodeType :

XmlNodeType type= reader.NodeType;

Các thành viên của enumeration XmlNodeType:

Các thành viên Mô tả

Attribute Thuộc tính của mắt nút

CDATA Phân đoạn CDATA

Comment Mắt nút chú giải

Document Đối tượng tài liệu

DocumentFragment Một đoạn tài liệu

DocumentType Là DTD được biết bởi tag <!DOCTYPE>

Element Mắt nút của phần tử

EndElement Cuối một phần tử

EndEntity Cuối một thực thể

Entity Khai báo thực thể

EntityReference Quy chiếu về một thực thể

None Được trả về nếu XmlReader chưa được gọi vào

Notation Một ghi chú trong một khai báo kiểu tài liệu

ProcessingInstruction Mắt nút tượng trưng cho một white space giữa markup

trong một nội dung mô hình lần lộn

Text Tượng trưng cho một nội dung văn bản của một phần tử

Whitespace Tượng trưng cho một white space giữa markup

XmlDeclaration Mắt nút khai báo một XML

Di chuyển về một node nội dung

Dùng hàm MoveToContent để di chuyển từ mắt nút hiện hành đến nội dung

mắt nút kế tiếp trên một tài liệu XML.

Ví dụ :


If (reader.Read ())

8

{

Console.WriteLine(reader.Name);

reader.MoveToContent();

Console.WriteLine(reader.Name);

}

Hàm GetAttribute của một mắt nút

Hàm GetAttribute là một hàm được nạp chồng.

Hàm này trả về những attribute kèm theo tên được khai báo, chỉ mục, tên cục

bộ hoặc namespace URI.

Thuộc tính HasAttributes để kiểm tra xem một mắt nút có thuộc tính hay

không.

AttributeCount trả về số thuộc tính trên mắt nút.

Ví dụ :

static void Main (string [] args)

{


reader.MoveToContent();

reader.MoveToFirstAttribute();

Console.WriteLine("First Attribute Value" + reader.Value);

Console.WriteLine("First Attribute Name"+ reader.name);

while(reader.Read())

{

if(reader.HasAttributes)

9

{ Console.WriteLine(reader.Name + "Attribute");

For(int i=0; i < reader.AttributeCount; i++)

{

reader.MoveToAttribute(i);

Console.WriteLine("Name: " + reader.Name + "Value: "+

reader.Value);

}

reader.MoveToElement();

}

}

}

Đi tìm một mắt nút

Hàm Skip nhảy bỏ mắt nút hiện hành..

Hàm này dùng khi muốn tìm một nút đặc biệt và muốn nhảy bỏ những mắt nút

khác.

Ví dụ :

static void Main (string [] args)

{


while (reader.Read())

{

if (reader.Name != "bookstore" )

reader.Skip();

10

else

{

Console.WriteLine("Name: " + reader.Name);

Console.WriteLine("level of the node: "+

reader.Depth.ToString());

Console.WriteLine("Value: " + reader.Value);

}

}

}

Đóng lại tài liệu

Dùng hàm Close để đóng tài liệu XML.

Các thuộc tính

Các hàm

3. Các lớp XmlWrite

Các thuộc tính của lớp XmlWriter

3 thuộc tính : WriteState, XmlLang và XmlSpace.

Thuộc tính WritesState: đi lấy tình trạng hiện hành của lớp XmlWriter

Viết các XML Items

Một tài liệu XML có thể có nhiều loại item bao gồm element, comment,

attribute và white space.

11

Hàm WriteStartDocument và WriterEndDocument cho mở và đóng một tài

liệu dùng để viết lên.

Hàm WriteComment sẽ viết chú giải lên tài liệu.

Hàm WriteString sẽ viết một chuỗi lên một tài liệu

Dùng cặp hàm WriteStartElement và WriteEndElement để viết một element

lên một tài liệu.

Dùng WriteStartAttribute và WriteEndAttribute dùng để viết một attribute

Hàm Close

Sử dụng hàm Close khi làm xong việc với đối tượng XmlWriter để đóng lại

stream

using System;

using System.Collections.Generic;

using System.Text;

using System.Xml;

namespace xmlwriter

{

class Program

{

static void Main(string[] args)

{

XmlTextWriter wt = new XmlTextWriter("test.xml", null);

wt.WriteStartDocument();

wt.WriteStartElement("document", "");

wt.WriteStartElement("ho va ten", "");

wt.WriteString("Do Khac Tinh");

wt.WriteEndElement();

wt.WriteStartElement("tuoi", "");

wt.WriteString("22");



12

wt.WriteString("Vu Minh Duc");






wt.WriteString("Pham Long Bien");





XmlTextReader rd = new XmlTextReader("test.xml");

wt.WriteEndDocument();

wt.Close();

}

}

}

4. Lớp XmlNote

Lớp XmlNote là một lớp cơ bản trừu tượng, tượng trưng cho một nút trên

một tài liệu nút cây này có thể là toàn bộ tài liệu. Lớp này định nghĩa khá đầy đủ

các hàm thực thi và thuộc tính để tượng trưng cho một nút tài liệu như là một nút

cây và có thể duyệt qua các nút này. Lớp này còn cung cấp những hàm thực thi

cho phép chèn thêm, thay thế và gỡ bỏ những nút tài liệu.

Thuộc tính ChildNodes trả về tất cả các nút con-cái của nút hiện hành. Bạn

có thể xử lý toàn bộ tài liệu như là một nút và sử dụng ChildNodes để đi lấy tất cả

các nút của tài liệu. Bạn có thể dùng FirstChild, LastChild và HasChildnodes để có

thể duyệt qua nút đầu tiên của tài liệu cho đến nút cuối cùng.Các thuộc tính

ParentNode, PreviousSibling và NextSiling sẽ trả về nút cha mẹ và nút anh chị em

của nút hiện hành. Các thuộc tính phổ biến khác là Attributes, BaseURI,InnerXml,

InnerText,Item, NodeType, Name, Value,vv..

13

Bạn có thể sử dụng hàm thực thi Createnavigator của lớp này tạo một đối

tượng XPathNavigator cho phép sử dụng XPath. Các hàm thực thi Appendchild,

InsertAfter và InserBefore cho phép thêm các nút vào tài liệu. Còn các hàm thực

thi RemoveAll, RemoveChild và replaceChild thì lại cho phép gỡ bỏ hoặc thay thế

những nút tài liệu.

5. Lớp xmlDocument

Lớp XmlDocument tượng trưng cho tài liệu XML. Vì nó được dẫn xuất từ

lớp XmlNode, nó hỗ trợ mọi chức năng : duyệt cây (tree traversal ),

chèn them, gỡ bỏ và thay thế.Lớp này chứa vài hàm thực thi hữu ích.

Nạp một tài liệu DOM là một cây nằm trong ký ức (cache tree ) biểu diễn một

tài liệu XML. Các hàm thực thi Load và Loadxml thuộc lớp này sẽ cho nạp dữ liệu

và tài liệu XML,còn hàm thực thi Save thì lại cho cất trữ dữ liệu. Hàm thực thi

load có thể nạp một tài liệu từ một string,stream, TextReader, hoặc Xmlreader.

Đoạn mx sau đay cho nạp tài liệu books.xml từ một string:

XmlDocument xmlDoc = new XmlDocument();

String filename =@”C:\books.xml”;

xmlDoc.Load(filename);

xmlDoc.Save(console.put);

Thí dụ sau đây dùng Load để nạp dữ liệu từ một XmlReader:


XmlTextReader reader = new XmlTextReader(@”C:\books.xml”);

xmlDoc.Load(reader);

xmlDoc.Save(console.out);

Hàm thực thi LoadXml sau đây nạp một tài liệu từ một chuỗi được khai báo

thí dụ:

xmlDocument xmlDoc new xmlDocument();

14

mailto:%3D@%5C

xmlDoc.LoadXml(“<Record>thong tin dat o day</Record>”);

6. Lưu trữ một tàu liệu

Hàm thực thi Save cho cất trữ dữ liệu về một vị trí được khai báo.Hàm này

tiếp nhận một thông số cua XmlWriter, hoặc một kiểu dữ liệu string:

String filename =@”c:\books.xml”;

Xmldocument xmlDoc = new XmlDocument();


XmlTextWriter = new XmlTextWriter(@”c:\domtest.xml”, null);

Writer.Formating.Indented;

xmlDoc.Save(writer);

Bạn cũng có thể sử dụng filename hoặc Console.out để cất trữ kết xuất như

là một tập tin hoặc lên console:

Xmldoc.save(@”c:\domtest.xml”,null);

Hoặc

xmlDoc.Save(Console.Out);

7. Lớp xmlDocumentFragment

Thông thường, bạn sẽ phải dùng lớp này khi bạn muốn chèn một đoạn nhỏ tài

liệu XML hoặc nút lên một tài liệu. Lớp này cũng được dẫn xuất từ lớp XmlNode

nên nó có cùng khả năng duyệt qua cấu trúc cây, chèn thêm, gỡ bỏ và thay thế.

Thông thường bạn sử dụng thể hiện lớp này bằng cách triệu gọi hàm

CreateDocumentFragment của XmlDocument. Thuộc tính InnerXml tượng trưng

cho những con cái của nút này. Thí dụ sau cho thấy một thí dụ làm thế nào tạo

XmlDocument Fragment và một đoạn dữ liệu nhorXML bằng cách cho đặt đẻ

thuộc tính InnerXml.

Thí dụ: thí dụ về XmlDocumentFragment.

15

mailto:%3D@%5C

// mở một tập tin XML

String filename =@ “c:\books.xml”;

XmlDocument xmlDoc = new XmlDocumnet();

Xmldoc.Load(filename);

//Tạo một đoạn tài liệu

XmldocumentFragment docFrag = xmlDoc.createDocumentFragment();

//Cho đặt để nội dung của fragment

docFrag.InnerXml = “<Record> viết cái gì ở đây</Record>;

//Cho hiển thị lên console

Console.WriteLine(docfrag.InnerXml);

Bạn có thể sử dụng các hàm thực thi XmlNode để thêm, gỡ bỏ và thay thế dữ liệu.

Thí dụ: cho ghi nối đuôi một nút trên đoan tài liệu.

//Mở một tệp tin XML

XmlDocument xmlDoc = new XmlDocumnet();

xmlDoc.LoadXml(“book genre =’programing’>+”<title>ADO.NET

Programing</title>”+”</book>;

//Đi lấy root node và tạo một nút mới

xmlNode root = xmlDoc.DocumentElement;

XmlElement newbook = xmlDoc.CreateElemnet(“price”);

Newbook.InnerText = “44.95”;

//Cho them nut vào document

16

Root.AppendChild(newbook);

//Cho cất trữ tài liệu

xmlDoc.Save(Console.out);

8. Lớp XmlElement

Một đố tượng lớp Element tượng trưng cho một phần tử trong một tài

liệu.Lớp này được dẫn xuất từ lớp XmlLinkenode, và lớp sau này lại được dẫn

xuất từ lớp XmlNode. Lớp XmlLinkeNode có hai thuộc tính hữu ích NextSibling

và PreviousSibling.Như theo tên gọi các thuộc tính này trả về nút anh chi em kế

tiếp và đi trước của một nút taì liệu XML hiện hành.

Lớp XmlElement thi công và phủ quyết một vài hàm thực thi hữu ích giúp them và

gỡ bỏ thuộc tính và phần tử,Xem bảng sau:

Một vài hàm thực thi quan trọng của lớp XmlElemnet

Các hàm thực thi Mô tả

GetAttribute Trả về trị của thuộc tính

HasAttribute Kiểm tra xem một nút có thuộc tính được khai báo hay

không

RemoveAll Cho gỡ bỏ tất cả các nút con cái và thuộc tính của nút

hiện hành

RemoveAllAttributes Cho gỡ bỏ tất cả các thuộc tính (RemoveAllAttributes) và

thuộc tính (RemoveAttribute) được khai báo khỏi một

phần tử.

RemoveAttributeAt Cho gỡ bỏ nút thuộc tính theo index được khai báo khỏi

collection các thuộc tính.

RemoveAttributeNode Cho gỡ bỏ một XmlAttribute

17

SetAttribute Cho đặt để trị của thuộc tính được khai báo.

SetAttributeNode Thêm một XmlAttribute mới

Thêm nút vào một phần tử

Bạn có thể dùng hàm thực thi AppenChild để them một nút lên một tài liệu hiện

hành.Hàm này nhận mtj thông số duy nhất kiểu dữ liệu XmlNode. Các hàm thực

thi Createxxx của lớp XmlDocument có thể tạo ra những kiểu nút khác nhau. Thí

dụ, các hàm thực thi CreateComment và CreateElement sẽ tạo nhữn nút vào một

tài liệu.

Thí dụ:Thêm nút vào tài liệu XML

Static void Main(string[] args)

{


xmlDoc.LoadXml(“<Record> Some Value </Record>”);

//Thêm một comment mới vào tài liệu

XmlNode nodel = xmlDoc.CreateComment(“DOM Testing Sample”);

xmlDoc.AppendChild(nodel);

//Thêm first Name vào tài liệu

Nodel = xmlDoc.CreateElement(“FirstName”);

Nodel.InnerText = “Benjamin”;

xmlDoc.DocumentElement.AppendChild(nodel);


}

18

Đi lấy nút gốc (root node)

Hàm thực thi DocumentElement của lớp XmlDocument trả về root node của một

tài liệu. Thí dụ sau đay cho thấy làm thế nào để lấy root node của một tài liệu.

Thí dụ: Lấy root node của một tài liệu

String filename = @”C:\books.xml”;

XmlDocumnet xmlDoc = new XmlDocument;


XmlElement root = xmlDoc.DocumnetElement;

Gỡ bỏ và thay thế các nút

Hàm thực thi RemoveAll của lớp XmlNode có thể gỡ bỏ tất cả các phần tử và

thuộc thính của một nút. Hàm RemoveChild chỉ gỡ nút con cái được chỉ định.

Thí dụ: Cho gỡ bỏ các item của một nút

Static void Main(string () args)

{

//Nạp một document fragment

XmlDocument xmlDoc =new XmlDocument();

xmlDoc.LoadXml(“<book gebre = ‘programming’>+”<title>ADO>NET

Programming</title></book>”);

XmlNode root = xmlDoc.DocumentElement;

Console.WriteLine(“XML Document Fragment”);

Console.WriteLine(“---------------------------------”);


Console.WriteLine();

19

Console.WriteLine(“---------------“);

Console.WriteLine(“XML Document Fragment After RemoveAll”);

Console.WriteLine(“-------------------------------“);

Root.RemoveAll();

//Cho hiển thị nội dung lên cosole

xmlDoc.Save(Cosole.Out);

}

Ví dụ sau đây cho thấy làm thế nào gỡ bỏ tất cả các item của books.xml

Thí dụ 7-20 :Triệu gọi hàm RemoveAll đối với books.xml

Static void Main(string[]args)


String filename = @”c:\books.xml”;

xmlDocument xmlDoc = new XmlDocument();


XmlNode root = xmlDoc.DocumentElement;

Console.WriteLine(“XML Documnent Fragment”);

Console.WtiteLine(“-------------------------------------“);

XmlDoc.Save(Console.Out);

Console.WriteLine();

Console.WriteLine(“------------------------“);

Console.WriteLine(“XML Document After RemoveAll”);

Console.WriteLine(“------------------------------------------“);

20

Root.RemoveAll();

//Cho hiện nội dung lên Console


Hàm thực thi ReplaceChild thay thế một nút con bởi một cái mới.Trên

Thí dụ ReplaceChild thay thế rootNode:LastChild bởi xmlDOcFrag

Thí dụ: Thí dụ về Replace

Static voi Main(string[] arge)

{


String filename = @”C:\books.xml”;

XmDocument xmDoc = new XmlDocument();

xmlDocLoad(filename);

xmlNode root = xmlDoc.DocumentElemnet;

XmlDocumentFragment xmlDocFragment =

new CreateDocumnetFragment();

xmlDocFragment.InnerXml =

“<Fragment><SomeData> Fragment Data </SomeData></Fragment>”;

XmlElement rootNode = XmlDoc.DocumentElement;

//Thay thế xmlDocFragment bởi rootNode.LastChild

rootNode.ReplaceChild(xmlDocFragment, rootNode.LastChild);


21

Chèn các mảnh vào tài liệu XML

Lớp XmlNode rất hữu ích trong việc duyệt qua các nút của một tài liệu.

Lớp này còn cung cấp những hàm thực thi khác để chèn những

mảnh(Fragment)XML vào một tài liệu. Thí dụ, hàm thực thi InserAfter sẽ chèn

một tài liệu hoặc một phần tử sau nút hiện hành. Hàm này nhận hai thông số: đối

tượng XmlDocumnet Fragment và vị trí mà ta muốn cho mảnh XML chen chân

vào.Bạn tạo một đối tượng XmlDocumentFragmnet bằng cách sử dụng hàm

CreateDocument Fragment của lớp Xml.Document. Thí dụ sau sẽ cho chèn một

mảnh XML vào một tài liệu.

Thí dụ:Chèn một mảnh XML vào một tài liệu

Static void Main(string[] args)

{

//Nap một document fragment

XmlDocumnet xmlDoc new XmlDocument();

xmlDoc.Load(”(@”C:\books.xml”);

XmlDocumentFragment xmlDocFragment =

new CreateDocumentFragment();

XmlDocFragment.InnerXml = “<Fragment><SomeData>Một đoank dữ liệu

</Somedata></Fragment>”;

xmlNode aNode = xmlDoc.DocumentElement.FirstChild;

//Cho chèn aNode vào xmlDocFragment

aNode.InserAfter(xmlDocFragment, aNode.LastChild);


}

22

Thêm các thuộc tính vào một nút

Bạn sử dụng hàm thực thi SetAttributeNode cửa lớp XmlElment để thêm

những thuộc tính vào một phần tử giữ vai trò một nút.XmlAttribute tượng trưng

cho một thuộc tính XML.Ban tạo một thể hiện của XmlAttribute băng cách triệu

gọi hàm CreateAttribute của lớp XmlDocument. Sau đó ,bạn triệu gọi hàm

SetAttributeNode của lớp XmlElement để dặt thuộc tính của một phần tử. Cuối

cùng bạn cho ghi nối đuôi item mới này vào tài liệu.Xem list 7-23

List 7-23:Thêm một mắt nút có mang thuộc tính

Static void Main(string [] args)

{

XmlDocument xmlDoc = new xmlDocument();

xmlDoc.Load(@”C:\books.xml”);

//Tạo một phaanf tử mới với thuộc tính mới

XmlElement newElem = new CreateElement(NewElement”);

XmlAttribute newAttr = new CreateAttribute(NewAttribute”);

newElem.SetAttributeNode(newAttr);

//Thêm phần tử mới vào tài liệu

XmlElement root = xmlDoc.DocumentElement;

Root.AppendChild(newElem);


}

9. Biến đổi và XSLT

Extensible Stylesheet Language (XML) là một ngôn ngữ dùng biểu diễn

những stysheet.Stylesheet định dạng (formatting) các tài lieu XML theo một cách

23

nào đó mà dữ liệu XML có thể được trình bầy theo một cấu trúc nào đó trên một

browser hoặc trên một vật thẻ ký tin(media) chẳng hạn catalog,sách.v.v..

Bộ processor của một stulesheet sẽ đọc một tài liệu XML (được gọi là XMl

source tree) và stylesheet, và nó trình bày dữ liệu tài liệu dưới dạng một XML tree

format. Việc sử lý này được gọi la XML Tranformation(XSLT).

Cây kết xuất được kết sinh sau XML Transnormation thuộc tính. Cây này

còn được gọi là một element-attribute hoặc tree. Trên cây này một đối tượng là

một XML element,còn các thuộc tính là những cặp attribute-value.

XSL stylesheet giữ một vai trò quan trong trong tiến trình XSLT. Một

stylesheet chứa một tập hợp những quy tắc xây dựng cây, gồm hai phần . phần đầu

là pattem các phần tử trên cây nguồn . còn phần hai là một template dùng cho kết

xuất.XSL paser sẽ đọc pattem và phần tử soure tree rồi cho kết sinh kết quả dựa

theo template của cây kết xuất.

XSLT trên .NET

Trên .NET Framework lớp XslTransform thi công phần đặc tả XSLT.Lớp

này được định nghĩa trong một namepace riêng biệt mang tên

System.Xml.Xsl.Bạn phải đảm bảo quy chiếu về namespace này trước khi dùng

lớp XslTransform.Bạn có thể dùng lớp XsltException để thụ lý những biệt lệ tung

ra bởi một XSLT transformation.

Hàm thực thi Tranform

Hàm thực thi Tranform của lớp XslTranform sẽ chuyển đổi dữ liệu sử dụng

stylesheet được nạp và cho kết xuất kết quả tùy thuộc vào đối mục . Hàm thực thi

này có đến 8 hàm contructor .Bạn có thể viết ra phần kết xuất của Transform dưới

dạng XmlWriter, stream, TextWrite hoặc XPathNavigator.

Chuyển đổi một tài liệu

Bạn theo các bước sau đây để thực hiện chuyển đổi:

1.Trước tiên ,bạn cần taojmootj đối tượng XslTransform:

XslTransform xslt = new XslTransform();

24

2.bây giờ ,bạn cho nạp stylesheet(.xsl)sử dụng hàm thực thi Load:

Xsl.Load(“stylesheetFrmt.xsl”);

3.Cuối cùng bạn triệu gọi hàm Transform của lớp XslTransform:

Xslt.Transform(“xmlfile.xml”,”file.html”);

Thí dụ về XSM transformation

Trước khi bạn sử dụng Xsltranssform trong ứng dụng của mình bạn cần them quy

chiếu các namespace vào trong ứng dụng. Đây là những namepace.System.

System.Xml.Xpath và System.Xml.Xsl .Thí dụ sau đây dung đến tập tin

schema.book.xsl. Xem Thí dụ 7-24.

Thí dụ :Thí dụ đoạn mã XSL Transformation

//Tạo một đối tượng XslTransform mới và nạp styleaheet

XslTransform xslt = new XslTransform ();

Xslt.Load(@”C:\books.xsl”);

//Tạo một đối tượng XPathDocument mới và nạp dữ liệu XML cần được chuyển

đổi

XPathDocument mydata = new XPathDocument(@”C:\books.xml”);

// Tạo một đối tượng XmlTextWriter cho kết xuất lên console

XmlWrite write = new XmlTextWriter (Console.Out);

//Chuyển đổi dữ liệu và cho kết xuất lên Console

Xslt.Transform(mydata, null, writer);

10. ADO.NET và XML

Tới đây bạn đã biết làm thế nào với các tài liệu XML. Trong mục này

chúng tôi sẽ chhir đẫn bạn sử dụng ADO.NET thế nào để lam fvieecj với XML.

Có hai cách tiếp cận để làm việc với XML và ADO.NET. Cách thứ nhất bạn có

thể dung ADO.NET để truy cập các tài liệu XML.Cách thứ hai bạn có thể dung

25

XML và ADO.NET để truy cập XML. Ngoài ra bạn có thể truy cập cơ sở dữ liệu

quan hệ sử dụng ADO.NET và XML.NET

Đọc XML sử dụng DataSet

Trên ADO.NET bạn có thể truy cập dữ liệu sử dụng lớp DataSet. Lớp

DataSet thực thi những hàm thực thi và thuộc tính để làm việc với các tài liệu

XML.Bạn xem Chương 2 “Tổng quan về ADO.NET” và chương 4 “Các lớp

ADO.NET tách rời “ để nhớ laijnhuwngx gì lien quan đến đối tượng DataSet và

làm việc vứi lưps này thế nào. Phần kế tiếp sẽ đề cập đến các hàm thực thi giúp

đọc dữ liệu XML.

Hàm thực thi ReadXml

Hàm ReadXml là một hàm được nạp chồng bạn có thể dung hàm này để

đọc một dòng dữ l;iệu (data stream) ,TextReader, XMLreader hoặc một tập tin

XML và cho cất trữ lên một đối tượng DataSet mà bạn có thể dung về sau cho

hiển thị dữ liệu theo dang thức hang hay cột(tabular format). Hàm thực thi

readXml có 8 constructor nạp chồng .Nó có thể đọc một text, string, TextReader,

XmlReader và phối hợp các dạng thức trên.

Trong ví dụ sau đây bạn tạo một đối tượng DataSet rồi triệu gọi hàm

DataSet.ReadXml để nạp tập tin books.xml vào đối tương DataSet:

//Tạo một đối tượng DataSet và điền đầy dữ liệu

DataSer dst = new DataSet();

Dst.Read.Xml(“books.xml”);

Khi bạn đã có một đối tương DataSet bạn sẽ biết nó mạnh thế nào. Bạn bảo đảm

lối tìm về đúng đắn của books.xml. Bạn cũng cần quy chiếu về System.Data và

System.Data.Common trước khi sử dụng DataSet và các cơ sở dữ liệu phổ biến

khác.

Hàm thực thi ReadXmlShema

Hàm thực thi ReasXmlShema cho phép đọc một XMLshema vào ghi lên

một đối tượng DataSet. Hàm này có 4 constructor được nạp chồng cho phép dùng

26

một TextReader, string, stream và XmlReader. Thí dụ sau đây cho thấy cách sử

dụng một tập tin như là nhập liệu trực tiếp và triệu gọi hàm ReadXmlSchema để

đọc tập tin:

DataSet dst = new DataSet();

dst.ReadXmlShema(@”C:\books.xml)’

Thí dụ sau đây đọc tập tin XmlTextReader và sử dụng XmlTextReader như là

input của ReaderXmlSchema:

//Tạo một đối tượng DataSet

DataSet dst = new DataSet (“New DataSet”);

//Dọc XML vào đối tượng XmlTextReader

XmlTextReader myXmlReader = new XmlTextReader(@”C:\books.xml”);

//Triệu gọi hàm ReadXmlShema

Dst./ReadXmlShema(myXmlreader);

myXmlreader.Close();

Viết XML sử dụng DataSet

Ngoài việc đọc dữ liệu lớp DataSet còn chứa những hàm thực thi cho phepsw bạn

viết những tập tin từ đối tượng DataSet và điền dữ liệu lên tập tin.

Hàm thực thi WriteXml

Hàm hành sụ WriteXml viết dữ liệu hiện hành (Schema và dữ liệu) cử một

đối tượng DataSet lên tập tin XML. Đây là một hàm thực thi được nạp chồng. Nó

có thể viết một taapj tin stream, TextWriter, XmlWriter. Thí dụ 7-25 sau đây là thí

dụ sử dụng hàm thực thi WriteXml. Thí dụ này tạo một DataSet điền dữ liệu vào

DataSet rồi viết dữ liệu lên tập tin.

Thí dụ: Sử dụng hàm thực thi WriteXml

Static void Main()

27

{

try

{

//Tạo một DataSet ,namespace và một bảng Student

DataSet dst = new DataSet(“DS”);

dst.Namepace = “StdNamespace”;

DataTable stdTable = new DataTable(“Student”);

Datacolumn dtcColumn1 =new DataColum(“name”);

Datacolumn dtcColumn2 =new DataColum(“Address”);

stdTable.Columns.Add(dtcColumn1);

stdTable.Columns.Add(dtcColumn2);

dst.Table.Add(stdTable);

//Thêm dữ liệu Student vào bảng dữ liệu

DataRow newRow;

newRow = stdTable. newRow();

newRow[“Name”] = “Pham Long Bien”;

newRow[“Address”] = “Hà Nam”;

stdTable. Row.Add(newRow);

newRow = stdTable. newRow();

newRow[“Name”] = “Đỗ Khắc Tính”;

newRow[“Address”]= “Phú Thọ”;

stdTable.Rơ.Add(newRow);

28

dst.AcceptChanges();

//Tạo một StreamWruter mới cho cất trữ lên tập tin stdData.xml

StreamWriter myStreamWriter = new StreamWriter(@”D\stdData.xml”);

Dst.WriteXml(myStreamWriter);

myStreameWriter.Close();

}

cath (Exception e)

{

Consle.WriteLine(“Exception :{0}”,e.ToString());

}

return;

}

Bạn có thể hình dung hàm WriteXml đã làm gì cho mình nếu xem phần kết

xuất của tập tin stdData.xml thì hàm này đã kết sinh một tập tin chuẩn XMl như

theo Thí dụ 7-26 sau đây:

Thí dụ 7-26 :Kết xuất của hàm WriteXML

<DS xmlns = “stdNamespace”>

<student>

<Name>Pham Long Bien</name>

<Address>Hà Nam</Address>

</student>

<student>

<Name>Đỗ Khắc Tính</name>

29

<Address>Hà Nam</Address>

</student>

</DS>

Hàm thực thi WriteXmlSchema

Hàm này viết ra cấu trúc của DataSet lên một XML Schema. Hàm

WriteXmlSchema có 4 hàm được nạp chồng. Bạn có thể viết dữ liệu một stream,

text, TextWriter, XmlWriter. Thí dụ 7-27 sử dụng XmlWriter đối với kết xuất.

Thí dụ: Thí dụ về WriteXmlSchema

// Tạo một DataSet, namespace và một bảng Student

DataSet dst = new DataSet(“DS”);

DataTable stdTable = new DataTable(“Student”);

DataColum dtcColum1 = new DataColum(“Name”);

DataColum dtcColum2 = new DataColum(“Address”);

stdTable.Colums.Add(dtcColum1);

stdTable.Colums.Add(dtcColum2);

dst.Table.Add(stdTable);

//Thêm dữ liệu Student vào bảng dữ liệu

DataRow newRow;

newRow= stdTable.NewRow();

newRow[“Name”] = “Pham Long Bien”;

newRow[“Address] = “Ha Nam”;

stdTable.Rows.Add(newRow);

newRow = stdTable.NewRow();

30

newRow[“Name”] = “Do Khac Tinh”;

newRow[“Address] = “Phu Tho”;

stdTable.Rows.Add(newRow);

dst.AcceptChanges();

//Tạo một XmlTextWriter mới cho Console

XmlTextWriter writer = new XmlWriter(Console.Out);

Dst.WriteXmlSchema(writer);

Writer.Close();

XmlDataDocument và XML

Như đã đề cập trước đây, lớp XmlDocument cung cấp cấu trúc cây DOM

của tài liệu XML. Lớp XmlDataDocument được đẫn xuất từ từ lớp XmlDocument

và lớp XmlDocument lại dược đẫn xuất từ lớp Xmlnode.

Ngoài việc phủ quyết các hàm thực thi của XmlNode và XmlDocument

lớp XmlDataDocument cũng thi hành hàm thực thi riêng của mình và cho phép

bạn nạp dữ liệu quan hệ sử dụng đối tượng DataSet cũng như tài liệu XML thông

qua các hàm thực thi Load và LoadXml.

XmlDataDocument mới rộng chức năng cua XmlDocument và đồng bộ hóa lớp

này với DataSet. Bạn có thể lấy dữ lieu từ hai nguồn khác nhau. Trước tiên bạn có

thể nạp dữ liệu từ nguồn quan hệ với sự trợ giúp của dataprovider và DataSet và

có sự đồng bộ hóa dữ liệu giữa hai đối tượng này.Đây có nghĩa là khi bạn nhận dữ

liệu trên đối tượng DataSet bạn sẽ thấy kết quả trên đối tượng XmlDataDocument

và ngược lại.

Một khi dữ liệu đã dược nạp bạn được phép sử dụng bất kỳ tác vụ nào có thể

được sử dụng trên các đối tượng XmlDocument . Bạn cũng có thể sử dụng

XmlReader và XmlWriter để đọc và ghi dữ liệu.

Lớp XmlDataDocument có một thuộc tính mang tên DataSet trả về đối tượng

DataSet được gắn liền với đối tượng XmlDataDocument. Thuộc tính DataSet cung

31

cấp một biểu diễn quan hệ của tài liệu Xml .khi ban đã có một đối tượng DataSet

bạn có thể làm bất cứ việc gì với đối tượng như đã biết .

Nạp dữ liệu sử dụng các hàm Load và LoadXml của lớp XmlDataDocument

Bạn co thể sử dụng hàm thực thi Load hoặc LoadXml để nạp tài liệu

XML.Hàm Load chấp nhận một thông số của chuỗi tập tin một TextReader và

XmlReader. Cũng tương tự như thế bạn co thể dùng hàm thực thi LoadXml bằng

cách chuyền cho hàm một tệp tin XML để nạp vào một tệp tin XML.

Ví dụ:

XmlDataDocument doc = new XmlDataDocument();

Doc. Load(@”C:\books.xml”);

Hoặc

XmlDataDocument doc = new XmlDataDocument ();

Doc.LoadXml(“<Record>thong tin</Record>”);

Nạp dữ liệu sử dụng DataSet

Đối tượng DataSet có những hàm thực thi cho phép đọc các tài lieu

XML.Những hàm này là ReadXmlSchema, và LoadXml. Bạn sử dụng hàm Load

hoặc LoadXml để nạp một tài liệu XML tương tự như làm trực tiếp từ

XmlDataDocument.Một lần nữa hàm Load chấp nhận thong số của một chuỗi tên

tập tin một Textreader hoặc XmlReader.Cũng tương tự như thế bạn có thể dùng

hàm thực thi LoadXml bằng cách chuyền cho hàm một tệp tin XML thong qua

một đối tượng DataSet để nạp vào một tệp tin XML thí dụ:

XmlDataDocument doc = new XmlDataDocument ();

Doc.DataSet.ReadXmlSchema(“test.xsd”);

Hoặc

XmlDataDocument doc = new XmlDataDocument();

Doc.DataSet.ReadXml(“<Record>Nội dung</Record>”);

32

Cho hiển thị dữ liệu XML theo dạng thức DataSet

Bạn có thể nhận một đối tượng DataSet từ một đối tượng

XmlDataDocument bằng cách dùng thuộc tính DataSet của nó. Bây giờ ta thử xem

làm thế nào. Thí dụ mẫu kế tiếp sẽ cho thấy làm thế nào hiển thị dễ dàng dữ liệu

của một tài liệu XML theo dạng thức một DataSet.

Muốn đọc một tai liệu XML vao một Dât Set trước tiên bạn đọc tái liệu

băng cách sử dụng hàm thực thi DataSet.ReadXml. Thuộc tính DataSet của lớp

XmlDataDocument tượng trưng cho đối tượng DataSet của XmlDataDocument.

Sauk hi đọc tai liệu Xml vào DataSet bạn có thể tạo những data view từ dataset

hoặc bạn có thể dùng thuộc tính DefaultViewManager của DataSet để gắn kết với

ô control data-bound như bạn có thể thấy trong thí dụ sau đây.

Thí dụ: Thí dụ sử dụng XmlDataDocument

Public form1()

{

InitializeComponent();

//Tạo một đối tượng XmlDataDocument và dọc một XML

XmlDataDocumnet XmlDatadoc = new XmlDataDocument ();

XmlDatadoc.DataSet.ReadXml(@”:\Books.xml”);

//Tạo một đối tượng DataSet và cho điền dữ liệu từ tập tin

DataSet dst = new DataSet(“Books DataSet”);

Dst = XmlDataSet;

//Cho gắn kết với một DataGrid

dataGridl.DataSource = dst.DefaultViewManager;

}

33

Cất trữ dữ liệu từ một DataSet lên một tài liệu XML.

Bạn có thể lưu trữ dữ liệu lên một đối tươmhj DataSet như là một tài liệu

XML bằng cách dùng hàm thực thi Savecuar XmlDataDocument. Trước tiên bạn

tạo ra một đối tượng DataSet rồi cho điền dữ liệu sử dụng đối tượng DatAdapter.

Thí dụ: Cho cất trữ dữ liệu DataSet lên một tài liệu XML

Using System;

Using System.Drawing;

Using System.collections;

Using System.ComponenModel;

Using System.Windows.Forms;

Using System.Data;

Using System.Data.OleDb;

Using System.ml;

Namespace ThiDu

{

Public class Form1: System.Windows.Form

{

Pravite System.ComponentModel.Container components = null;

Public Form1()

{

InitializeComponent();

String strSQL = “SELECT * FORM Customers”;

String strCom = Provider = Microsoft.Jet.OLEDB.4.0;

34

Data Source = C:\\Program File\\MicrosoftOfice\\Ofifce10\\1033\\

FPNWIND.mdb;

//Tạo data adapter

OleDbDataAdapter đa =new OleDbDataAdapter(strSQL,strCom);

// Tạo một dataset và điền dữ liệu từ data adapter

DataSet dst = new DataSet();

Đa.Fill(dst);

//Sử dụng XmlDataDocument với hàm Save

XmlDataDocument doc = new XmlDataDocument (dst);

Doc.Save(@”D:\XmldataDoc.xml”);

}

Static void main()

{

Application.Run(new Form1());

}

}

}

}

11. Đi lại dọc ngang trên XML

Lớp XmlNode cung cấp một cách “đi lại” các cây DOM với sự trợ giúp của

các hàm thực thi FirstChild, ChildNodes, LastChild, PreviousNode, NextSibling

và previousSibling.

35

Ngoài lớp XmlNode , XML.NET còn có thêm hai lớp giúp ban”lèo lai” các

tài liệu XML.Các lớp này là XpathDocument và XpathNavigator. Hai lớp này

được định nghĩa trong namepace System.Xml.XPath. Namespace XPath chứa

nhiều lớp cho phép truy cập nhanh và chỉ đọc các tài liệu XML.Trước khi sử dụng

các lớp này bạn phải nhớ quy chiếu về namepace System.Xml.XPath trong ứng

dụng của bạn.

XPathNodeIterator, XpathExpression và XPathException là những lớp khác

được định nghĩa trong namepace này. xPathNodeIteration cung cấp khả năng

duyệt qua các nút còn XpathExpression cung cấp tiêu chí lựa chọn dung tuyển ra

một tập hợp những nút từ tài liệu XML dựa trên các tiêu chí này và cuối cùng lớp

XpathExpresstion là một lớp thụ lý ngoại lệ.Lớp XpathDocument cung cấp một

fast cache đối với việc ssuwr lý các tài liệu XML sử dụng XSLT và XPath.

Bạn sử dụng hàm contructor của các XpathDocument để tạo một thể hiện

của lớp này. Nó có nhiều hàm contructor được nạp chồng và bạn có thể chuyển

qua một XmlRader, TextReader hoặc trực tiếp kể cả các tài liệu XML.

Lớp XPathNavigator

Lớp XPathNavigator có những hàm thực thi dễ dùng.Bạn tạo một thể hiện

lớp XPathNavigator bằng cách triệu gọi hàm CreateNavigator của lớp

XPathDocument. Bạn cũng có thể tạo đối tượng XPathNavigator bằng cách triệu

gọi hàm CreateNavigator của lớp XmlDocumnet.

Ví dụ :

//Nạp tài liệu XML books.xml

XmlDocument xmlDoc = new XmlDocument ();

xmlDoc.Load(@”C:\books.xml”);

//Tạo đối tượng XPathNavigator thong qua hàm CreateNavigator của

XmlDocument

XPathNavigator nav = xmlDoc.CreateNavigator();

36

Lớp XPathNavigator chứa nững hàm thực thi và thuộc tính cho phép di

chuyển các nút gốc ban đầu , kế tiếp , con cái, cha me trên tài liệu.

Các hàm thực thi Move của lớp XPathNavigator

Bảng: Các hàm thực thi của lớp XPathnavigator

Các hàm thực thi Mô tả

MoveToAttribute Di chuyển về một thuộc tính

MoveToFirst Di chuyển về nút anh chị của nút hiện hành

MoveToFirstAttribute Di chuyển về thuộc tính đầu tiên

MoveToFirstChild Di chuyển về nút con cái của nút hiện hành

MoveToNamespace Di chuyển XPathNavigator về nút namespace

đầu tiên của phần tử hiện hành

MoveToId Di chuyển về nút mang mã nhận diện ID được

khai báo

MoveToNamespace Di chuyển về namespace được khai báo

MoveToNext Di chuyển về nút kế tiếp của nút hiện hành

MoveToNextAttribute Di chuyển về thuộc tính kế tiếp

MoveToNextnamespace Di chuyển về namespace kế tiếp

MoveToParent Di chuyển về nút cha mẹ của nút hiện hành

MovetoPrevious Di chuyển về nút anh chị đi trước của nút hiện

hành

MoveToRoot Di chuyển về nút gốc

37

Như vậy với sự hỗ trợ của các hàm thực thi kể trên bạn có thể duyệt qua tài liệu

XML như một cây DOM.

Thí dụ: Di chuyển về nút gốc và nút con cái đầu tiên sử dụng XPathNavigator

Static void Main()

{



xmlDoc.Load(@”D:\books.xml”);

//Tạo đối tượng XPathNavigator

XPathNavigator nav xmlDoc.CrearteNavigator();

//Di chuyển về nút gốc và cho hiện thông tin

Nav.MoveToRoot();

String name = nav.Name;

Console.WriteLine(“Root node info”);

Console.WriteLine(“Base URI : “ + nav.BaseURI.ToString());

Console.WriteLine(“Name : “ +nav.Name.ToString());

Console.WriteLine(“NodeType: “+ nav.NodeType.ToString());

Console.WriteLine(“Node Value : “ + nav.Value.ToString());

If (nav.HasChildren)

{

Nav.MoveToFirstChild()

}

38

}

Tìm kiếm thông tin sử dụng XpathNivigator

Các hàm thực thi Select, SelectChildren, SelectAncestors và

Selecetdescendents là nững hàm hữu ích khác đặc biệt khi bạn cần tuyển chọn

những item của các tài liệu XML dựa trên một biểu thức XPath. Thí dụ bạn có thể

sử dụng một hàm khi tuyển chọn các nut chỉ dựa trên tag ‘author’ mà thôi. Bây giờ

bạn thử tìm kiếm và cho hiển thị tất cả các nút ngang <first-name> tag trong

tài liệu XML books.xml Trên Thí dụ 7-32 bạn sử dụng hàm thực thi Select của

XpathNavigator để dưa ra tiêu chuẩn chọn và cho hiện thị các nút.

Thí dụ: Sử dụng XPathNodeIterator

Static void Main()

{


XmlDocument xmlDoc = new XmlDocument ();

XmlDoc.Load (@”C:\books.xml”);

//Tạo đối tượng XPathNavigator

XPathNavigator nav = xmlDoc.CreateNavigator();

//Đi tìm First name của các Author

Console.WriteLine(“Author First name”);

XPathNodeInterator intrator nav.Select(“descendant::first-name”);

While (integrator.MoveNext())

{

Console.WriteLine(integrator.Current.Value.ToString());

}

39

Consle.ReadLine()

}

Tài liệu tham khảo

1. .NET toàn tập (Dương Quang Thiện)

2. Giáo trình XML

Các Website tham khảo

1. http://www.w3schools.com/

40

http://www.w3schools.com/

2. http://khmt3-k2.net/

41

http://khmt3-k2.net/

dom_xml for c#

Documents