C#操作XML

在写一个串口通信的时候用到的C#操作xml类

功能：对xml节点增、删、修改功能.

本来是用linq写的,后来发现3.5框架太大,又改成C#2.0的.现都附上代码,方便以后查询

 

C# 2.0

1. using System;
2. using System.Collections.Generic;
3. 
   
4. using System.Text;
5. 
   
6. using System.Xml;
7. using System.IO;
8. 
   
9. namespace SerialPortComm
10. {
11.     public class PortConfig
12.     {
13. 
    
14.         public PortConfig()
15.         {
16. 
    
17.         }
18.         /// <summary>
19.         /// 端口号
20.         /// </summary>
21.         public string PortName = "COM1";
22.         /// <summary>
23.         /// 波特率
24.         /// </summary>
25.         public string BaudRate = "9600";
26.         /// <summary>
27.         /// 数据位
28.         /// </summary>
29.         public string DataBits = "8";
30.         /// <summary>
31.         /// 校验位
32.         /// </summary>
33.         public string Paritys = "None";
34.         /// <summary>
35.         /// 停止位
36.         /// </summary>
37.         public string StopBits = "1";
38.         /// <summary>
39.         /// 握手协议
40.         /// </summary>
41.         public string HandShaking = "None";
42. 
    
43.     }
44. 
    
45.     public class SerialPortSetting
46.     {
47.         /// <summary>
48.         /// 文件路径
49.         /// </summary>
50.         public string FilePath = "config.xml";
51. 
    
52.         /// <summary>
53.         /// 构造函数
54.         /// </summary>
55.         /// <param name="FileName"></param>
56.         public SerialPortSetting(string FileName)
57.         {
58.             FilePath = FileName;
59.             fileIsExist(FileName);
60.         }
61. 
    
62.         /// <summary>
63.         /// 增加端口配置
64.         /// </summary>
65.         /// <param name="portName"></param>
66.         public void AddSerialPort(PortConfig pConfig)
67.         {
68.             if (!Exist(pConfig.PortName))
69.             {
70. 
    
71.                 XmlDocument xDom = new XmlDocument();
72.                 xDom.Load(FilePath);
73.                 XmlNode root = xDom.SelectSingleNode("SerialPorts");
74.                 XmlElement xPortName = xDom.CreateElement("PortName");
75.                 xPortName.SetAttribute("Id", pConfig.PortName);
76. 
    
77.                 XmlElement xSubNode1 = xDom.CreateElement("BaudRate");
78.                 xSubNode1.InnerText = pConfig.BaudRate;
79.                 xPortName.AppendChild(xSubNode1);
80. 
    
81.                 XmlElement xSubNode2 = xDom.CreateElement("DataBits");
82.                 xSubNode2.InnerText = pConfig.DataBits;
83.                 xPortName.AppendChild(xSubNode2);
84. 
    
85.                 XmlElement xSubNode3 = xDom.CreateElement("Paritys");
86.                 xSubNode3.InnerText = pConfig.Paritys;
87.                 xPortName.AppendChild(xSubNode3);
88. 
    
89.                 XmlElement xSubNode4 = xDom.CreateElement("StopBits");
90.                 xSubNode4.InnerText = pConfig.StopBits;
91.                 xPortName.AppendChild(xSubNode4);
92. 
    
93.                 XmlElement xSubNode5 = xDom.CreateElement("HandShaking");
94.                 xSubNode5.InnerText = pConfig.HandShaking;
95.                 xPortName.AppendChild(xSubNode5);
96. 
    
97.                 root.AppendChild(xPortName);//增加端口配置
98.                 xDom.Save(FilePath);
99.             }
100. 
     
101.         }
102. 
     
103.         /// <summary>
104.         /// 删除端口配置
105.         /// </summary>
106.         /// <param name="portName">端口名称</param>
107.         public void DelSerialPort(string portName)
108.         {
109. 
     
110.             XmlDocument xDom = new XmlDocument();
111.             xDom.Load(FilePath);
112. 
     
113.             XmlNodeList xmlNodeList = xDom.SelectSingleNode("SerialPorts").ChildNodes;
114.             foreach (XmlNode xn in xmlNodeList)
115.             {
116.                 XmlElement xe = (XmlElement)xn;
117.                 if (xe.GetAttribute("Id") == portName)
118.                 {
119.                     xe.RemoveAll();//删除改节点及子节点
120.                 }
121.             }
122.             xDom.Save(FilePath);
123. 
     
124.         }
125. 
     
126.         /// <summary>
127.         /// 返回端口配置
128.         /// </summary>
129.         /// <param name="portName">端口名称</param>
130.         /// <returns></returns>
131.         public PortConfig GetSerialPortName(string portName)
132.         {
133. 
     
134.             PortConfig portConfig = new PortConfig();
135. 
     
136.             XmlDocument xDom = new XmlDocument();
137.             xDom.Load(FilePath);
138.             bool has = false;
139.             XmlNodeList xmlNodeList = xDom.SelectSingleNode("SerialPorts").ChildNodes;
140.             foreach (XmlNode xn in xmlNodeList)
141.             {
142.                 XmlElement xe = (XmlElement)xn;
143.                 if (xe.GetAttribute("Id") == portName)
144.                 {
145.                     foreach (XmlNode xchildeNode in xe.ChildNodes)
146.                     {
147.                         XmlElement xchild = (XmlElement)xchildeNode;
148.                         switch (xchild.Name)
149.                         {
150.                             case "BaudRate":
151.                                 portConfig.BaudRate = xchild.InnerText ;
152.                                 break;
153.                             case "DataBits":
154.                                 portConfig.DataBits = xchild.InnerText;
155.                                 break;
156.                             case "Paritys":
157.                                 portConfig.Paritys = xchild.InnerText;
158.                                 break;
159.                             case "StopBits":
160.                                 portConfig.StopBits = xchild.InnerText;
161.                                 break;
162.                             case "HandShaking":
163.                                 portConfig.HandShaking = xchild.InnerText;
164.                                 break;
165.                         }
166.                     }
167.                     has = true;
168.                     break;
169.                 }
170.             }
171.             xDom.Save(FilePath);
172. 
     
173.             if (has == true)
174.             {
175.                 return portConfig;
176.             }
177.             else
178.             {
179.                 return null;
180.             }
181. 
     
182. 
     
183.         }
184. 
     
185.         /// <summary>
186.         /// 增加端口配置
187.         /// </summary>
188.         /// <param name="portName"></param>
189.         public void EditSerialPort(PortConfig portConfig)
190.         {
191.             XmlDocument xDom = new XmlDocument();
192.             xDom.Load(FilePath);
193. 
     
194.             XmlNodeList xmlNodeList = xDom.SelectSingleNode("SerialPorts").ChildNodes;
195.             foreach (XmlNode xn in xmlNodeList)
196.             {
197.                 XmlElement xe = (XmlElement)xn;
198.                 if (xe.GetAttribute("Id") == portConfig.PortName)
199.                 {
200.                     foreach (XmlNode xchildeNode in xe.ChildNodes)
201.                     {
202.                         XmlElement xchild = (XmlElement)xchildeNode;
203.                         switch (xchild.Name)
204.                         {
205.                             case "BaudRate":
206.                                 xchild.InnerText = portConfig.BaudRate;
207.                                 break;
208.                             case "DataBits":
209.                                 xchild.InnerText = portConfig.DataBits;
210.                                 break;
211.                             case "Paritys":
212.                                 xchild.InnerText = portConfig.Paritys;
213.                                 break;
214.                             case "StopBits":
215.                                 xchild.InnerText = portConfig.StopBits;
216.                                 break;
217.                             case "HandShaking":
218.                                 xchild.InnerText = portConfig.HandShaking;
219.                                 break;
220.                         }
221.                     }
222.                     break;
223.                 }
224.             }
225.             xDom.Save(FilePath);
226. 
     
227.         }
228. 
     
229.         /// <summary>
230.         /// 判断端口配置是否存在
231.         /// </summary>
232.         /// <param name="portName"></param>
233.         /// <returns></returns>
234.         public bool Exist(string portName)
235.         {
236. 
     
237.             XmlDocument xDom = new XmlDocument();
238.             xDom.Load(FilePath);
239.             XmlNodeList xNodeList = xDom.SelectSingleNode("SerialPorts").ChildNodes;
240.             bool find = false;
241.             foreach (XmlNode xmlNode in xNodeList)
242.             {
243. 
     
244.                 XmlElement xe = (XmlElement)xmlNode;
245.                 if (xe.GetAttribute("Id") == portName.Trim())
246.                 {
247.                     find = true;
248.                     break;
249. 
     
250.                 }
251.             }
252.             return find;
253.         }
254. 
     
255.         /// <summary>
256.         /// 判断文件是否存在
257.         /// </summary>
258.         /// <param name="FilePath"></param>
259.         public void fileIsExist(string FilePath)
260.         {
261.             if (!File.Exists(FilePath))
262.             {
263. 
     
264.                 XmlDocument xDom = new XmlDocument();
265. 
     
266.                 XmlElement xmlRoot = xDom.CreateElement("SerialPorts");
267.                 xDom.AppendChild(xmlRoot);
268.                 xDom.Save(FilePath);
269.             }
270.         }
271.     }
272. }

