1
using System;
2
using System.Xml;
3
using System.Web;
4
5
/**//// <summary>
6
/// XML核心类:
7
/// 必需用XPath表达式来获取相应节点
8
/// </summary>
9
public class XmlCore
10

{
11
变量-----------------------------------------------------------#region 变量-----------------------------------------------------------
12
13
14
private string xmlFilePath;
15
private XmlDocument xmlDoc = new XmlDocument();
16
#endregion
17
18
属性-----------------------------------------------------------#region 属性-----------------------------------------------------------
19
/**//// <summary>
20
/// 文件路径
21
/// </summary>
22
/// <remarks>文件路径</remarks>
23
public string XmlFilePath
24
{
25
get
26
{
27
return this.xmlFilePath;
28
}
29
set
30
{
31
xmlFilePath = value;
32
33
}
34
}
35
36
#endregion
37
38
构造函数-------------------------------------------------------#region 构造函数-------------------------------------------------------
39
/**//// <summary>
40
/// 构造函数
41
/// </summary>
42
/// <param name="tempXmlFilePath">已有的文件的路径</param>
43
public XmlCore(string tempXmlFilePath)
44
{
45
this.xmlFilePath = tempXmlFilePath;
46
GetXmlDocument();
47
}
48
49
/**//// <summary>
50
/// 构造函数
51
/// </summary>
52
/// <param name="NewXmlFilePath">将要新建的文件路径</param>
53
/// <param name="RootNodeName">根节点名称</param>
54
public XmlCore(string NewXmlFilePath, string RootNodeName)
55
{
56
CreateNewXmlFile(NewXmlFilePath, RootNodeName);
57
this.xmlFilePath = NewXmlFilePath;
58
GetXmlDocument();
59
}
60
61
/**////<summary>
62
///获取XmlDocument实体类
63
///</summary>
64
/// <returns>指定的XML描述文件的一个xmldocument实例</returns>
65
private XmlDocument GetXmlDocument()
66
{
67
XmlDocument doc = null;
68
69
doc = GetXmlDocumentFromFile(xmlFilePath);
70
71
return doc;
72
}
73
74
private XmlDocument GetXmlDocumentFromFile(string tempXmlFilePath)
75
{
76
string xmlFileFullPath = tempXmlFilePath;
77
xmlDoc.Load(xmlFileFullPath);
78
//定义事件处理
79
xmlDoc.NodeChanged += new XmlNodeChangedEventHandler(this.nodeUpdateEvent);
80
xmlDoc.NodeInserted += new XmlNodeChangedEventHandler(this.nodeInsertEvent);
81
xmlDoc.NodeRemoved += new XmlNodeChangedEventHandler(this.nodeDeleteEvent);
82
return xmlDoc;
83
}
84
85
private void CreateNewXmlFile(string filePath, string rootNode)
86
{
87
XmlTextWriter xtw = new XmlTextWriter(filePath, System.Text.Encoding.UTF8);
88
xtw.Formatting = Formatting.Indented;
89
xtw.WriteStartDocument(false);
90
xtw.WriteStartElement(rootNode);
91
xtw.WriteEndElement();
92
xtw.Flush();
93
xtw.Close();
94
}
95
96
#endregion
97
98
获取所有指定名称的节点#region 获取所有指定名称的节点
99
/**//// <summary>
100
/// 功能:
101
/// 获取所有指定名称的节点(XmlNodeList)
102
/// </summary>
103
/// <param >节点名称</param>
104
public XmlNodeList GetXmlNodeList(string strNode)
105
{
106
XmlNodeList strReturn = null;
107
try
108
{
109
//根据指定路径获取节点
110
XmlNodeList xmlNode = xmlDoc.SelectNodes(strNode);
111
if (!(xmlNode == null))
112
{
113
strReturn = xmlNode;
114
}
115
}
116
catch (XmlException xmle)
117
{
118
throw xmle;
119
}
120
return strReturn;
121
}
122
#endregion
123
124
读取指定节点的指定属性值---------------------------------------#region 读取指定节点的指定属性值---------------------------------------
125
/**//// <summary>
126
/// 功能:
127
/// 读取指定节点的指定属性值(Value)
128
/// </summary>
129
/// <param >节点名称</param>
130
/// <param >此节点的属性</param>
131
/// <returns></returns>
132
public string GetXmlNodeAttributeValue(string strNode, string strAttribute)
133
{
134
string strReturn = "";
135
try
136
{
137
//根据指定路径获取节点
138
XmlNode xmlNode = xmlDoc.SelectSingleNode(strNode);
139
if (!(xmlNode == null))
140
{
141
strReturn = xmlNode.Attributes.GetNamedItem(strAttribute).Value;
142
143
/**/////获取节点的属性,并循环取出需要的属性值
144
//XmlAttributeCollection xmlAttr = xmlNode.Attributes;
145
//for (int i = 0; i < xmlAttr.Count; i++)
146
//{
147
// if (xmlAttr.Item(i).Name == strAttribute)
148
// {
149
// strReturn = xmlAttr.Item(i).Value;
150
// break;
151
// }
152
//}
153
}
154
}
155
catch (XmlException xmle)
156
{
157
throw xmle;
158
}
159
return strReturn;
160
}
161
#endregion
162
163
读取指定节点的值-----------------------------------------------#region 读取指定节点的值-----------------------------------------------
164
/**//// <summary>
165
/// 功能:
166
/// 读取指定节点的值(InnerText)
167
/// </summary>
168
/// <param >节点名称</param>
169
/// <returns></returns>
170
public string GetXmlNodeValue(string strNode)
171
{
172
string strReturn = String.Empty;
173
try
174
{
175
//根据路径获取节点
176
XmlNode xmlNode = xmlDoc.SelectSingleNode(strNode);
177
if (!(xmlNode == null))
178
strReturn = xmlNode.InnerText;
179
}
180
catch (XmlException xmle)
181
{
182
throw xmle;
183
}
184
return strReturn;
185
}
186
#endregion
187
188
设置节点值-----------------------------------------------------#region 设置节点值-----------------------------------------------------
189
/**//// <summary>
190
/// 功能:
191
/// 设置节点值(InnerText)
192
/// </summary>
193
/// <param >节点的名称</param>
194
/// <param >节点值</param>
195
public void SetXmlNodeValue(string xmlNodePath, string xmlNodeValue)
196
{
197
try
198
{
199
//可以批量为符合条件的节点进行付值
200
XmlNodeList xmlNode = this.xmlDoc.SelectNodes(xmlNodePath);
201
if (!(xmlNode == null))
202
{
203
foreach (XmlNode xn in xmlNode)
204
{
205
xn.InnerText = xmlNodeValue;
206
}
207
}
208
/**//**/
209
/**//*
210
* 根据指定路径获取节点
211
XmlNode xmlNode = xmlDoc.SelectSingleNode(xmlNodePath) ;
212
//设置节点值
213
if (!(xmlNode==null))
214
xmlNode.InnerText = xmlNodeValue ;*/
215
}
216
catch (XmlException xmle)
217
{
218
throw xmle;
219
}
220
}
221
#endregion
222
223
设置节点的属性值-----------------------------------------------#region 设置节点的属性值-----------------------------------------------
224
/**//// <summary>
225
/// 功能:
226
/// 设置节点的属性值
227
/// </summary>
228
/// <param >节点名称</param>
229
/// <param >属性名称</param>
230
/// <param >属性值</param>
231
public void SetXmlNodeAttributeValue(string xmlNodePath, string xmlNodeAttribute, string xmlNodeAttributeValue)
232
{
233
try
234
{
235
//可以批量为符合条件的节点的属性付值
236
XmlNodeList xmlNode = this.xmlDoc.SelectNodes(xmlNodePath);
237
if (!(xmlNode == null))
238
{
239
foreach (XmlNode xn in xmlNode)
240
{
241
XmlAttributeCollection xmlAttr = xn.Attributes;
242
for (int i = 0; i < xmlAttr.Count; i++)
243
{
244
if (xmlAttr.Item(i).Name == xmlNodeAttribute)
245
{
246
xmlAttr.Item(i).Value = xmlNodeAttributeValue;
247
break;
248
}
249
}
250
}
251
}
252
}
253
catch (XmlException xmle)
254
{
255
throw xmle;
256
}
257
}
258
#endregion
259
260
添加-----------------------------------------------------------#region 添加-----------------------------------------------------------
261
/**//// <summary>
262
/// 获取XML文件的根元素
263
/// </summary>
264
public XmlNode GetXmlRoot()
265
{
266
return xmlDoc.DocumentElement;
267
}
268
269
/**//// <summary>
270
/// 在根节点下添加父节点
271
/// </summary>
272
public void AddParentNode(string parentNode)
273
{
274
try
275
{
276
XmlNode root = GetXmlRoot();
277
XmlNode parentXmlNode = xmlDoc.CreateElement(parentNode);
278
root.AppendChild(parentXmlNode);
279
}
280
catch (XmlException xmle)
281
{
282
throw xmle;
283
}
284
}
285
286
/**//// <summary>
287
/// 向一个已经存在的父节点中插入一个子节点,并返回子节点.
288
/// </summary>
289
/// <param >父节点</param>
290
/// <param >字节点名称</param>
291
public XmlNode AddChildNode(string parentNodePath, string childnodename)
292
{
293
XmlNode childXmlNode = null;
294
try
295
{
296
XmlNode parentXmlNode = xmlDoc.SelectSingleNode(parentNodePath);
297
if (!((parentXmlNode) == null))//如果此节点存在
298
{
299
childXmlNode = xmlDoc.CreateElement(childnodename);
300
parentXmlNode.AppendChild(childXmlNode);
301
}
302
else
303
{//如果不存在就放父节点添加
304
this.GetXmlRoot().AppendChild(childXmlNode);
305
}
306
}
307
catch (XmlException xmle)
308
{
309
throw xmle;
310
}
311
return childXmlNode;
312
}
313
/**//// <summary>
314
/// 向一个已经存在的父节点中插入一个子节点,并添加一个属性
315
/// </summary>
316
public void AddChildNode(string parentNodePath, string childnodename, string NodeAttribute, string NodeAttributeValue)
317
{
318
try
319
{
320
XmlNode parentXmlNode = xmlDoc.SelectSingleNode(parentNodePath);
321
XmlNode childXmlNode = null;
322
if (!((parentXmlNode) == null))//如果此节点存在
323
{
324
childXmlNode = xmlDoc.CreateElement(childnodename);
325
326
//添加属性
327
XmlAttribute nodeAttribute = this.xmlDoc.CreateAttribute(NodeAttribute);
328
nodeAttribute.Value = NodeAttributeValue;
329
childXmlNode.Attributes.Append(nodeAttribute);
330
331
parentXmlNode.AppendChild(childXmlNode);
332
}
333
else
334
{//如果不存在就放父节点添加
335
this.GetXmlRoot().AppendChild(childXmlNode);
336
}
337
}
338
catch (XmlException xmle)
339
{
340
throw xmle;
341
}
342
}
343
344
/**//// <summary>
345
/// 向一个节点添加属性,值为空
346
/// </summary>
347
/// <param >节点路径</param>
348
/// <param >属性名</param>
349
public void AddAttribute(string NodePath, string NodeAttribute)
350
{
351
privateAddAttribute(NodePath, NodeAttribute, "");
352
}
353
/**//// <summary>
354
/// 向一个节点添加属性,并赋值***
355
/// </summary>
356
public void AddAttribute(XmlNode childXmlNode, string NodeAttribute, string NodeAttributeValue)
357
{
358
XmlAttribute nodeAttribute = this.xmlDoc.CreateAttribute(NodeAttribute);
359
nodeAttribute.Value = NodeAttributeValue;
360
childXmlNode.Attributes.Append(nodeAttribute);
361
}
362
363
/**//// <summary>
364
/// 向一个节点添加属性
365
/// </summary>
366
/// <param >节点路径</param>
367
/// <param >属性名</param>
368
/// <param >属性值</param>
369
private void privateAddAttribute(string NodePath, string NodeAttribute, string NodeAttributeValue)
370
{
371
try
372
{
373
XmlNode nodePath = xmlDoc.SelectSingleNode(NodePath);
374
if (!(nodePath == null))
375
{
376
XmlAttribute nodeAttribute = this.xmlDoc.CreateAttribute(NodeAttribute);
377
nodeAttribute.Value = NodeAttributeValue;
378
nodePath.Attributes.Append(nodeAttribute);
379
}
380
}
381
catch (XmlException xmle)
382
{
383
throw xmle;
384
}
385
}
386
/**//// <summary>
387
/// 向一个节点添加属性,并赋值
388
/// </summary>
389
/// <param >节点</param>
390
/// <param >属性名</param>
391
/// <param >属性值</param>
392
public void AddAttribute(string NodePath, string NodeAttribute, string NodeAttributeValue)
393
{
394
privateAddAttribute(NodePath, NodeAttribute, NodeAttributeValue);
395
}
396
#endregion
397
398
删除-----------------------------------------------------------#region 删除-----------------------------------------------------------
399
/**//// <summary>
400
/// 删除节点的一个属性
401
/// </summary>
402
/// <param >节点所在的xpath表达式</param>
403
/// <param >属性名</param>
404
public void DeleteAttribute(string NodePath, string NodeAttribute)
405
{
406
XmlNodeList nodePath = this.xmlDoc.SelectNodes(NodePath);
407
if (!(nodePath == null))
408
{
409
foreach (XmlNode tempxn in nodePath)
410
{
411
XmlAttributeCollection xmlAttr = tempxn.Attributes;
412
for (int i = 0; i < xmlAttr.Count; i++)
413
{
414
if (xmlAttr.Item(i).Name == NodeAttribute)
415
{
416
tempxn.Attributes.RemoveAt(i);
417
break;
418
}
419
}
420
}
421
}
422
}
423
424
/**//// <summary>
425
/// 删除节点的一个属性,当其属性值等于给定的值时
426
/// </summary>
427
/// <param >节点所在的xpath表达式</param>
428
/// <param >属性</param>
429
/// <param >值</param>
430
public void DeleteAttribute(string NodePath, string NodeAttribute, string NodeAttributeValue)
431
{
432
XmlNodeList nodePath = this.xmlDoc.SelectNodes(NodePath);
433
if (!(nodePath == null))
434
{
435
foreach (XmlNode tempxn in nodePath)
436
{
437
XmlAttributeCollection xmlAttr = tempxn.Attributes;
438
for (int i = 0; i < xmlAttr.Count; i++)
439
{
440
if (xmlAttr.Item(i).Name == NodeAttribute && xmlAttr.Item(i).Value == NodeAttributeValue)
441
{
442
tempxn.Attributes.RemoveAt(i);
443
break;
444
}
445
}
446
}
447
}
448
}
449
/**//// <summary>
450
/// 删除节点
451
/// </summary>
452
/// <param ></param>
453
/// <remarks></remarks>
454
public void DeleteXmlNode(string tempXmlNode)
455
{
456
XmlNodeList nodePath = this.xmlDoc.SelectNodes(tempXmlNode);
457
if (!(nodePath == null))
458
{
459
foreach (XmlNode xn in nodePath)
460
{
461
xn.ParentNode.RemoveChild(xn);
462
}
463
}
464
}
465
466
#endregion
467
468
XML文档事件----------------------------------------------------#region XML文档事件----------------------------------------------------
469
/**//// <summary>
470
/// 节点插入事件
471
/// </summary>
472
/// <param ></param>
473
/// <param ></param>
474
private void nodeInsertEvent(Object src, XmlNodeChangedEventArgs args)
475
{
476
//保存设置
477
SaveXmlDocument();
478
}
479
/**//// <summary>
480
/// 节点删除事件
481
/// </summary>
482
/// <param ></param>
483
/// <param ></param>
484
private void nodeDeleteEvent(Object src, XmlNodeChangedEventArgs args)
485
{
486
//保存设置
487
SaveXmlDocument();
488
}
489
/**//// <summary>
490
/// 节点更新事件
491
/// </summary>
492
/// <param ></param>
493
/// <param ></param>
494
private void nodeUpdateEvent(Object src, XmlNodeChangedEventArgs args)
495
{
496
//保存设置
497
SaveXmlDocument();
498
}
499
#endregion
500
501
保存XML文件----------------------------------------------------#region 保存XML文件----------------------------------------------------
502
/**//// <summary>
503
/// 功能:
504
/// 保存XML文件
505
/// </summary>
506
public void SaveXmlDocument()
507
{
508
try
509
{
510
//保存设置的结果
511
Savexml(xmlFilePath);
512
513
}
514
catch (XmlException xmle)
515
{
516
throw xmle;
517
}
518
}
519
520
/**//// <summary>
521
/// 功能:
522
/// 保存XML文件
523
/// </summary>
524
public void SaveXmlDocument(string tempXMLFilePath)
525
{
526
try
527
{
528
//保存设置的结果
529
Savexml(tempXMLFilePath);
530
}
531
catch (XmlException xmle)
532
{
533
throw xmle;
534
}
535
}
536
/**//// <summary>
537
///
538
/// </summary>
539
/// <param ></param>
540
private void Savexml(string filepath)
541
{
542
xmlDoc.Save(filepath);
543
}
544
545
#endregion
546
547
}
548
549

