我們今天的主題不是論述xml的好處，而是討論在c#中如何使用xml。下面我們來了解一下使用程序訪問xml的一些基礎理論知識。

　　訪問的兩種模型：

　　在程序中訪問進而操作xml文件一般有兩種模型，分別是使用dom（文檔對象模型）和流模型，使用dom的好處在于它允許編輯和更新xml文檔，可以隨機訪問文檔中的數據，可以使用xpath查詢，但是，dom的缺點在于它需要一次性的加載整個文檔到內存中，對于大型的文檔，這會造成資源問題。流模型很好的解決了這個問題，因為它對xml文件的訪問采用的是流的概念，也就是說，任何時候在內存中只有當前節點，但它也有它的不足，它是只讀的，僅向前的，不能在文檔中執行向后導航操作。雖然是各有千秋，但我們也可以在程序中兩者并用實現優劣互補嘛，呵呵，這是題外話了！我們今天主要討論xml的讀取，那我們就詳細討論一下流模型吧！

　　流模型中的變體：

　　流模型每次迭代xml文檔中的一個節點，適合于處理較大的文檔，所耗內存空間小。流模型中有兩種變體——“推”模型和“拉”模型。

　　推模型也就是常說的sax，sax是一種靠事件驅動的模型，也就是說：它每發現一個節點就用推模型引發一個事件，而我們必須編寫這些事件的處理程序，這樣的做法非常的不靈活，也很麻煩。

　　.net中使用的是基于“拉”模型的實現方案，“拉”模型在遍歷文檔時會把感興趣的文檔部分從讀取器中拉出，不需要引發事件，允許我們以編程的方式訪問文檔，這大大的提高了靈活性，在性能上“拉”模型可以選擇性的處理節點，而sax每發現一個節點都會通知客戶機，從而，使用“拉”模型可以提高application的整體效率。在.net中“拉”模型是作為xmlreader類實現的，下面看一下該類的繼承結構：

　　我們今天來講一下該體系結構中的xmltextreader類，該類提供對xml文件進行讀取的功能，它可以驗證文檔是否格式良好，如果不是格式良好的xml文檔，該類在讀取過程中將會拋出xmlexception異常，可使用該類提供的一些方法對文檔節點進行讀取，篩選等操作以及得到節點的名稱和值，請牢記：xmltextreader是基于流模型的實現，打個不恰當的比喻，xml文件就好象水源，閘一開水就流出，流過了就流過了不會也不可以往回流。內存中任何時候只有當前節點，你可以使用xmltextreader類的read()方法讀取下一個節點。好了，說了這么多來看一個例子，編程要注重實際對吧。看代碼前先看下運行效果吧！

　　example1按紐遍歷文檔讀取數據，example2，example3按紐得到節點類型，example4過濾文檔只獲得數據內容，example5得到屬性節點，example6按紐得到命名空間，example7顯示整個xml文檔，為此，我專門寫一個類來封裝以上功能，該類代碼如下：

//---------------------------------------------------------------------------------------------------
//xmlreader類用于xml文件的一般讀取操作，以下對這個類做簡單介紹：
//
//attributes(屬性):
//listbox: 設置該屬性主要為了得到客戶端控件以便于顯示所讀到的文件的內容(這里是listbox控件)
//xmlpath: 設置該屬性為了得到一個確定的xml文件的絕對路徑
//
//basilic using(重要的引用):
//system.xml: 該命名空間中封裝有對xml進行操作的常用類，本類中使用了其中的xmltextreader類
//xmltextreader: 該類提供對xml文件進行讀取的功能，它可以驗證文檔是否格式良好，如果不是格式 // 良好的xml文檔，該類在讀取過程中將會拋出xmlexception異常，可使用該類提供的
// 一些方法對文檔節點進行讀取，篩選等操作以及得到節點的名稱和值
//
//bool xmltextreader.read(): 讀取流中下一個節點，當讀完最后一個節點再次調用該方法該方法返回false
//xmlnodetype xmltextreader.nodetype: 該屬性返回當前節點的類型
// xmlnodetype.element 元素節點
// xmlnodetype.endelement 結尾元素節點
// xmlnodetype.xmldeclaration 文檔的第一個節點
// xmlnodetype.text 文本節點
//bool xmltextreader.hasattributes: 當前節點有沒有屬性，返回true或false
//string xmltextreader.name: 返回當前節點的名稱
//string xmltextreader.value: 返回當前節點的值
//string xmltextreader.localname: 返回當前節點的本地名稱
//string xmltextreader.namespaceuri: 返回當前節點的命名空間uri
//string xmltextreader.prefix: 返回當前節點的前綴
//bool xmltextreader.movetonextattribute(): 移動到當前節點的下一個屬性
//---------------------------------------------------------------------------------------------------

