C#创建、读写、增加、删除XML操作

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Xml;
using System.Collections;

namespace CommandXML
{
    public class cmdXML
    {

/// <summary>
        /// 创建XML文件
        /// </summary>
        /// <param name="xmlFilePath">存放目录</param>
        /// <param name="rootNodename">根节点名字</param>
        public void CreateXMLDoc(string xmlFilePath, string rootNodename)
         {
             //初始化一个xml实例
             XmlDocument myXmlDoc = new XmlDocument();
             //<?xml version="1.0" encoding="UTF-8"?>
             myXmlDoc.AppendChild(myXmlDoc.CreateXmlDeclaration("1.0", "UTF-8", null));
             //创建xml的根节点
             XmlElement rootElement = myXmlDoc.CreateElement(rootNodename);
             //将根节点加入到xml文件中（AppendChild）
             myXmlDoc.AppendChild(rootElement);
             myXmlDoc.Save(xmlFilePath);
         }

/// <summary>
        /// 增加第一层的节点
        /// </summary>
        /// <param name="xmlFilePath">文件路径</param>
        /// <param name="RootPath">根节点名字</param>
        /// <param name="Name">所要添加第一层节点的节点名</param>
        /// <param name="attribute"></param>
        public void AddXmlFirstNode(string xmlFilePath, string RootPath, string Name, string[,] attribute)
         {
             try
             {
                 XmlDocument myXmlDoc = new XmlDocument();
                 myXmlDoc.Load(xmlFilePath);

XmlNode memberlist = myXmlDoc.SelectSingleNode(RootPath);
                 //XmlNodeList nodelist = memberlist.ChildNodes;

XmlElement firstLevelElement1 = myXmlDoc.CreateElement(Name);
                 //填充第一层的第一个子节点的属性值（SetAttribute）
                 for (int i = 0; i < attribute.GetLength(0); i++)
                 {
                     firstLevelElement1.SetAttribute(attribute[i, 0], attribute[i, 1]);
                 }
                 //将第一层的第一个子节点加入到根节点下
                 memberlist.AppendChild(firstLevelElement1);

//保存更改
                 myXmlDoc.Save(xmlFilePath);
             }
             catch (Exception ex)
             {
                 Console.WriteLine(ex.ToString());
             }
         }

/// <summary>
         /// 增加第二层节点
         /// </summary>
         /// <param name="xmlFilePath">路径</param>
         /// <param name="RootPath">根节点名</param>
         /// <param name="FirstElementattributesName">第一层节点属性名</param>
         /// <param name="Firstattributes">第一层节点属性名对应的值</param>
         /// <param name="SecondElement">所要增加的第二层节点名</param>
         /// <param name="SecondinnerText">第二层节点对应的存储内容</param>
        public void AddXmlSecondNod(string xmlFilePath, string RootPath, string FirstElementattributesName, string Firstattributes, string[] SecondElement, string[] SecondinnerText)
         {
             try
             {
                 XmlDocument myXmlDoc = new XmlDocument();
                 myXmlDoc.Load(xmlFilePath);

XmlNode memberlist = myXmlDoc.SelectSingleNode(RootPath);
                 XmlNodeList nodelist = memberlist.ChildNodes;

//添加一个带有属性的节点信息
                 foreach (XmlNode node in nodelist)
                 {
                     if (node.Attributes[FirstElementattributesName].Value.Equals(Firstattributes))
                     {
                         for (int i = 0; i < SecondElement.Length; i++)
                         {
                             XmlElement newElement = myXmlDoc.CreateElement(SecondElement[i]);
                             newElement.InnerText = SecondinnerText[i];
                             node.AppendChild(newElement);
                         }
                     }
                 }
                 //保存更改
                 myXmlDoc.Save(xmlFilePath);
             }
             catch (Exception ex)
             {
                 Console.WriteLine(ex.ToString());
             }
         }

/// <summary>
        /// 获取第一层节点的属性值，返回所有的属性名和对应的值
        /// </summary>
        /// <param name="xmlFilePath">文件路径</param>
        /// <param name="RootPath">根节点名</param>
        /// <param name="firstNodeName">第一层节点名</param>
        /// <returns></returns>
        public ArrayList GetXMLFirstNodeAttributes(string xmlFilePath, string RootPath, string firstNodeName)
         {
             ArrayList list = new ArrayList();
             try
             {
                 //初始化一个xml实例
                 XmlDocument myXmlDoc = new XmlDocument();
                 //加载xml文件（参数为xml文件的路径）
                 myXmlDoc.Load(xmlFilePath);
                 //获得第一个姓名匹配的节点（SelectSingleNode）：此xml文件的根节点
                 XmlNode rootNode = myXmlDoc.SelectSingleNode(RootPath);
                 //分别获得该节点的InnerXml和OuterXml信息
                 string innerXmlInfo = rootNode.InnerXml.ToString();
                 string outerXmlInfo = rootNode.OuterXml.ToString();
                 //获得该节点的子节点（即：该节点的第一层子节点）
                 XmlNodeList firstLevelNodeList = rootNode.ChildNodes;
                 foreach (XmlNode node in firstLevelNodeList)
                 {
                     //获得该节点的属性集合
                     if (node.Name == firstNodeName)
                     {
                         XmlAttributeCollection attributeCol = node.Attributes;
                         foreach (XmlAttribute attri in attributeCol)
                         {
                             //获取属性名称与属性值
                             string name = attri.Name;
                             string value = attri.Value;
                             list.Add(name + ":" + value);
                         }
                     }
                 }
             }
             catch (Exception ex)
             {
                 Console.WriteLine(ex.ToString());
             }
             return list;
         }

/// <summary>
        /// 获取第二层节点的存储值
        /// </summary>
        /// <param name="xmlFilePath">文件路径</param>
        /// <param name="RootPath">根节点</param>
        /// <param name="firstNodeName">第一层节点名</param>
        /// <param name="secondNoadeName">第二层节点名</param>
        /// <returns></returns>
        public ArrayList GetXMLSecondNodeValue(string xmlFilePath, string RootPath, string firstNodeName, string secondNoadeName)
         {
             ArrayList list = new ArrayList();
             try
             {
                 //初始化一个xml实例
                 XmlDocument myXmlDoc = new XmlDocument();
                 //加载xml文件（参数为xml文件的路径）
                 myXmlDoc.Load(xmlFilePath);
                 //获得第一个姓名匹配的节点（SelectSingleNode）：此xml文件的根节点
                 XmlNode rootNode = myXmlDoc.SelectSingleNode(RootPath);
                 //分别获得该节点的InnerXml和OuterXml信息
                 string innerXmlInfo = rootNode.InnerXml.ToString();
                 string outerXmlInfo = rootNode.OuterXml.ToString();
                 //获得该节点的子节点（即：该节点的第一层子节点）
                 XmlNodeList firstLevelNodeList = rootNode.ChildNodes;
                 foreach (XmlNode node in firstLevelNodeList)
                 {
                     //获得该节点的属性集合
                     if (node.Name == firstNodeName)
                     {
                         foreach (XmlNode _node in node.ChildNodes)
                         {
                             if (_node.Name == secondNoadeName)
                                 list.Add(_node.InnerText);
                         }
                     }

//判断此节点是否还有子节点
                     if (node.HasChildNodes)
                     {
                         //获取该节点的第一个子节点
                         XmlNode secondLevelNode1 = node.FirstChild;
                         //获取该节点的名字
                         string name = secondLevelNode1.Name;
                         //获取该节点的值（即：InnerText）
                         string innerText = secondLevelNode1.InnerText;
                         Console.WriteLine("{0} = {1}", name, innerText);

//获取该节点的第二个子节点（用数组下标获取）
                         XmlNode secondLevelNode2 = node.ChildNodes[1];
                         name = secondLevelNode2.Name;
                         innerText = secondLevelNode2.InnerText;
                         Console.WriteLine("{0} = {1}", name, innerText);
                     }
                 }
             }
             catch (Exception ex)
             {
                 Console.WriteLine(ex.ToString());
             }
             return list;
         }

/// <summary>
        /// 修改第一层节点的属性值
        /// </summary>
        /// <param name="xmlFilePath">文件路径</param>
        /// <param name="RootPath">根节点名</param>
        /// <param name="FirstNodeName">第一节点名</param>
        /// <param name="FirstNodeAttributes">第一节点属性名</param>
        /// <param name="FirstNodeAttributesOldValue">第一节点属性值</param>
        /// <param name="newValue"></param>
        public void ModifyXmlFirstattribute(string xmlFilePath, string RootPath, string FirstNodeName, string FirstNodeAttributes, string FirstNodeAttributesOldValue, string newValue)
         {
             try
             {
                 XmlDocument myXmlDoc = new XmlDocument();
                 myXmlDoc.Load(xmlFilePath);
                 //XmlNode rootNode = myXmlDoc.FirstChild;
                 //XmlNodeList firstLevelNodeList = rootNode.ChildNodes;
                 XmlNode rootNode = myXmlDoc.SelectSingleNode(RootPath);
                 foreach (XmlNode node in rootNode.ChildNodes)
                 {
                     if (node.Name.Equals(FirstNodeName))
                     {
                         //修改此节点的属性值
                         if (node.Attributes[FirstNodeAttributes].Value.Equals(FirstNodeAttributesOldValue))
                         {
                             node.Attributes[FirstNodeAttributes].Value = newValue;
                         }
                     }
                 }
                 //要想使对xml文件所做的修改生效，必须执行以下Save方法
                 myXmlDoc.Save(xmlFilePath);
             }
             catch (Exception ex)
             {
                 Console.WriteLine(ex.ToString());
             }
         }

/// <summary>
        /// 修改第二节点的存储值
        /// </summary>
        /// <param name="xmlFilePath">文件路径</param>
        /// <param name="RootPath">根节点名字</param>
        /// <param name="FirstNodeName">第一节点名字</param>
        /// <param name="FirstNodeAttributes">第一节点属性名</param>
        /// <param name="FirstNodeAttributesValue">第一节点属性值</param>
        /// <param name="SecondNodeName">第二节点名字</param>
        /// <param name="value">第二节点存储值</param>
        public void ModifyXmlElementValue(string xmlFilePath, string RootPath, string FirstNodeName,string FirstNodeAttributes, string FirstNodeAttributesValue, string SecondNodeName, string value)
         {
             try
             {
                 XmlDocument myXmlDoc = new XmlDocument();
                 myXmlDoc.Load(xmlFilePath);
                 XmlNode rootNode = myXmlDoc.SelectSingleNode(RootPath);
                 foreach (XmlNode node in rootNode.ChildNodes)
                 {
                     if (node.Name.Equals(FirstNodeName))
                     {
                         //修改此节点的属性值
                         if (node.Attributes[FirstNodeAttributes].Value.Equals(FirstNodeAttributesValue))
                         {
                             foreach (XmlNode _node in node.ChildNodes)
                             {
                                 if (_node.Name == SecondNodeName)
                                 {
                                     _node.InnerText = value;
                                 }
                             }
                         }
                     }
                 }
                 //要想使对xml文件所做的修改生效，必须执行以下Save方法
                 myXmlDoc.Save(xmlFilePath);
             }
             catch (Exception ex)
             {
                 Console.WriteLine(ex.ToString());
             }
         }

/// <summary>
        /// 删除第一节点
        /// </summary>
        /// <param name="xmlFilePath">路径</param>
        /// <param name="RootPath">根节点</param>
        /// <param name="FirstNodeName">第一节点名</param>
        /// <param name="FirstNodeAttributes">第一节点属性名</param>
        /// <param name="FirstNodeAttributesValue">第一节点属性值</param>
        public void DeleteXmlFirstnode(string xmlFilePath, string RootPath, string FirstNodeName, string FirstNodeAttributes, string FirstNodeAttributesValue)
         {
             try
             {
                 XmlDocument myXmlDoc = new XmlDocument();
                 myXmlDoc.Load(xmlFilePath);
                 XmlNode rootNode = myXmlDoc.SelectSingleNode(RootPath);

foreach (XmlNode node in rootNode.ChildNodes)
                 {
                     if (node.Name.Equals(FirstNodeName))
                     {
                         if (node.Attributes[FirstNodeAttributes].Value.Equals(FirstNodeAttributesValue))
                         {
                             //node.RemoveAll();
                             rootNode.RemoveChild(node);
                         }
                     }
                 }
                 //保存对xml文件所做的修改
                 myXmlDoc.Save(xmlFilePath);
             }
             catch (Exception ex)
             {
                 Console.WriteLine(ex.ToString());
             }
         }

/// <summary>
         /// 删除子节点
        /// </summary>
        /// <param name="xmlFilePath">路径</param>
        /// <param name="FirstElementattributesName">第一节点属性名</param>
        /// <param name="Firstattributes">第一节点属性值</param>
        /// <param name="secondnodeName">子节点名称</param>
        public void DeleteXmlsecondNode(string xmlFilePath, string RootPath, string FirstNodeName, string FirstNodeAttributes, string FirstNodeAttributesValue, string secondnodeName)
         {
             try
             {
                 XmlDocument myXmlDoc = new XmlDocument();
                 myXmlDoc.Load(xmlFilePath);
                 XmlNode rootNode = myXmlDoc.SelectSingleNode(RootPath);

foreach (XmlNode node in rootNode.ChildNodes)
                 {
                     if (node.Name.Equals(FirstNodeName))
                     {
                         if (node.Attributes[FirstNodeAttributes].Value.Equals(FirstNodeAttributesValue))
                         {
                             foreach (XmlNode _node in node.ChildNodes)
                             {
                                 if (_node.Name == secondnodeName)
                                     //_node.RemoveAll();
                                     node.RemoveChild(_node);

}
                         }
                     }
                 }
                 //保存对xml文件所做的修改
                 myXmlDoc.Save(xmlFilePath);
             }
             catch (Exception ex)
             {
                 Console.WriteLine(ex.ToString());
             }
         }

}
}

