C#手工解析XML

唉，已经好久没逛园子了，今天没事来写一点

前段时间遇到个情况，由于引用的程序集（为XNA wp的）所依赖的System.XML的版本不一样，导致无法使用系统的XML解析。本来想从网上找个自己实现XML算法的程序，还真不好找，不过也是，谁没事去写这个东西。

没办法，就自己写了，当然，这个比较简单，因为我所使用的就这个简单功能，有需要的朋友可以看看，也就免得以后不好找了，根据需要可以自由扩充。

 

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

namespace GameEngine.XNA
{
    /// <summary>
    /// XML解析器
    /// </summary>
    public class XmlParser
    {
        /// <summary>
        /// 加载XML
        /// </summary>
        /// <param name="xml"></param>
        public void Load(string xml)
        {
            InnerXML = xml;

            Root = new XmlNode();
            Root._internalXML = InnerXML;
            Root.Parser();
        }
        public string InnerXML { get; set; }
        /// <summary>
        /// 根节点
        /// </summary>
        public XmlNode Root { get; set; }
    }

    /// <summary>
    /// XML属性
    /// </summary>
    public class XmlAttribute
    {
        public string Name { get; set; }
        public string Value { get; set; }
        internal string _internalXML;
        internal void Parser()
        {
            string[] exp = _internalXML.Split('=');
            Name = exp[0];
            Value = exp[1].Substring(1, exp[1].Length - 2);
        }
    }

    /// <summary>
    /// XML节点
    /// </summary>
    public class XmlNode
    {

        public string Name { get; set; }
        public string Value { get; set; }
        /// <summary>
        /// 子节点
        /// </summary>
        public List<XmlNode> Nodes { get; set; }
        public List<XmlAttribute> Attributes { get; set; }
        public string InnerXML { get; set; }
        internal string _internalXML;
        private int start;
        private int end;
        internal int current;

        public XmlNode()
        {
            Nodes = new List<XmlNode>();
            Attributes = new List<XmlAttribute>();
        }

        private void ParserXML()
        {
            InnerXML = InternalParserXML();
        }
        private string InternalParserXML()
        {
            StringBuilder builder = new StringBuilder();
            builder.Append("<");
            builder.Append(Name);

            for (int i = 0; i < Attributes.Count; i++)
            {
                builder.Append(" ");
                builder.Append(Attributes[i].Name);
                builder.Append("=");
                builder.Append("\"");
                builder.Append(Attributes[i].Value);
                builder.Append("\"");
            }


            builder.Append(">");
            for (int i = 0; i < Nodes.Count; i++)
            {
                builder.Append(Nodes[i].InternalParserXML());
            }
            builder.Append("</");
            builder.Append(Name);
            builder.Append(">");
            return builder.ToString();
        }

        internal void Parser()
        {
            NodeType type = GetCurrentNodeType();

            ReadBeginBlock();
            while (true)
            {
                type = GetCurrentNodeType();
                if (type == NodeType.BeginNode)
                {
                    XmlNode node = new XmlNode();
                    node._internalXML = _internalXML;//.Substring(current, _internalXML.Length - current);
                    node.start = current;
                    node.current = current;
                    node.Parser();
                    Nodes.Add(node);
                    current = node.end;
                }
                else if (type == NodeType.Text)
                {
                    ReadValue();
                }
                else if (type == NodeType.EndNode)
                {
                    ReadEndBlock();
                    break;
                }
            }
          
        }

        public enum NodeType
        {
            BeginNode,
            EndNode,
            Text
        }
        private NodeType GetCurrentNodeType()
        {
            if (_internalXML[current] == '<' && _internalXML[current + 1] != '/')
            {
                return NodeType.BeginNode;
            }
            else if (_internalXML[current] == '<' && _internalXML[current + 1] == '/')
            {
                return NodeType.EndNode;
            }
            else if (_internalXML[current] != '<')
            {
                return NodeType.Text;
            }

            throw new Exception();
        }

        private void ReadBeginBlock()
        {
            current++;
            int posend = _internalXML.IndexOf('>',start);
            
            string nodeinner = _internalXML.Substring(current, posend - current);

            string [] atts = nodeinner.Split(' ');

            Name = atts[0];

            if (atts.Length > 1)
            {
                for (int i = 1; i < atts.Length; i++)
                {
                    XmlAttribute att = new XmlAttribute();
                    att._internalXML = atts[i];
                    att.Parser();
                    Attributes.Add(att);
                }
            }

            posend++;
            current = posend;
        }



        private void ReadValue()
        {
            int posend = _internalXML.IndexOf('<', current);
            Value = _internalXML.Substring(current, posend - current);
            current = posend;
        }
        private void ReadEndBlock()
        {
            int posend = _internalXML.IndexOf('>', current);
            posend++;
            current = posend;
            InnerXML = _internalXML.Substring(start, current-start);
            end = current;
        }

    }
}