C#怎么解析XML，在线等

Question

怎么解析这样的XML
<?xml version="1.0" encoding="utf-16"?>
<age>2022</age>
最好是用XmlDocument的方法，加上注释
<?xml version="1.0" encoding="utf-16"?>
<student>
  <name>张三</name>
  <age>22</age>
</student>这个又怎么解析那。
最好加上注释。

Answer 1

msdn上有例子啊，网上搜一下也比在这里问快多了吧。

Answer 2

m_xmlDoc = new XmlDocument();
                    m_xmlDoc.Load(m_sXmlPath);//加载文档

Answer 3

1.先定义个类 XmlDocument xml = new XmlDocument();
  xml.LoadXml(strXML);//strXML你要解析的XML；
  string strKey=“//student/name”；//定义你要取得字段的Key，也就是xml层关系
2.取得XmlNodeList：
 XmlNodeList list=xml.DocumentElement.SelectNodes(strKey);
 再循环XmlNodeList 的每个节点（XmlNode类）
 取得XmlNode类的InnerText值，也许就是你要的值，如果不是的话可以取得XmlNode.ChildNodes
 顺序就是这样。
 如果层比较深的话，也可以嵌套的定义XmlDocument再LoadXml(ChildNodes[index].OuterXml),继续解析就是了。
如果不懂得到XmlNodeList，监视下这个，看看他的结构就是了。

Answer 4

XmlDocument XML_Doc = new XMLDocument();//实例化XMLDoc
XML_Doc.Load(Path);//加载XML
XmlNode nameNode = XML_Doc.SelectSingleNode("/student/name");//使用xPath定位查找Node节点  其实这里不要疑惑 xPath就是一个名词  就相当于一个地图，你告诉他先找到Student再找name 就是这样
string name_Str = nameNode.InnerText;//取出Node节点里的值

Answer 5

XmlDocument xmlDoc = new XmlDocument();
xmlDoc.Load(path);
XmlNode root = xmlDoc.SelectSingleNode("student");

Answer 6

XmlDocument doc = new XmlDocument();
doc.load(filepath);
XmlNode root = doc.SelectSingleNode("age"); //根节点
root.InnerText 就是2022XmlDocument doc = new XmlDocument();
doc.load(filepath);
第一种方法
XmlNode root = doc.SelectSingleNode("student"); //根节点
root.chileren[i] 就是节点（student）下的第i个子节点。
要想取第i个子节点的值，直接root.chileren[i].InnerText就行第二种方法
XmlNodeList root = doc.SelectNodes("student");
root 就是节点（student）下所有子节点的集合。
要想取第i个子节点的值
forearch（XmlNode xn in root）
{
    xn.InnerText 就是子节点的值
}

Answer 7

看看这段代码：
XmlDocument xml = new XmlDocument();
string strxml = "<student><name>张三</name><age>22</age></student>";
xml.LoadXml(strxml);
XmlNodeList NodeList = xml.SelectNodes("//student/name");//层关系strKey
foreach (XmlNode item in NodeList)
{
xml = new XmlDocument();
string aaa = item.InnerText;//看看是不是你要的值如果不是继续下面的操作；
//xml.LoadXml(item.OuterXml);
//XmlNodeList CNodeList = xml.SelectNodes(【新定义的strKey】);

}

Answer 8

就你给出的xml而言可以用这样的方式；
XmlDocument XmlDoc = new XmlDocument（）
XmlDoc.LoadXml(xmlStr);
string Age = XmlDoc.SelectSingleNode("./student/age").InnerText;

Answer 9

XmlDocument doc = new XmlDocument(); //实例化一个 XmlDocument 
doc.load(filepath); //加载XML文件

Answer 10

