xml 帮助类

最新推荐文章于 2024-02-24 22:55:31 发布
转载 最新推荐文章于 2024-02-24 22:55:31 发布 · 60 阅读 · 0 ·
CC 4.0 BY-SA版权
原文链接：http://www.cnblogs.com/wlwjc/articles/wally.html 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Xml;
using System.IO;

public class XmlDoc
    {
         XmlDocument doc;
         string xmlFileName;
         readonly string xmlRootName;
        public XmlNode xmlRoot;

        //设置XML文件名
        public string FileName
        {
            set { xmlFileName = HttpContext.Current.Server.MapPath(value); }
        }

        /// <summary>
        /// 类初始化
        /// </summary>
        /// <param name='path'>文件夹</param>
        /// <param name='filename'>xml文件名</param>
        /// <param name='root'>xml根节点</param>
        public XmlDoc(string path, string filename, string root)
        {
            xmlRootName = root;
            xmlFileName = HttpContext.Current.Server.MapPath(path) + "\\" + filename;
            doc = new XmlDocument();
            try
            {
                doc.Load(xmlFileName);
            }
            catch
            {
                doc.LoadXml("<?xml version=\"1.0\" encoding=\"utf-8\"?><" + root + "></" + root + ">");
            }
            xmlRoot = doc.SelectSingleNode(xmlRootName);
        }

        /// <summary>
        /// 类初始化（从内容实例化XML）
        /// </summary>
        /// <param name='Content'>内容</param>
        /// <param name='root'>xml根节点</param>
        public XmlDoc(string Content, string root)
        {
            xmlRootName = root;
            doc = new XmlDocument();
            try
            {
                doc.LoadXml(Content);
            }
            catch
            {
                doc.LoadXml("<?xml version=\"1.0\" encoding=\"utf-8\"?><" + xmlRootName + "></" + xmlRootName + ">");
            }
            xmlRoot = doc.SelectSingleNode(xmlRootName);
            xmlFileName = HttpContext.Current.Server.MapPath(root + ".xml");
        }

        /// <summary>
        /// 保存XML文件
        /// </summary>
        /// <returns></returns>
        public void Save()
        {
            try
            {
                string server_path = Helper.GetServerPath(xmlFileName);
                if (!Directory.Exists(server_path))
                {
                    Directory.CreateDirectory(server_path);
                }
                doc.Save(xmlFileName);
            }
            catch
            {
                return;
            }
        }

        /// <summary>
        /// 删除XML文件
        /// </summary>
        /// <returns></returns>
        public void Delete()
        {
            try
            {
                if (File.Exists(xmlFileName))
                {
                    File.Delete(xmlFileName);
                }
            }
            catch
            {
                return;
            }
        }

        /// <summary>
        /// 获取类里的XmlDocument
        /// </summary>
        /// <returns></returns>
        public XmlDocument Doc
        {
            get { return doc; }
        }

        /// <summary>
        /// 对类里的XmlDocument重新初始化
        /// </summary>
        /// <returns></returns>
        public void DocInit()
        {
            doc = new XmlDocument();
            doc.LoadXml("<?xml version=\"1.0\" encoding=\"utf-8\"?><" + xmlRoot + "></" + xmlRoot + ">");
        }

        /// <summary>
        /// 获取类里的XmlDocument一个特定XmlElement
        /// </summary>
        /// <param name='parentNode'>父节点</param>
        /// <param name='tagName'>节点名称</param>
        /// <param name='index'>节点数组下标值</param>
        /// <param name='IsAutoCreate'>是否自动创建</param>
        /// <returns>XmlElement</returns>
        public XmlElement GetXmlNodeByTagNameAndIndex(XmlElement parentNode, string tagName, int index, bool IsAutoCreate)
        {
            XmlElement xe;
            if (index < 0)
            {
                return null;
            }
            try
            {
                XmlNodeList elemList = parentNode.SelectNodes(tagName);
                //自动创建
                if (elemList.Count <= index && IsAutoCreate)
                {
                    for (int i = elemList.Count; i <= index; i++)
                    {
                        parentNode.AppendChild(doc.CreateElement(tagName));
                    }
                    elemList = parentNode.SelectNodes(tagName);
                }
                XmlNode xn = elemList[index];
                xe = (XmlElement)xn;
            }
            catch
            {
                xe = null;
            }
            return xe;
        }

        /// <summary>
        /// 获取类里的XmlDocument一个特定XmlElement（根据节点属性值查找）
        /// </summary>
        /// <param name='parentNode'>父节点</param>
        /// <param name='tagName'>节点名称</param>
        /// <param name='AttributeName'>节点属性名称</param>
        /// <param name='AttributeValue'>节点属性值</param>
        /// <param name='IsAutoCreate'>是否自动创建</param>
        /// <returns>XmlElement</returns>
        public XmlElement GetXmlNodeByTagNameAndAttribute(XmlElement parentNode, string tagName, string AttributeName, string AttributeValue, bool IsAutoCreate)
        {
            bool IsExists = false;
            XmlElement xe = null;
            string Value = "";
            try
            {
                XmlNodeList elemList = parentNode.SelectNodes(tagName);
                if (elemList != null)
                {
                    foreach (XmlNode xn in elemList)
                    {
                        if (xn.NodeType == XmlNodeType.Element)
                        {
                            XmlElement xel = (XmlElement)xn;
                            if (xel.HasAttribute(AttributeName))
                            {
                                Value = xel.GetAttribute(AttributeName);
                            }
                            if (Value == AttributeValue)
                            {
                                IsExists = true;
                                xe = xel;
                                break;
                            }
                        }
                    }
                }
                //自动创建
                if (!IsExists && IsAutoCreate)
                {
                    XmlElement elem = doc.CreateElement(tagName);
                    elem.SetAttribute(AttributeName, AttributeValue);
                    parentNode.AppendChild(elem);
                    xe = elem;
                }
            }
            catch
            {
                xe = null;
            }
            return xe;
        }

        /// <summary>
        /// 获取类里的XmlDocument一个特定XmlElement(根节点作父节点)
        /// </summary>
        /// <param name='tagName'>节点名称</param>
        /// <param name='index'>节点数组下标值</param>
        /// <param name='IsAutoCreate'>是否自动创建</param>
        /// <returns>XmlElement</returns>
        public XmlElement GetXmlNodeByTagNameAndIndex(string tagName, int index, bool IsAutoCreate)
        {
            XmlElement ParentNode = (XmlElement)xmlRoot;
            return GetXmlNodeByTagNameAndIndex(ParentNode, tagName, index, IsAutoCreate);
        }

        /// <summary>
        /// 获取类里的XmlDocument一个特定XmlElement（根节点作父节点，根据节点属性值查找）
        /// </summary>
        /// <param name='tagName'>节点名称</param>
        /// <param name='AttributeName'>节点属性名称</param>
        /// <param name='AttributeValue'>节点属性值</param>
        /// <param name='IsAutoCreate'>是否自动创建</param>
        /// <returns>XmlElement</returns>
        public XmlElement GetXmlNodeByTagNameAndAttribute(string tagName, string AttributeName, string AttributeValue, bool IsAutoCreate)
        {
            XmlElement ParentNode = (XmlElement)xmlRoot;
            return GetXmlNodeByTagNameAndAttribute(ParentNode, tagName, AttributeName, AttributeValue, IsAutoCreate);
        }

        /// <summary>
        /// 为类里的XmlDocument一个特定XmlElement设置子CData节点
        /// </summary>
        /// <param name='xe'>节点</param>
        /// <param name='tagName'>子节点名称</param>
        /// <param name='tagValue'>子节点内容</param>
        /// <returns></returns>
        public void SetXmlCDataNode(XmlElement xe, string tagName, string tagValue)
        {
            XmlNode elemList = xe.SelectSingleNode(tagName);
            if (elemList != null)
            {
                if (elemList.FirstChild == null)
                {
                    XmlNode elem = elemList.AppendChild(doc.CreateCDataSection(tagValue));
                    elemList.AppendChild(elem);
                }
                else
                {
                    elemList.FirstChild.Value = tagValue;
                }
            }
            else
            {
                XmlElement elem = doc.CreateElement(tagName);
                XmlNode xn = elem.AppendChild(doc.CreateCDataSection(tagValue));
                elem.AppendChild(xn);
                xe.AppendChild(elem);
            }
        }

        /// <summary>
        /// 为类里的XmlDocument一个特定XmlElement设置子CData节点(根节点作节点)
        /// </summary>
        /// <param name='tagName'>子节点名称</param>
        /// <param name='tagValue'>子节点内容</param>
        /// <returns></returns>
        public void SetXmlCDataNode(string tagName, string tagValue)
        {
            XmlElement ParentNode = (XmlElement)xmlRoot;
            SetXmlCDataNode(ParentNode, tagName, tagValue);
        }

        /// <summary>
        /// 获取类里的XmlDocument一个特定XmlElement的子CData节点内容
        /// </summary>
        /// <param name='xe'>节点</param>
        /// <param name='tagName'>子节点名称</param>
        /// <returns>string</returns>
        public string GetXmlCData(XmlElement xe, string tagName)
        {
            string tagValue = "";
            XmlNode elemList = xe.SelectSingleNode(tagName);
            if (elemList != null)
            {
                if (elemList.FirstChild != null)
                {
                    tagValue = elemList.FirstChild.Value;
                }
            }
            return tagValue;
        }

        /// <summary>
        /// 获取类里的XmlDocument一个特定XmlElement的子CData节点内容(根节点作节点)
        /// </summary>
        /// <param name='tagName'>子节点名称</param>
        /// <returns>string</returns>
        public string GetXmlCData(string tagName)
        {
            XmlElement ParentNode = (XmlElement)xmlRoot;
            return GetXmlCData(ParentNode, tagName);
        }

        /// <summary>
        /// 为类里的XmlDocument一个特定XmlElement设置属性
        /// </summary>
        /// <param name='xe'>节点</param>
        /// <param name='tagName'>节点属性名称</param>
        /// <param name='tagValue'>节点属性值</param>
        /// <returns></returns>
        public void SetXmlAttribute(XmlElement xe, string tagName, string tagValue)
        {
            if (xe.HasAttribute(tagName))
            {
                xe.SetAttribute(tagName, tagValue);
            }
            else
            {
                xe.SetAttribute(tagName, tagValue);
            }
        }

        /// <summary>
        /// 获取类里的XmlDocument一个特定XmlElement的属性值
        /// </summary>
        /// <param name='xe'>节点</param>
        /// <param name='tagName'>节点属性名称</param>
        /// <returns>string</returns>
        public string GetXmlAttribute(XmlElement xe, string tagName)
        {
            string tagValue = "";
            if (xe.HasAttribute(tagName))
            {
                tagValue = xe.GetAttribute(tagName);
            }
            return tagValue;
        }

        /// <summary>
        /// 移除类里的XmlDocument一个特定XmlElement的属性值
        /// </summary>
        /// <param name='xe'>节点</param>
        /// <param name='tagName'>节点属性名称</param>
        /// <returns></returns>
        public void RemoveXmlAttribute(XmlElement xe, string tagName)
        {
            if (xe.HasAttribute(tagName))
            {
                xe.RemoveAttribute(tagName);
            }
        }

        /// <summary>
        /// 移除类里的XmlDocument一个特定XmlElement的子节点
        /// </summary>
        /// <param name='xe'>节点</param>
        /// <param name='tagName'>子节点名称</param>
        /// <returns></returns>
        public void RemoveXmlChildNode(XmlElement xe, string tagName)
        {
            XmlNode removeNode = xe.SelectSingleNode(tagName);
            if (removeNode != null)
            {
                xe.RemoveChild(removeNode);
            }
        }

        /// <summary>
        /// 移除类里的XmlDocument一个特定XmlElement(根节点不能移除)
        /// </summary>
        /// <param name='xe'>节点</param>
        /// <returns></returns>
        public void RemoveXmlNode(XmlElement xe)
        {
            if (xe.ParentNode != null)
            {
                xe.ParentNode.RemoveChild(xe);
            }
        }

        /// <summary>
        /// 上移类里的XmlDocument一个特定XmlElement
        /// </summary>
        /// <param name='parentNode'>父节点</param>
        /// <param name='tagName'>节点名称</param>
        /// <param name='index'>节点数组下标值</param>
        /// <returns></returns>
        public void Up(XmlElement parentNode, string tagName, int index)
        {
            XmlNodeList elemList = parentNode.SelectNodes(tagName);
            if (elemList != null)
            {
                if ((elemList.Count) > index && (index > 0))
                {
                    XmlNode refChild = elemList[index];

                    XmlNode xn = elemList[index - 1];
                    RemoveXmlNode((XmlElement)xn);
                    parentNode.InsertAfter(xn, refChild);
                }
            }
        }

        /// <summary>
        /// 上移类里的XmlDocument一个特定XmlElement(根节点作父节点)
        /// </summary>
        /// <param name='tagName'>节点名称</param>
        /// <param name='index'>节点数组下标值</param>
        /// <returns></returns>
        public void Up(string tagName, int index)
        {
            XmlElement ParentNode = (XmlElement)xmlRoot;
            Up(ParentNode, tagName, index);
        }

        /// <summary>
        /// 下移类里的XmlDocument一个特定XmlElement
        /// </summary>
        /// <param name='parentNode'>父节点</param>
        /// <param name='tagName'>节点名称</param>
        /// <param name='index'>节点数组下标值</param>
        /// <returns></returns>
        public void Down(XmlElement parentNode, string tagName, int index)
        {
            XmlNodeList elemList = parentNode.SelectNodes(tagName);
            if (elemList != null)
            {
                if ((elemList.Count - 1) > index && (index >= 0))
                {
                    XmlNode refChild = elemList[index];

                    XmlNode xn = elemList[index + 1];
                    RemoveXmlNode((XmlElement)xn);
                    parentNode.InsertBefore(xn, refChild);
                }
            }
        }

        /// <summary>
        /// 下移类里的XmlDocument一个特定XmlElement(根节点作父节点)
        /// </summary>
        /// <param name='tagName'>节点名称</param>
        /// <param name='index'>节点数组下标值</param>
        /// <returns></returns>
        public void Down(string tagName, int index)
        {
            XmlElement ParentNode = (XmlElement)xmlRoot;
            Down(ParentNode, tagName, index);
        }

        /// <summary>
        /// 获取类里的XmlDocument一个特定XmlElement下的所有相同节点名的节点数量
        /// </summary>
        /// <param name='parentNode'>父节点</param>
        /// <param name='tagName'>节点名称</param>
        /// <returns>int</returns>
        public int GetNodeCount(XmlElement parentNode, string tagName)
        {
            int NodeCount = 0;
            XmlNodeList elemList = parentNode.SelectNodes(tagName);
            if (elemList != null)
            {
                NodeCount = elemList.Count;
            }
            return NodeCount;
        }

        /// <summary>
        /// 获取类里的XmlDocument一个特定XmlElement下的所有相同节点名的节点数量(根节点作父节点)
        /// </summary>
        /// <param name='tagName'>节点名称</param>
        /// <returns>int</returns>
        public int GetNodeCount(string tagName)
        {
            XmlElement ParentNode = (XmlElement)xmlRoot;
            return GetNodeCount(ParentNode, tagName);
        }

        /// <summary>
        /// 为类里的XmlDocument一个特定XmlElement设置子Text节点
        /// </summary>
        /// <param name='xe'>节点</param>
        /// <param name='tagName'>子节点名称</param>
        /// <param name='tagValue'>子节点内容</param>
        /// <returns></returns>
        public void SetXmlTextNode(XmlElement xe, string tagName, string tagValue)
        {
            XmlNode elemList = xe.SelectSingleNode(tagName);
            if (elemList != null)
            {
                if (elemList.FirstChild == null)
                {
                    XmlNode elem = elemList.AppendChild(doc.CreateTextNode(tagValue));
                    elemList.AppendChild(elem);
                }
                else
                {
                    elemList.FirstChild.Value = tagValue;
                }
            }
            else
            {
                XmlElement elem = doc.CreateElement(tagName);
                XmlNode xn = elem.AppendChild(doc.CreateTextNode(tagValue));
                elem.AppendChild(xn);
                xe.AppendChild(elem);
            }
        }

        /// <summary>
        /// 获取类里的XmlDocument一个特定XmlElement的子Text节点内容
        /// </summary>
        /// <param name='xe'>节点</param>
        /// <param name='tagName'>子节点名称</param>
        /// <returns>string</returns>
        public string GetXmlTextNode(XmlElement xe, string tagName)
        {
            string tagValue = "";
            XmlNode elemList = xe.SelectSingleNode(tagName);
            if (elemList != null)
            {
                if (elemList.FirstChild != null)
                {
                    tagValue = elemList.FirstChild.Value;
                }
            }
            return tagValue;
        }

        /// <summary>
        /// 获取类里的XmlDocument一个特定XmlElement的子Text节点内容
        /// </summary>
        /// <param name='xe'>节点</param>
        /// <param name='tagName'>子节点名称</param>
        /// <param name='index'>节点数组下标值</param>
        /// <returns>string</returns>
        public string GetXmlText(XmlElement xe, string tagName, int index)
        {
            string tagValue = "";
            XmlNodeList elemList = xe.SelectNodes(tagName);
            if (elemList != null)
            {
                if ((elemList.Count) > index)
                {
                    XmlNode refChild = elemList[index];
                    if (refChild.FirstChild != null)
                    {
                        tagValue = refChild.FirstChild.Value;
                    }
                }
            }
            return tagValue;
        }

        /// <summary>
        /// 获取类里的XmlDocument一个特定XmlElement的子Text节点内容(根节点作节点)
        /// </summary>
        /// <param name='tagName'>子节点名称</param>
        /// <param name='index'>节点数组下标值</param>
        /// <returns>string</returns>
        public string GetXmlText(string tagName, int index)
        {
            XmlElement ParentNode = (XmlElement)xmlRoot;
            return GetXmlText(ParentNode, tagName, index);
        }

        /// <summary>
        /// 获取类里的XmlDocument一个特定XmlElement的子Text节点内容(根节点作节点)
        /// </summary>
        /// <param name='tagName'>子节点名称</param>
        /// <returns>string</returns>
        public string GetXmlTextNode(string tagName)
        {
            XmlElement ParentNode = (XmlElement)xmlRoot;
            return GetXmlTextNode(ParentNode, tagName);
        }

        /// <summary>
        /// 获取类里的XmlDocument一个特定XmlElement的所有有特定属性的节点的属性的最大值（属性值必须是INT型）
        /// </summary>
        /// <param name='parentNode'>父节点</param>
        /// <param name='tagName'>节点名称</param>
        /// <param name='AttributeName'>节点属性名称</param>
        /// <returns>int</returns>
        public int GetMaxValueByTagNameAndAttribute(XmlElement parentNode, string tagName, string AttributeName)
        {
            int MaxTagValue = 1;
            XmlNodeList elemList = parentNode.SelectNodes(tagName);
            if (elemList != null)
            {
                foreach (XmlNode xn in elemList)
                {
                    if (xn.NodeType == XmlNodeType.Element)
                    {
                        XmlElement xel = (XmlElement)xn;
                        if (xel.HasAttribute(AttributeName))
                        {
                            int iValue = FormChecker.IsNumeric(xel.GetAttribute(AttributeName), 0);
                            if (iValue >= MaxTagValue)
                            {
                                MaxTagValue = iValue + 1;
                            }
                        }
                    }
                }
            }
            return MaxTagValue;
        }

        /// <summary>
        /// 获取类里的XmlDocument一个特定XmlElement的所有有特定属性的节点的属性的最大值（属性值必须是INT型,根节点作节点）
        /// </summary>
        /// <param name='tagName'>节点名称</param>
        /// <param name='AttributeName'>节点属性名称</param>
        /// <returns>int</returns>
        public int GetMaxValueByTagNameAndAttribute(string tagName, string AttributeName)
        {
            XmlElement ParentNode = (XmlElement)xmlRoot;
            return GetMaxValueByTagNameAndAttribute(ParentNode, tagName, AttributeName);
        }

        /// <summary>
        /// 判断类里的XmlDocument一个特定XmlElement是否存在特定节点
        /// </summary>
        /// <param name='xe'>节点</param>
        /// <param name='tagName'>节点名称</param>
        /// <returns>int</returns>
        public bool HasAttribute(XmlElement xe, string tagName)
        {
            return xe.HasAttribute(tagName);
        }
        /// <summary>
        /// 获取特定XmlElement的节点值
        /// </summary>
        /// <param name='xe'>节点</param>
        /// <param name='tagName'>节点名称</param>
        /// <returns>string</returns>
        public string GetXmlCDataNode(XmlElement xe, string tagName)
        {
            string tagValue = "";
            XmlNode elemList = xe.SelectSingleNode(tagName);
            if (elemList != null)
            {
                if (elemList.FirstChild != null)
                {
                    tagValue = elemList.FirstChild.Value;
                }
            }
            return tagValue;
        }

        /// <summary>
        /// 获取根节点下特定XmlElement的节点值
        /// </summary>
        /// <param name='itemName'>节点名</param>
        /// <param name='tagName'>节点属性名称</param>
        /// <param name='tagValue'>节点属性值</param>
        /// <returns>string</returns>
        public string GetXmlTextNodeByAttribute(string itemName, string tagName, string tagValue)
        {
            string value = "";
            XmlElement xe = GetXmlNodeByTagNameAndAttribute(itemName, tagName, tagValue, false);
            if (xe != null)
            {
                value = GetXmlCDataNode(xe, "value");

            }
            if (value == "")
            {
                value = tagValue;
            }
            return value;
        }
    }