namespace xmlreading
{
　using system;
　using system.xml;
　using system.windows.forms;
　using system.componentmodel;

　/// ＜summary＞
　/// xml文件讀取器
　/// ＜/summary＞

　public class xmlreader : idisposable
　{
　　private string _xmlpath;
　　private const string _errmsg = "error occurred while reading ";
　　private listbox _listbox;
　　private xmltextreader xmltxtrd;

　　#region xmlreader 的構造器

　　public xmlreader()
　　{
　　　this._xmlpath = string.empty;
　　　this._listbox = null;
　　　this.xmltxtrd = null;
　　}

　　/// ＜summary＞
　　/// 構造器
　　/// ＜/summary＞
　　/// ＜param name="_xmlpath"＞xml文件絕對路徑＜/param＞
　　/// ＜param name="_listbox"＞列表框用于顯示xml＜/param＞

　　public xmlreader(string _xmlpath, listbox _listbox)
　　{
　　　this._xmlpath = _xmlpath;
　　　this._listbox = _listbox;
　　　this.xmltxtrd = null;
　　}

　　#endregion
　　#region xmlreader 的資源釋放方法

　　/// ＜summary＞
　　/// 清理該對象所有正在使用的資源

　　/// ＜/summary＞

　　public void dispose()
　　{
　　　this.dispose(true);
　　　gc.suppressfinalize(this);
　　}

　　/// ＜summary＞
　　/// 釋放該對象的實例變量
　　/// ＜/summary＞
　　/// ＜param name="disposing"＞＜/param＞

　　protected virtual void dispose(bool disposing)
　　{
　　　if (!disposing)
　　　　return;
　　　if (this.xmltxtrd != null)
　　　{
　　　　this.xmltxtrd.close();
　　　　this.xmltxtrd = null;
　　　}

　　　if (this._xmlpath != null)
　　　{
　　　　this._xmlpath = null;
　　　}
　　}

　　#endregion　
　　#region xmlreader 的屬性

　　/// ＜summary＞
　　/// 獲取或設置列表框用于顯示xml
　　/// ＜/summary＞

　　public listbox listbox
　　{
　　　get
　　　{
　　　　return this._listbox;
　　　}
　　　set
　　　{
　　　　this._listbox = value;
　　　}
　　}

　　/// ＜summary＞
　　/// 獲取或設置xml文件的絕對路徑
　　/// ＜/summary＞

　　public string xmlpath
　　{
　　　get
　　　{
　　　　return this._xmlpath;
　　　}
　　　set
　　　{
　　　　this._xmlpath = value;
　　　}
　　}

　　#endregion

　　/// ＜summary＞
　　/// 遍歷xml文件
　　/// ＜/summary＞

　　public void eachxml()
　　{
　　　this._listbox.items.clear();
　　　this.xmltxtrd = new xmltextreader(this._xmlpath);

　　　try
　　　{
　　　　while(xmltxtrd.read())
　　　　{
　　　　　this._listbox.items.add(this.xmltxtrd.value);
　　　　}
　　　}
　　　catch(xmlexception exp)
　　　{
　　　　throw new xmlexception(_errmsg + this._xmlpath + exp.tostring());
　　　}
　　　finally
　　　{
　　　　if (this.xmltxtrd != null)
　　　　　this.xmltxtrd.close();
　　　}
　　}

　　/// ＜summary＞
　　/// 讀取xml文件的節點類型
　　/// ＜/summary＞

　　public void readxmlbynodetype()
　　{
　　　this._listbox.items.clear();
　　　this.xmltxtrd = new xmltextreader(this._xmlpath);

　　　try
　　　{
　　　　while(xmltxtrd.read())
　　　　{
　　　　　this._listbox.items.add(this.xmltxtrd.nodetype.tostring());
　　　　}
　　　}
　　　catch(xmlexception exp)
　　　{
　　　　throw new xmlexception(_errmsg + this._xmlpath + exp.tostring());
　　　}
　　　finally
　　　{
　　　　if (this.xmltxtrd != null)
　　　　　this.xmltxtrd.close();
　　　}
　　}

　　/// ＜summary＞
　　/// 根據節點類型過濾xml文檔
　　/// ＜/summary＞
　　/// ＜param name="xmlntype"＞xmlnodetype 節點類型的數組＜/param＞

　　public void filterbynodetype(xmlnodetype[] xmlntype)
　　{
　　　this._listbox.items.clear();
　　　this.xmltxtrd = new xmltextreader(this._xmlpath);
　　　try
　　　{
　　　　while(xmltxtrd.read())
　　　　{
　　　　　for (int i = 0; i ＜ xmlntype.length; i++)
　　　　　{
　　　　　　if (xmltxtrd.nodetype == xmlntype[i])
　　　　　　{
　　　　　　　this._listbox.items.add(xmltxtrd.name + " is type " + xmltxtrd.nodetype.tostring());
　　　　　　}
　　　　　}
　　　　}
　　　}
　　　catch(xmlexception exp)
　　　{
　　　　throw new xmlexception(_errmsg + this.xmlpath + exp.tostring());
　　　}
　　　finally
　　　{
　　　　if (this.xmltxtrd != null)
　　　　　this.xmltxtrd.close();
　　　}
　　}

　　/// ＜summary＞
　　/// 讀取xml文件的所有文本節點值

　　/// ＜/summary＞

　　public void readxmltextvalue()
　　{
　　　this._listbox.items.clear();
　　　this.xmltxtrd = new xmltextreader(this._xmlpath);

　　　try
　　　{
　　　　while(xmltxtrd.read())
　　　　{
　　　　　if (xmltxtrd.nodetype == xmlnodetype.text)
　　　　　{
　　　　　　this._listbox.items.add(xmltxtrd.value);
　　　　　}
　　　　}
　　　}
　　　catch(xmlexception xmlexp)
　　　{
　　　　throw new xmlexception(_errmsg + this._xmlpath + xmlexp.tostring());
　　　}
　　　finally
　　　{
　　　　if (this.xmltxtrd != null)
　　　　　this.xmltxtrd.close();
　　　}
　　}

　　/// ＜summary＞
　　/// 讀取xml文件的屬性
　　/// ＜/summary＞

　　public void readxmlattributes()
　　{
　　　this._listbox.items.clear();
　　　this.xmltxtrd = new xmltextreader(this._xmlpath);

　　　try
　　　{
　　　　while(xmltxtrd.read())
　　　　{
　　　　　if (xmltxtrd.nodetype == xmlnodetype.element)
　　　　　{
　　　　　　if (xmltxtrd.hasattributes)
　　　　　　{
　　　　　　　this._listbox.items.add("the element " + xmltxtrd.name + " has " + xmltxtrd.attributecount + " attributes");

　　　　　　　this._listbox.items.add("the attributes are:");

　　　　　　　while(xmltxtrd.movetonextattribute())
　　　　　　　{
　　　　　　　　this._listbox.items.add(xmltxtrd.name + " = " + xmltxtrd.value);
　　　　　　　}
　　　　　　}
　　　　　　else
　　　　　　{
　　　　　　　this._listbox.items.add("the element " + xmltxtrd.name + " has no attribute");
　　　　　　}
　　　　　　this._listbox.items.add("");
　　　　　}
　　　　}
　　　}
　　　catch(xmlexception xmlexp)
　　　{
　　　　throw new xmlexception(_errmsg + this._xmlpath + xmlexp.tostring());
　　　}
　　　finally
　　　{
　　　　if (this.xmltxtrd != null)
　　　　　this.xmltxtrd.close();
　　　}
　　}

　　/// ＜summary＞
　　/// 讀取xml文件的命名空間
　　/// ＜/summary＞

　　public void readxmlnamespace()
　　{
　　　this._listbox.items.clear();
　　　this.xmltxtrd = new xmltextreader(this._xmlpath);
　　　try
　　　{
　　　　while(xmltxtrd.read())
　　　　{
　　　　　if (xmltxtrd.nodetype == xmlnodetype.element && xmltxtrd.prefix != "")
　　　　　{
　　　　　　this._listbox.items.add("the prefix " + xmltxtrd.prefix + " is associated with namespace " + xmltxtrd.namespaceuri);

　　　　　　this._listbox.items.add("the element with the local name " + xmltxtrd.localname + " is associated with" + " the namespace " + xmltxtrd.namespaceuri);
　　　　　}

　　　　　if (xmltxtrd.nodetype == xmlnodetype.element && xmltxtrd.hasattributes)
　　　　　{
　　　　　　while(xmltxtrd.movetonextattribute())
　　　　　　{
　　　　　　　if (xmltxtrd.prefix != "")
　　　　　　　{
　　　　　　　　this._listbox.items.add("the prefix " + xmltxtrd.prefix + " is associated with namespace " + xmltxtrd.namespaceuri);

　　　　　　　　this._listbox.items.add("the attribute with the local name " + xmltxtrd.localname + " is associated with the namespace " + xmltxtrd.namespaceuri);

　　　　　　　}
　　　　　　}
　　　　　}
　　　　}
　　　}
　　　catch(xmlexception xmlexp)
　　　{
　　　　throw new xmlexception(_errmsg + this._xmlpath + xmlexp.tostring());
　　　}
　　　finally
　　　{
　　　　if (this.xmltxtrd != null)
　　　　　this.xmltxtrd.close();
　　　}
　　}

　　/// ＜summary＞
　　/// 讀取整個xml文件
　　/// ＜/summary＞

　　public void readxml()
　　{
　　　string attandele = string.empty;
　　　this._listbox.items.clear();
　　　this.xmltxtrd = new xmltextreader(this._xmlpath);

　　　try
　　　{
　　　　while(xmltxtrd.read())
　　　　{
　　　　　if (xmltxtrd.nodetype == xmlnodetype.xmldeclaration)
　　　　　　this._listbox.items.add(string.format("＜?{0} {1} ?＞",xmltxtrd.name,xmltxtrd.value));
　　　　　else if (xmltxtrd.nodetype == xmlnodetype.element)
　　　　　{
　　　　　　attandele = string.format("＜{0} ",xmltxtrd.name);
　　　　　　if (xmltxtrd.hasattributes)
　　　　　　{
　　　　　　　while(xmltxtrd.movetonextattribute())
　　　　　　　{
　　　　　　　　attandele = attandele + string.format("{0}='{1}' ",xmltxtrd.name,xmltxtrd.value);
　　　　　　　}
　　　　　　}

　　　　　　attandele = attandele.trim() + "＞";
　　　　　　this._listbox.items.add(attandele);
　　　　　}
　　　　　else if (xmltxtrd.nodetype == xmlnodetype.endelement)
　　　　　　this._listbox.items.add(string.format("＜/{0}＞",xmltxtrd.name));
　　　　　else if (xmltxtrd.nodetype == xmlnodetype.text)
　　　　　　this._listbox.items.add(xmltxtrd.value);
　　　　}
　　　}
　　　catch(xmlexception xmlexp)
　　　{
　　　　throw new xmlexception(_errmsg + this._xmlpath + xmlexp.tostring());
　　　}
　　　finally
　　　{
　　　　if (this.xmltxtrd != null)
　　　　　this.xmltxtrd.close();
　　　}
　　}
　}
}