时间： 2024-08-02 09:36:14

C#创建、读写、增加、删除XML操作的相关文章

以编程的方式使用SQLite数据库 执行CRUD（创建 读取 更新 删除）操作

DBAdapter数据库辅助类 package com.databses; import android.content.ContentValues; import android.content.Context; import android.database.Cursor; import android.database.SQLException; import android.database.sqlite.SQLiteDatabase; import android.database.s

库函数文件，创建、打开、读写、删除、操作实现

库函数-文件访问 上一个博文主要讲了系统调用,接下来就开始库函数调用讲解. 特点:C库函数是独立与操作系统平台存在的,无论在nunixlinux,还是windows操作系统下库函数调用都是一样的. 一.打开文件 FILE*fopen(cons char*filename,const char*mode) Filename: 打开的文件名; Mode: 打开的模式; 常见的打开模式: R rb 只读方式打开 W wb 只写方式打开,文件不存在,进行创建. A,ab 追加方式打开,如果文件不存在,则

C语言链表总结(创建,排序,增加,删除）

#include <stdio.h>#include <stdlib.h> typedef struct NODE{ int data ; struct NODE * pNext ;} * PNODE , NODE ; PNODE create_list(void) ;void traverse_list(PNODE phead);int length_list(PNODE pHead) ;void sort_list(PNODE pHead);bool insert_list(P

Excel 增加删除线

Excel 增加删除线 操作如下: 2.  选中删除线即 增加删除线, 去掉删除线即删除删除线, 颜色可以定义成红色之类.

sql 创建表、删除表 增加字段 删除字段操作

[转]sql 创建表.删除表 增加字段 删除字段操作 下面是Sql Server 和 Access 操作数据库结构的常用Sql,希望对你有所帮助. 新建表:create table [表名]([自动编号字段] int IDENTITY (1,1) PRIMARY KEY ,[字段1] nVarChar(50) default \'默认值\' null ,[字段2] ntext null ,[字段3] datetime,[字段4] money null ,[字段5] int default 0,[

java dom4j创建 ，修改 ，删除 xml文件内容

import java.io.File; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.io.UnsupportedEncodingException; import org.dom4j.Attribute; import org.dom4j.Document; import org.dom4j.DocumentExcep

基于Centos6系统创建逻辑卷LVM，执行扩容，缩减，删除等操作

什么是逻辑卷? LVM是逻辑盘卷管理(Logical Volume Manager)的简称,它是Linux环境下对磁盘分区进行管理的一种机制,LVM是建立在硬盘和分区之上的一个逻辑层,来提高磁盘分区管理的灵活性. LVM的工作原理其实很简单,它就是通过将底层的物理硬盘抽象的封装起来,然后以逻辑卷的方式呈现给上层应用.在传统的磁盘管理机制中,我们的上层应用是直接访问文件系统,从而对底层的物理硬盘进行读取,而在LVM中,其通过对底层的硬盘进行封装,当我们对底层的物理硬盘进行操作时,其不再是针对于分区

基于CentOS 6 系统创建逻辑卷LVM，执行扩容，缩减，删除等操作

2016-08-29 05:37:57 标签:Linux LVMFstab VG PV 原创作品,允许转载,转载时请务必以超链接形式标明文章 原始出处 .作者信息和本声明.否则将追究法律责任.http://51eat.blog.51cto.com/11892702/1843663 什么是逻辑卷? LVM是逻辑盘卷管理(Logical Volume Manager)的简称,它是Linux环境下对磁盘分区进行管理的一种机制,LVM是建立在硬盘和分区之上的一个逻辑层,来提高磁盘分区管理的灵活性. LV

.net学习笔记---xml操作及读写

一.XML文件操作中与.Net中对应的类 微软的.NET框架在System.xml命名空间提供了一系列的类用于Dom的实现. 以下给出XML文档的组成部分对应.NET中的类: XML文档组成部分 对应.net中的类 处理指令 XmlProcessingInstruction 专指元素节点 XmlElement 属性 XmlAttribute 文本节点 XmlText 节点 XmlNode 文档 XmlDocument XmlWriter 对象的特性 XmlWriterSettings 注释 Xm