转载于:https://www.cnblogs.com/wlwjc/articles/wally.html

C#个人珍藏基础类库分享 — 7、Xml处理帮助类XmlHelper
MarcoPro的博客
12-21 1987
做.NET开发的同学，一套简单易用的基础类库是必不可少的，这里把我混迹C#圈子十余载珍藏的类库分享出来，希望能够给刚踏入开发门槛的朋友一些帮助。C#个人珍藏基础类库分享 — 1、通用缓存帮助类CacheHelper。C#个人珍藏基础类库分享 — 3、目录、文件帮助类FileHelper。C#个人珍藏基础类库分享 — 6、数据库处理帮助类SqlHelper。C#个人珍藏基础类库分享 — 7、Xml处理帮助类XmlHelper。C#个人珍藏基础类库分享 — 8、通用工具帮助类ToolHelper。
C#实现XML操作帮助类
12-14
C#帮助类（Helper class）是一种用于封装常用功能的类。它通常包含一组静态方法，这些方法能够执行特定的任务或提供通用的功能。帮助类的目的是为了提高代码的可重用性和可维护性，避免重复编写相似的功能代码。 ...
C#XmlHelper帮助类操作Xml文档的通用方法汇总
zls365365的博客
04-11 700
前言　　该篇文章主要总结的是自己平时工作中使用频率比较高的Xml文档操作的一些常用方法和收集网上写的比较好的一些通用Xml文档操作的方法（主要包括Xml序列化和反序列化，Xml文件读取，Xml文档节点内容增删改的一些通过方法）。当然可能还有很多方法会漏了，假如各位同学好的方法可以在文末留言，我会统一收集起来。C#XML基础入门C# XML基础入门（XML文件内容增删改查清...
C#帮助工具类整理--FileHelper、XmlHelper、ToolHelper
Zhaof_Notes
04-03 2339
C#帮助工具类整理
C#底层库--XML配置参数读写辅助类（推荐阅读）
花北城的博客
02-23 1433
本文介绍XML配置文件读写，将程序开发中一些可调节变化的参数，以文件形式存储在程序目录中，用户可以自行配置调节，而不需要改动代码。是程序开发中使用频率最高的底层库，所以我强力推荐。 用途：可以实现 数据库连接参数、邮件服务器参数、软件功能参数、服务器连接参数等可以配置。
微信公众号开发：xml消息体转为Map集合以及对象转化为xml帮助类
一枝夏雨荷的博客
08-09 1513
/** * xml转为Map集合 * @author Administrator * */ public class MessageUtil { public static Map<String, String> xmlToMap(HttpServletRequest request){ Map<String, String> map = new HashMap<St
C# XmlHelper
熊思雨的博客
03-01 3723
一、需求 对于小量数据在本地存储，可能会用到 xml 文件，下面的 xmlhelper.cs 代码出处好像是微软的，不太清楚，百度搜的很多帖子只是贴出了 xmlhelper 代码，千篇一律，全是贴了代码就什么都没有了，在此我将 xmlhelper 常用的 增、删、改、查 做一个教程。 二、XmlHelper using System; using System.Collections; using System.Data; using System.IO; using System.Te....
C#xml操作帮助类
除却猩猩不是猿
03-15 2392
using System.Xml; using System.Data; namespace myhelper { /// /// Xml的操作公共类 /// public class XmlHelper { #region 字段定义 /// /// XML文件的物理路径 //
XML 测试用例分类Variants参数
蚂蚁小兵
09-20 2396
XML 测试用例分类Variants参数
xml系列篇之xml解析
m0_74315688的博客
06-19 1733
欢迎关注辉辉，持续更新中~
xml生成java类在线
牛肉胡辣汤
02-24 2425
XML to Java Class Generator是一个非常有用的在线工具，它可以帮助我们快速生成Java类代码来处理XML数据。通过简单的复制粘贴，我们可以获得可读性和维护性良好的Java类，从而提高开发效率。这个工具在处理小到中等规模的XML文件时非常适用，并且提供了一些自定义选项来满足不同的需求。它解决了手动编写Java类以解析XML的繁琐问题，让我们能够更专注于业务逻辑的实现。
c#操作xml帮助类分享(xml增删改查)
12-31
代码如下:using System;using System.Collections;using System.Xml;...#region 创建Xml文档/// <summary>/// 创建一个带有根节点的Xml文件/// </summary>/// ”FileName”>Xml文件名称</param>/// <param
XmlHelper_xml帮助类_
09-30
XmlHelper 是一个专门为处理XML文档而设计的辅助类，它提供了方便的方法来创建、操作和管理XML文件。在本文中，我们将深入探讨XML基础、XmlHelper类的主要功能以及如何使用这些功能来处理XML数据。 首先，XML...
xml帮助类,xml,C#
05-04
XML帮助类通常是为了简化XML文档的操作而创建的辅助类，它们提供了诸如读取、写入、解析和操作XML文档的便利方法。在C#中，有几个内置的类库可以帮助我们处理XML，例如`System.Xml`命名空间下的`XmlDocument`、`...
pngquant-2.12.5-1.el8.tar.gz
09-10
# 适用操作系统：Centos8 #Step1、解压 tar -zxvf xxx.el8.tar.gz #Step2、进入解压后的目录，执行安装 sudo rpm -ivh *.rpm
poezio-0.13.1-3.el8.tar.gz
09-10
# 适用操作系统：Centos8 #Step1、解压 tar -zxvf xxx.el8.tar.gz #Step2、进入解压后的目录，执行安装 sudo rpm -ivh *.rpm
Excel表格通用模板：装修装潢预算表(实用).xls
最新发布
09-10
Excel表格通用模板：装修装潢预算表(实用).xls
portreserve-0.0.5-19.el8.tar.gz
09-10
# 适用操作系统：Centos8 #Step1、解压 tar -zxvf xxx.el8.tar.gz #Step2、进入解压后的目录，执行安装 sudo rpm -ivh *.rpm
最新计算机科学与技术毕业生自我鉴定-毕业自我鉴定计算机(6篇).docx
09-10
最新计算机科学与技术毕业生自我鉴定-毕业自我鉴定计算机(6篇).docx
XmlHelper：简化XML操作的实用帮助类
资源摘要信息:" XmlHelper_xml帮助类 " XmlHelper是一个用于简化XML文件操作的C#帮助类，它封装了一系列基础的XML操作方法，目的是为了方便开发人员快速实现创建XML文件、增加节点、获取节点值、删除节点等操作，而...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值