要详细的话..我有封装的类读写都很自由..怕你没时间搞明白/// <summary>
    /// XML文档读写
    /// </summary>
    public class XMLWR:IDisposable
    {
        #region 内部变量        //文档
        XmlDocument m_xmlDoc = null;        //文档路径
        string m_sXmlPath = "";        #endregion        #region 类初始化        #region 属性        /// <summary>
        /// 判断节点是否符合条件的委托
        /// </summary>
        /// <param name="xn"></param>
        /// <returns></returns>
        public delegate bool delegateCheckNode(XmlNode xn);              /// <summary>
        /// XML文档
        /// </summary>
        public XmlDocument XmlDoc
        {
            get 
            {
                if (m_xmlDoc == null)
                {
                    if (string.IsNullOrEmpty(m_sXmlPath))
                        throw new Exception("请先设置XML文档路径！");
                    m_xmlDoc = new XmlDocument();
                    m_xmlDoc.Load(m_sXmlPath);//加载文档
                }
                return m_xmlDoc;
            }
            set
            {
                m_xmlDoc = value;
            }
        }        /// <summary>
        /// 文档路径
        /// </summary>
        public string XmlPath
        {
            get { return m_sXmlPath; }
            set
            {
                m_sXmlPath = value; 
                
                m_xmlDoc = null;//重置文档
            }
        }        #endregion
        #region 构造函数        /// <summary>
        /// XML文档读取器
        /// </summary>
        public XMLWR()
        { }        /// <summary>
        /// XML文档读取器
        /// </summary>
        /// <param name="Xml_Path">XML文档路径</param>
        public XMLWR(string Xml_Path)
        {
            m_sXmlPath = Xml_Path;
        }        #endregion
        #endregion        #region 函数        #region 内部函数
        /// <summary>
        /// 关闭
        /// </summary>
        private void Close()
        {
            if (XmlDoc != null)
            {
                XmlDoc.Save(XmlPath);
                XmlDoc = null;                
            }
        }
                /// <summary>
        /// 遍历所有节点
        /// </summary>
        /// <param name="xnList"></param>
        /// <param name="delcn"></param>
        protected void checkAllNode(List<XmlNode> xnList, delegateCheckNode delcn, XmlNode xn)
        {            
            //递归
            if (xn.HasChildNodes)
            {
                foreach (XmlNode cxn in xn.ChildNodes)
                {
                    if (delcn != null && delcn(cxn)) //委托不为空且条件符合
                        xnList.Add(cxn);                    checkAllNode(xnList, delcn, cxn);//如果有子节点则遍历子节点
                }
            }
        }        /// <summary>
        /// 获取节点通过委托
        /// </summary>
        /// <param name="delcn"></param>
        /// <param name="xn"></param>
        /// <returns></returns>
        protected XmlNode getXmlNodeByDelegate(delegateCheckNode delcn, XmlNode xn)
        {
            if (delcn != null && delcn(xn)) //委托不为空且条件符合
                        return xn;            //递归
            if (xn.HasChildNodes)
            {
                foreach (XmlNode cxn in xn.ChildNodes)
                {                    
                    XmlNode ccxn= getXmlNodeByDelegate(delcn, cxn);//如果有子节点则遍历子节点
                    if (ccxn != null) return ccxn;
                }
            }            return null;
        }
        #endregion        #region 公共函数        public void LoadXmlString(string xmlString)
        {
            m_xmlDoc = new XmlDocument();
            m_xmlDoc.LoadXml(xmlString);
        }
        /// <summary>
        /// 通过委托获取单个节点
        /// </summary>
        /// <param name="delcn">获取节点的委托</param>
        /// <returns></returns>
        public XmlNode GetNodeByDelegate(delegateCheckNode delcn)
        {
            //循环所有顶级节点
            foreach (XmlNode xn in XmlDoc.ChildNodes)
            {
                if (delcn != null && delcn(xn)) //委托不为空且条件符合
                    return xn;                if (xn.HasChildNodes)
                {
                    XmlNode cxn = getXmlNodeByDelegate(delcn, xn);//如果有子节点则遍历子节点
                    if (cxn != null) return cxn;
                }
            }
            return null;
        }        /// <summary>
        /// 查找所有符合条件的节点
        /// </summary>
        /// <param name="delcn">条件委托</param>
        /// <returns></returns>
        public List<XmlNode> getNodeListByDelegate(delegateCheckNode delcn)
        {
            List<XmlNode> xnList = new List<XmlNode>();            //循环所有顶级节点
            foreach (XmlNode xn in XmlDoc.ChildNodes)
            {
                if (delcn != null && delcn(xn)) //委托不为空且条件符合
                    xnList.Add(xn);
                if (xn.HasChildNodes)
                {
                    checkAllNode(xnList, delcn, xn);//如果有子节点则遍历子节点
                }
            }            return xnList;        }
                /// <summary>
        /// 通过路径获取节点
        /// </summary>
        /// <param name="nodePath">节点路径（如：application/appsetting）</param>
        /// <returns></returns>
        public XmlNode GetNodeByPath(string nodePath)
        {
            if (string.IsNullOrEmpty(nodePath)) throw new Exception("节点的路径不可为空！");            //通过路径查得节点
            XmlNode xn = XmlDoc.SelectSingleNode(nodePath);            return xn;
        }        /// <summary>
        /// 通过节点名称读取其值
        /// </summary>
        /// <param name="nodePath">节点路径（如：application/appsetting）</param>
        /// <returns></returns>
        public string ReadValueByPath(string nodePath)
        {
            if (string.IsNullOrEmpty(nodePath)) throw new Exception("节点的路径不可为空！");            XmlNode xn = GetNodeByPath(nodePath);//通过路径获取节点            if (xn != null) return xn.Value;            return string.Empty;//返回空值
        }        /// <summary>
        /// 通过属读取值
        /// </summary>
        /// <param name="AttributeName">属性名</param>
        /// <param name="AttributeValue">属性值</param>
        /// <returns></returns>
        public string ReadValueByAttribute(string AttributeName, string AttributeValue)
        {            XmlNode xn = GetNodeByAttribute(AttributeName, AttributeValue);//通过属性获取节点            if (xn != null) //存在此节点
                return xn.Value;            return string.Empty;//返回空值
        }        /// <summary>
        /// 通过属性获取节点
        /// </summary>
        /// <param name="AttributeName">属性名</param>
        /// <param name="AttributeValue">属性值</param>
        /// <returns></returns>
        public XmlNode GetNodeByAttribute(string AttributeName, string AttributeValue)
        {
            if (string.IsNullOrEmpty(AttributeName)) throw new Exception("节点的属性名不可为空！");            //新建委托
            delegateCheckNode delcn = new delegateCheckNode(delegate(XmlNode xn)
            {
                return (xn.Attributes != null && xn.Attributes[AttributeName] != null && xn.Attributes[AttributeName].Value == AttributeValue);
            });            return GetNodeByDelegate(delcn);//通过委托获取节点
        }        /// <summary>
        /// 获取所有属性符合条件的节点集合
        /// </summary>
        /// <param name="AttributeName">属性名</param>
        /// <param name="AttributeValue">属性值</param>
        /// <returns></returns>
        public List<XmlNode> GetNodeListByAttribute(string AttributeName, string AttributeValue)
        {
            if (string.IsNullOrEmpty(AttributeName)) throw new Exception("节点的属性名不可为空！");            //新建委托
            delegateCheckNode delcn = new delegateCheckNode(delegate(XmlNode xn)
            {
                return (xn.Attributes != null && xn.Attributes[AttributeName] != null && xn.Attributes[AttributeName].Value == AttributeValue);
            });            return getNodeListByDelegate(delcn);//返回所有符合条件的节点
        }        /// <summary>
        /// 通过节点类型获取所有节点集合
        /// </summary>
        /// <param name="xnType">节点类型</param>
        /// <returns></returns>
        public List<XmlNode> GetNodeListByNodeType(XmlNodeType xnType)
        {
            //新建委托
            delegateCheckNode delcn = new delegateCheckNode(delegate(XmlNode xn)
            {
                return xn.NodeType == xnType;
            });            return getNodeListByDelegate(delcn);//返回所有符合条件的节点
        }
        /// <summary>
        /// 将XML全加载到集合中
        /// </summary>
        /// <param name="bToLower"></param>
        /// <returns></returns>
        public Dictionary<string, string> TurnXmlToDictionary(bool bToLower)
        {
            Dictionary<string, string> dic = new Dictionary<string, string>();
            foreach (XmlNode xn in XmlDoc.ChildNodes)
            {
                initChildPath(xn, "", dic, bToLower);
            }
            return dic;
        }        

Answer 11

/// <summary>
        /// 将XML全加载到集合中
        /// </summary>
        /// <param name="bToLower"></param>
        /// <returns></returns>
        public Dictionary<string, string> TurnXmlToDictionary(XmlNode RootXn,bool bToLower)
        {
            Dictionary<string, string> dic = new Dictionary<string, string>();            initChildPath(RootXn, "", dic, bToLower);            foreach (XmlNode xn in RootXn.ChildNodes)
            {
                initChildPath(xn, (bToLower ? RootXn.Name.ToLower() : RootXn.Name), dic, bToLower);
            }            return dic;
        }        private void initChildPath(XmlNode xn, string parentPath, Dictionary<string, string> _xmlDictionary, bool bToLower)
        {
            parentPath += (string.IsNullOrEmpty(parentPath) ? "" : "/") + (bToLower ? xn.Name.ToLower() : xn.Name);            if (xn.Attributes != null && xn.Attributes.Count > 0)
            {
                foreach (XmlAttribute xa in xn.Attributes)
                {
                    string xapath = parentPath + "/" + (bToLower ? xa.Name.ToLower() : xa.Name);
                    if (!_xmlDictionary.ContainsKey(xapath))
                    {
                        _xmlDictionary.Add(xapath, xa.Value);
                    }
                }
            }            if (xn.NodeType == XmlNodeType.Element && !string.IsNullOrEmpty(xn.InnerText))
            {
                string xtpath = parentPath + "/" + (bToLower ? "innertext" : "InnerText");
                _xmlDictionary.Add(xtpath, xn.InnerText);
            }            if (xn.HasChildNodes)
            {
                foreach (XmlNode cxn in xn.ChildNodes)
                {
                    initChildPath(cxn, parentPath, _xmlDictionary,bToLower);
                }
            }
        }        /// <summary>
        /// 获取父节点下子节点值集合
        /// </summary>
        /// <param name="prefix"></param>
        /// <param name="parentKey"></param>
        /// <returns></returns>
        public static List<string> GetChildrenKeys(Dictionary<string, string> _xmlDictionary, string parentKey, string onlyAttribute, bool bToLower)
        {
            if (bToLower)
            {
                onlyAttribute = onlyAttribute.ToLower().Trim();
                parentKey = parentKey.ToLower();
            }            List<string> children = new List<string>();
            foreach (string key in _xmlDictionary.Keys)
            {
                if ((bToLower && key.ToLower().StartsWith(parentKey) && key.ToLower().EndsWith("/" + onlyAttribute)) || (!bToLower && key.StartsWith(parentKey) && key.EndsWith("/" + onlyAttribute)))
                {
                    string midpath = bToLower ? key.ToLower().Substring(parentKey.Length) : key.Substring(parentKey.Length);
                    int lastat = bToLower ? midpath.ToLower().LastIndexOf("/" + onlyAttribute.ToLower()) : midpath.LastIndexOf("/" + onlyAttribute);
                    int firstsplit = midpath.IndexOf("/", midpath.IndexOf("/") + 1);
                    //检　查是否是父节点的一级子节点，
                    if (lastat != -1 && firstsplit == lastat)
                    {
                        children.Add(parentKey + midpath.Substring(0, lastat));
                    }
                }            }            return children;
        }
        /// <summary>
        /// 保存文档
        /// </summary>
        public void Save()
        {
            XmlDoc.Save(XmlPath);
        }
        /// <summary>
        /// 保存文档
        /// </summary>
        /// <param name="fileName">要保存的路径</param>
        public void Save(string fileName)
        {
            XmlDoc.Save(fileName);
        }        /// <summary>
        /// 生成新的文档
        /// </summary>
        public void CreateNewXML()
        {
            XmlDoc = new XmlDocument();            //生成根节点
            XmlNode xn = XmlDoc.CreateNode(XmlNodeType.XmlDeclaration, "xml", "");
            xn.Value = "version=\"1.0\" encoding=\"utf-8\"";            XmlDoc.AppendChild(xn);
        }        /// <summary>
        /// 生成新的文档
        /// </summary>
        /// <param name="DeclarationValue">XML声明（如：version="1.0" encoding="utf-8"）</param>
        public void CreateNewXML(string DeclarationValue)
        {
            XmlDoc = new XmlDocument();            //生成根节点
            XmlNode xn = XmlDoc.CreateNode(XmlNodeType.XmlDeclaration, "xml", "");
            xn.Value = DeclarationValue;            XmlDoc.AppendChild(xn);
        }        /// <summary>
        /// 生成新节点(此方法生成的节点未保存到文档中)
        /// </summary>
        /// <param name="xnType">节点类型</param>
        /// <param name="name">节点名称</param>
        public XmlNode CreateNewNode(XmlNodeType xnType, string name)
        {
            XmlNode xn = XmlDoc.CreateNode(xnType, name, "");
            return xn;
        }        /// <summary>
        /// 在指定的父节点中生成一个子节点
        /// </summary>
        /// <param name="parentNode">父节点(如果为NULL，则此节点为根节点)</param>
        /// <param name="xnType">子节点类型</param>
        /// <param name="name">子节点名称</param>
        /// <returns>返回生成的节点</returns>
        public XmlNode CreateNewNode(XmlNode parentNode, XmlNodeType xnType, string name)
        {
            if (parentNode != null)
            {
                //生成子节点
                XmlNode xn = XmlDoc.CreateNode(xnType, name, "");                //将子节点添加到父节点下
                parentNode.AppendChild(xn);                return xn;
            }
            else
            {
                //生成子节点
                XmlNode xn = XmlDoc.CreateNode(xnType, name, "");                //添加到根节点
                XmlDoc.AppendChild(xn);                return xn;
            }
        }        /// <summary>
        /// 在指定的父节点中生成一个子节点
        /// </summary>
        /// <param name="parentNode">父节点(如果为NULL，则此节点为根节点)</param>
        /// <param name="xnType">子节点类型</param>
        /// <param name="name">子节点名称</param>
        /// <param name="attributes">此节点的属性</param>
        /// <returns></returns>
        public XmlNode CreateNewNode(XmlNode parentNode, XmlNodeType xnType, string name, Dictionary<string, string> attributes)
        {
            //生成节点
            XmlNode xn = CreateNewNode(parentNode, xnType, name);            WriteNodeAttributes(xn, attributes);//写属性            return xn;
        }        /// <summary>
        /// 给节点写入属性
        /// </summary>
        /// <param name="xn">当前节点</param>
        /// <param name="attributeName">属性名</param>
        /// <param name="attributeValue">属性值</param>
        /// <returns></returns>
        public XmlNode WriteNodeAttribute(XmlNode xn, string attributeName, string attributeValue)
        {
            if (xn.Attributes[attributeName] != null)//如果属性不存在
            {
                xn.Attributes[attributeName].Value = attributeValue;//添加属性
            }
            else
            {
                //如果不存在属性则新增
                XmlAttribute xa = XmlDoc.CreateAttribute(attributeName);
                xa.Value = attributeValue;
                xn.Attributes.Append(xa);
            }
            return xn;
        }        /// <summary>
        /// 给节点添加属性
        /// </summary>
        /// <param name="xn"></param>
        /// <param name="attributes"></param>
        /// <returns></returns>
        public XmlNode WriteNodeAttributes(XmlNode xn, Dictionary<string, string> attributes)
        {
            //**********************
            //如果属性不为空，添加属性
            //**********************
            if (attributes != null)
            {
                foreach (string key in attributes.Keys)
                {
                    WriteNodeAttribute(xn, key, attributes[key]);
                }
            }            return xn;
        }
       

Answer 12

 /// <summary>
        /// 添加节点通过你节点路径
        /// </summary>
        /// <param name="parentPath">父节点路径（如：application/appsetting）</param>
        /// <param name="xnType">子节点类型</param>
        /// <param name="name">子节点名</param>
        /// <returns></returns>
        public XmlNode CreateNewNodeByParentPath(string parentPath, XmlNodeType xnType, string name)
        {
            //通过节点路径获取节点
            XmlNode parentNode = GetNodeByPath(parentPath);            if (parentNode == null) throw new Exception("获取父节点错误，确保此节点是否在存！");            XmlNode xn = CreateNewNode(xnType, name);//生成节点            parentNode.AppendChild(xn);//将节点添加至父节点下            return xn;
        }        /// <summary>
        /// 通过节点路径更改值
        /// </summary>
        /// <param name="nodePath">节点路径（如：application/appsetting）</param>
        /// <param name="value">节点的值</param>
        public void SetValueByPath(string nodePath, string value)
        {
            //通过路径获取节点
            XmlNode xn = GetNodeByPath(nodePath);            if (xn != null)
            {
                //修改节点的值
                xn.Value = value;
            }
            else
            {
                throw new Exception("获取节点失败，请确保节点路径正确！");
            }
        }        /// <summary>
        /// 通过节点路径设置属性值
        /// </summary>
        /// <param name="AttributeName"></param>
        /// <param name="AttributeValue"></param>
        public void SetAttributeValue(string nodePath, string AttributeName, string AttributeValue)
        {
            //通过路径获取节点
            XmlNode xn = GetNodeByPath(nodePath);            if (xn != null)
            {
                //修改节点属性的值
                WriteNodeAttribute(xn, AttributeName, AttributeValue);
            }
            else
            {
                throw new Exception("获取节点失败，请确保节点路径正确！");
            }
        }        #endregion        #endregion        #region IDisposable 成员        public void Dispose()
        {
            XmlDoc = null;
            GC.Collect();
        }        #endregion
    }