C# 3.5 Linq操作XML

1. using System;
2. using System.Collections.Generic;
3. using System.Linq;
4. using System.Text;
5. using System.Xml.Linq;
6. using System.Xml;
7. using System.IO;
8. 
   
9. namespace SerialPortComm
10. {
11.     public class PortConfig
12.     {
13. 
    
14.         public PortConfig()
15.         {
16. 
    
17.         }
18.         /// <summary>
19.         /// 端口号
20.         /// </summary>
21.         public string PortName = "COM1";
22.         /// <summary>
23.         /// 波特率
24.         /// </summary>
25.         public string BaudRate = "9600";
26.         /// <summary>
27.         /// 数据位
28.         /// </summary>
29.         public string DataBits = "8";
30.         /// <summary>
31.         /// 校验位
32.         /// </summary>
33.         public string Paritys = "None";
34.         /// <summary>
35.         /// 停止位
36.         /// </summary>
37.         public string StopBits = "1";
38.         /// <summary>
39.         /// 握手协议
40.         /// </summary>
41.         public string HandShaking = "None";
42. 
    
43.     }
44.     public class SerialPortSetting
45.     {
46.         /// <summary>
47.         /// 文件路径
48.         /// </summary>
49.         public string FilePath = "";
50. 
    
51.         /// <summary>
52.         /// 构造函数
53.         /// </summary>
54.         /// <param name="FileName"></param>
55.         public SerialPortSetting(string FileName)
56.         {
57.             FilePath = FileName;
58.             fileIsExist(FileName);
59.         }
60. 
    
61.         /// <summary>
62.         /// 增加端口配置
63.         /// </summary>
64.         /// <param name="portName"></param>
65.         public void AddSerialPort(PortConfig pConfig)
66.         {
67.             if (!Exist(pConfig.PortName))
68.             {
69.                 XDocument xDom = XDocument.Load(FilePath);
70.                 xDom.Root.Add(new XElement("PortName", new XAttribute("Id", pConfig.PortName),
71.                     new XElement("BaudRate", pConfig.BaudRate),
72.                     new XElement("DataBits", pConfig.DataBits),
73.                     new XElement("Paritys", pConfig.Paritys),
74.                     new XElement("StopBits", pConfig.StopBits),
75.                     new XElement("HandShaking", pConfig.HandShaking)));
76.                 xDom.Save(FilePath);
77.             }
78. 
    
79.         }
80. 
    
81.         /// <summary>
82.         /// 删除端口配置
83.         /// </summary>
84.         /// <param name="portName">端口名称</param>
85.         public void DelSerialPort(string portName)
86.         {
87.             XDocument xDom = XDocument.Load(FilePath);
88.             var ports = from p in xDom.Root.Elements("PortName") where p.Attribute("Id").Value == portName select p;
89.             ports.Remove();
90.             xDom.Save(FilePath);
91.         }
92. 
    
93.         /// <summary>
94.         /// 返回端口配置
95.         /// </summary>
96.         /// <param name="portName">端口名称</param>
97.         /// <returns></returns>
98.         public PortConfig GetSerialPortName(string portName)
99.         {
100.             XDocument xDom = XDocument.Load(FilePath);
101.             PortConfig portConfig = new PortConfig();
102. 
     
103.             var ports = from p in xDom.Root.Elements("PortName") where p.Attribute("Id").Value == portName select p;
104.             if (ports.Count() > 0)
105.             {
106.                 XElement xElement = ports.First<XElement>();
107. 
     
108.                 portConfig.PortName = xElement.Attribute("Id").Value;
109.                 portConfig.BaudRate = xElement.Element("BaudRate").Value;
110.                 portConfig.DataBits = xElement.Element("DataBits").Value;
111.                 portConfig.Paritys = xElement.Element("Paritys").Value;
112.                 portConfig.StopBits = xElement.Element("StopBits").Value;
113.                 portConfig.HandShaking = xElement.Element("HandShaking").Value;
114. 
     
115.             }
116.             xDom.Save(FilePath);
117.             return portConfig;
118.         }
119. 
     
120.         /// <summary>
121.         /// 增加端口配置
122.         /// </summary>
123.         /// <param name="portName"></param>
124.         public void EditSerialPort(PortConfig portConfig)
125.         {
126.             XDocument xDom = XDocument.Load(FilePath);
127. 
     
128.             var ports = from p in xDom.Root.Elements("PortName") where p.Attribute("Id").Value == portConfig.PortName select p;
129.             if (ports.Count() > 0)
130.             {
131.                 XElement xElement = ports.First<XElement>();
132. 
     
133.                 xElement.Attribute("Id").Value = portConfig.PortName;
134.                 xElement.Element("BaudRate").Value = portConfig.BaudRate;
135.                 xElement.Element("DataBits").Value = portConfig.DataBits;
136.                 xElement.Element("Paritys").Value = portConfig.Paritys;
137.                 xElement.Element("StopBits").Value = portConfig.StopBits;
138.                 xElement.Element("HandShaking").Value = portConfig.HandShaking;
139. 
     
140.             }
141.             xDom.Save(FilePath);
142.         }
143. 
     
144.         /// <summary>
145.         /// 判断端口配置是否存在
146.         /// </summary>
147.         /// <param name="portName"></param>
148.         /// <returns></returns>
149.         public bool Exist(string portName)
150.         {
151.             XDocument xDom = XDocument.Load(FilePath);
152.             var ports = from p in xDom.Root.Elements("PortName") where p.Attribute("Id").Value == portName select p;
153.             if (ports.Count() > 0)
154.             {
155.                 return true;
156.             }
157.             else
158.             {
159.                 return false;
160.             }
161.         }
162. 
     
163.         /// <summary>
164.         /// 判断文件是否存在
165.         /// </summary>
166.         /// <param name="FilePath"></param>
167.         public void fileIsExist(string FilePath)
168.         {
169.             if (!File.Exists(FilePath))
170.             {
171.                 XDocument xDom = new XDocument();
172.                 xDom.Add(new XElement("SerialPorts"));
173.                 xDom.Save(FilePath);
174.             }
175.         }
176. 
     
177.     }
178. }