2

3

4

5


6

7

8

9

10



11


12

13

14

15

16

17

18


19


20

21

22

23

24



25

26



27

28

29

30



31

32

33

34

35

36

37

38


39


40

41

42

43

44



45

46

47

48

49


50

51

52

53

54

55



56

57

58

59

60

61


62

63

64

65

66



67

68

69

70

71

72

73

74

75



76

77

78

79

80

81

82

83

84

85

86



87

88

89

90

91

92

93

94

95

96

97

98


99


100

101

102

103

104

105



106

107

108



109

110

111

112



113

114

115

116

117



118

119

120

121

122

123

124


125


126

127

128

129

130

131

132

133



134

135

136



137

138

139

140



141

142

143


144

145

146

147

148

149

150

151

152

153

154

155

156



157

158

159

160

161

162

163


164


165

166

167

168

169

170

171



172

173

174



175

176

177

178

179

180

181



182

183

184

185

186

187

188


189


190

191

192

193

194

195

196



197

198



199

200

201

202



203

204



205

206

207

208


209


210

211

212

213

214

215

216

217



218

219

220

221

222

223


224


225

226

227

228

229

230

231

232



233

234



235

236

237

238



239

240



241

242

243



244

245



246

247

248

249

250

251

252

253

254



255

256

257