附上我的网站:http://www.jiamaocode.com

Answer 13

很多方法都可行的，你可以用xmldocument+xpath，或者使用dataset.readxml，或者使用linq

Answer 14

在问一下，如果我的xml是在一个var的变量中怎么解析啊！
var a =“<?xml version="1.0" encoding="utf-16"?>
<age>22</age>”
谢谢了！

Answer 15

XmlDocument doc = new XmlDocument();
doc.Load(@"..\tree.xml");
Response.Write(doc.OuterXml);

Answer 16

<?xml version="1.0" encoding="utf-16"?>
<student>
  <name>张三</name>
  <age>22</age>
</student>我就对这段解析下，上面那个同理啦：
1。如果这个XML是存在一个String字符串中，那么操作如下：
   //创建 XMLDocuemnt
   XmlDocument xmlDoc = new XmlDocument();
  //然后载入这个字符串,假设这个字符串叫 xmlStr
   xmlDoc.LoadXml(xmlStr)
 //接着解析，先找出根节点
  XmlElement root = xmlDoc.DocumentElement;
 //验证根节点,取值
  if(root.Name == "student")
  {
    // 取出节点
    XmlNode nameNode = xmlDoc.SelectSingleNode("//student/name");
    XmlNode ageNode = xmlDoc.SelectSingleNode("//student/age");
    //取出节点的值，这里我用了个函数，下面有该函数的详细信息
    name = GetInnerText（nameNode ）；
     age = GetInnerText(ageNode);
  } 完成！
  以下是函数：
                public string GetInnerText(XmlNode node)
{
string result = "";
if(node != null && node.NodeType == XmlNodeType.Element)
{
result = node.InnerText;
}
return result;
}
 2,。如果XML存在一个文件中，那么Load的时候这样：
     string Ordr=@"C:\student.xml";
   XmlTextReader reader = new XmlTextReader(Ordr);
   XmlDocument lcXML_FILENAME = new XmlDocument();
   lcXML_FILENAME.Load(reader);
   reader.Close();

  其他的和1中的一样解析 希望这个是你想要的   
  

Answer 17

用 linq 啊，现成的东西干嘛不用

Answer 18

用了LINQ TO XML 以前的那些垃圾方法再也不想用了你去找C:\Program Files\Microsoft Visual Studio 9.0\Samples\2052\CSharpSamples.zip这个文件里面有个LinqSamples,打开运行后你能发现101个关于XML的语句,找到你要用的,复制出来改改就能用

Answer 19

我想请大家帮忙解决一个问题，我定义一个key属性
我要他自动增加，我现在取到值了，就是添加的时候怎么做了！