258

259

260


261


262

263

264

265



266

267

268

269


270

271

272

273



274

275



276

277

278

279

280

281



282

283

284

285

286


287

288

289

290

291

292



293

294

295



296

297

298



299

300

301

302

303



304

305

306

307

308



309

310

311

312

313


314

315

316

317



318

319



320

321

322

323



324

325

326

327

328

329

330

331

332

333

334



335

336

337

338

339



340

341

342

343

344


345

346

347

348

349

350



351

352

353


354

355

356

357



358

359

360

361

362

363


364

365

366

367

368

369

370



371

372



373

374

375



376

377

378

379

380

381

382



383

384

385

386


387

388

389

390

391

392

393



394

395

396

397

398


399


400

401

402

403

404

405



406

407

408



409

410



411

412

413



414

415



416

417

418

419

420

421

422

423

424


425

426

427

428

429

430

431



432

433

434



435

436



437

438

439



440

441



442

443

444

445

446

447

448

449


450

451

452

453

454

455



456

457

458



459

460



461

462

463

464

465

466

467

468


469


470

471

472

473

474

475



476

477

478

479


480

481

482

483

484

485



486

487

488

489


490

491

492

493

494

495



496

497

498

499

500

501


502


503

504

505

506

507



508

509



510

511

512

513

514

515



516

517

518

519

520


521

522

523

524

525



526

527



528

529

530

531

532



533

534

535

536


537

538

539

540

541



542

543

544

545

546

547

548

549
