C# XmlReader

一个非常全面的XML解析类

using System;
using UnityEngine;
using System.Xml;
using System.Collections;

using UnityObject = UnityEngine.Object;
using SystemObject = System.Object;

using Fcm;

using LoadedTexts =
    System.Collections.Generic.Dictionary<
        System.String,
        System.String
    >;

public sealed class XmlReader
{
    public Boolean Open(string fileName)
    {
        Close();

        try
        {
            _Document = new XmlDocument();
            String xml_content = XmlContent(fileName);
            _Document.LoadXml(xml_content);
            XmlNodeList list = _Document.GetElementsByTagName("fcm");
            if (0 >= list.Count)
                return (false);
            _Root = list[0] as XmlElement;
        }
        catch (Exception)
        {
            return (false);
        }

        return (true);
    }

    public Int32 ConfigCount
    {
        get
        {
            try
            {
                if (null == _Root)
                    return (0);
                return (Int32.Parse(_Root.Attributes["count"].Value));
            }
            catch (Exception)
            {
                return (0);
            }
        }
    }

    public Boolean SeekConfig()
    {
        return (SeekConfig(0));
    }

    public Boolean SeekConfig(Int32 config_index)
    {
        if (null == _Document || null == _Root)
            return (false);

        String config_name = String.Format("CFG{0}", config_index);
        try
        {
            _CurrentConfig = _Root[config_name];
        }
        catch (Exception)
        {
            return (false);
        }

        return (true);
    }

    public Int32 RecordCount
    {
        get
        {
            try
            {
                if (null == _CurrentConfig)
                    return (0);
                return (Int32.Parse(_CurrentConfig.Attributes["count"].Value));
            }
            catch (Exception)
            {
                return (0);
            }
        }
    }

    public Boolean SeekRecord(Int32 record_index)
    {
        if (null == _Document || null == _Root || null == _CurrentConfig)
            return (false);

        String record_name = String.Format("RECORD{0}", record_index);
        try
        {
            _CurrentRecord = _CurrentConfig[record_name];
        }
        catch (Exception)
        {
            return (false);
        }

        return (true);
    }

    public Boolean SeekNextRecord()
    {
        if (null == _Document || null == _Root || null == _CurrentConfig)
            return (false);

        try
        {
            if (null == _CurrentRecords)
            {
                XmlNodeList nl = _CurrentConfig.ChildNodes;
                _CurrentRecords = nl.GetEnumerator();
            }
            if (!_CurrentRecords.MoveNext())
                return (false);
            _CurrentRecord = (XmlElement)_CurrentRecords.Current;
        }
        catch (Exception)
        {
            return (false);
        }

        return (true);
    }

    public String RecordString(String field_name)
    {
        return (RecordString(field_name, ""));
    }

    public String RecordString(String field_name, String def)
    {
        if (null == _CurrentRecord)
            return (def);

        try
        {

            XmlElement e = _CurrentRecord[field_name];
            if (null == e)
                return (def);

            return (e.InnerText);

        }
        catch (Exception)
        {

            return (def);
        }
    }

    public Int16 RecordInt16(String field_name)
    {
        return (RecordInt16(field_name, 0));
    }

    public Int16 RecordInt16(String field_name, Int16 def)
    {
        if (null == _CurrentRecord)
            return (0);

        String str = RecordString(field_name);
        try
        {
            Int16 v = Int16.Parse(str);
            return (v);
        }
        catch (Exception)
        {
            return (def);
        }
    }

    public Int32 RecordInt(String field_name)
    {
        return (RecordInt(field_name, 0));
    }

    public Int32 RecordInt(String field_name, Int32 def)
    {
        if (null == _CurrentRecord)
            return (0);

        String str = RecordString(field_name);
        try
        {
            Int32 v = Int32.Parse(str);
            return (v);
        }
        catch (Exception)
        {
            return (def);
        }
    }

    public Int64 RecordInt64(String field_name)
    {
        return (RecordInt64(field_name, 0));
    }

    public Int64 RecordInt64(String field_name, Int64 def)
    {
        if (null == _CurrentRecord)
            return (0);

        String str = RecordString(field_name);
        try
        {
            Int64 v = Int64.Parse(str);
            return (v);
        }
        catch (Exception)
        {
            return (def);
        }
    }

    public String[] RecordStringArray(String field_name)
    {
        return (RecordStringArray(field_name, ",", 0));
    }

    public String[] RecordStringArray(String field_name, Int32 match_count)
    {
        return (RecordStringArray(field_name, ",", match_count));
    }

    public String[] RecordStringArray(String field_name, String split)
    {
        return (RecordStringArray(field_name, split, 0));
    }

    public String[] RecordStringArray(String field_name, String split, Int32 match_count)
    {
        if (null == _CurrentRecord)
            return (new String[0]);

        String str = RecordString(field_name);

        String[] splits = str.Split(split.ToCharArray());
        Int32 split_count = splits.Length;

        if (0 < match_count && match_count != split_count)
            return (new String[0]);

        if (1 == split_count && 0 >= splits[0].Length)
            split_count = 0;

        try
        {
            String[] ar = new String[split_count];
            for (Int32 i = 0; i < split_count; i++)
                ar[i] = splits[i];
            return (ar);
        }
        catch (Exception)
        {
            return (new String[0]);
        }
    }

    public String[][] RecordStringArray2(String field_name, String split1, String split2)
    {
        if (null == _CurrentRecord)
            return (new String[0][]);

        String str = RecordString(field_name);

        String[] splits1 = str.Split(split1.ToCharArray());
        Int32 split_count1 = splits1.Length;

        if (1 == split_count1 && 0 >= splits1[0].Length)
            split_count1 = 0;

        try
        {
            String[][] ar = new String[split_count1][];
            for (Int32 i = 0; i < split_count1; i++)
            {
                String s = splits1[i];
                String[] splits2 = s.Split(split2.ToCharArray());
                Int32 split_count2 = splits2.Length;
                if (1 == split_count2 && 0 >= splits2[0].Length)
                    split_count2 = 0;
                ar[i] = new String[split_count2];
                for (Int32 j = 0; j < split_count2; j++)
                {
                    ar[i][j] = splits2[j];
                }
            }
            return (ar);

        }
        catch (Exception)
        {
            return (new String[0][]);
        }
    }

    public Int32[] RecordIntArray(String field_name)
    {
        return (RecordIntArray(field_name, ",", 0));
    }

    public Int32[] RecordIntArray(String field_name, Int32 match_count)
    {
        return (RecordIntArray(field_name, ",", match_count));
    }

    public Int32[] RecordIntArray(String field_name, String split)
    {
        return (RecordIntArray(field_name, split, 0));
    }

    public Int32[] RecordIntArray(String field_name, String split, Int32 match_count)
    {
        if (null == _CurrentRecord)
            return (new Int32[0]);

        String str = RecordString(field_name);

        String[] splits = str.Split(split.ToCharArray());
        Int32 split_count = splits.Length;

        if (0 < match_count && match_count != split_count)
            return (new Int32[0]);

        if (1 == split_count && 0 >= splits[0].Length)
            split_count = 0;

        try
        {
            Int32[] ar = new Int32[split_count];
            for (Int32 i = 0; i < split_count; i++)
                ar[i] = Int32.Parse(splits[i]);
            return (ar);
        }
        catch (Exception)
        {
            return (new Int32[0]);
        }
    }

    public Int32[][] RecordIntArray2(String field_name, String split1, String split2)
    {
        if (null == _CurrentRecord)
            return (new Int32[0][]);

        String str = RecordString(field_name);

        String[] splits1 = str.Split(split1.ToCharArray());
        Int32 split_count1 = splits1.Length;

        if (1 == split_count1 && 0 >= splits1[0].Length)
            split_count1 = 0;

        try
        {
            Int32[][] ar = new Int32[split_count1][];
            for (Int32 i = 0; i < split_count1; i++)
            {
                String s = splits1[i];
                String[] splits2 = s.Split(split2.ToCharArray());
                Int32 split_count2 = splits2.Length;
                if (1 == split_count2 && 0 >= splits2[0].Length)
                    split_count2 = 0;
                ar[i] = new Int32[split_count2];
                for (Int32 j = 0; j < split_count2; j++)
                {
                    ar[i][j] = Int32.Parse(splits2[j]);
                }
            }
            return (ar);

        }
        catch (Exception)
        {
            return (new Int32[0][]);
        }
    }

    public Int64[] RecordInt64Array(String field_name)
    {
        return (RecordInt64Array(field_name, ",", 0));
    }

    public Int64[] RecordInt64Array(String field_name, Int64 match_count)
    {
        return (RecordInt64Array(field_name, ",", match_count));
    }

    public Int64[] RecordInt64Array(String field_name, String split)
    {
        return (RecordInt64Array(field_name, split, 0));
    }

    public Int64[] RecordInt64Array(String field_name, String split, Int64 match_count)
    {
        if (null == _CurrentRecord)
            return (new Int64[0]);

        String str = RecordString(field_name);

        String[] splits = str.Split(split.ToCharArray());
        Int32 split_count = splits.Length;

        if (0 < match_count && match_count != split_count)
            return (new Int64[0]);

        if (1 == split_count && 0 >= splits[0].Length)
            split_count = 0;

        try
        {
            Int64[] ar = new Int64[split_count];
            for (Int32 i = 0; i < split_count; i++)
                ar[i] = Int64.Parse(splits[i]);
            return (ar);
        }
        catch (Exception)
        {
            return (new Int64[0]);
        }
    }

    public Int64[][] RecordInt64Array2(String field_name, String split1, String split2)
    {
        if (null == _CurrentRecord)
            return (new Int64[0][]);

        String str = RecordString(field_name);

        String[] splits1 = str.Split(split1.ToCharArray());
        Int32 split_count1 = splits1.Length;

        if (1 == split_count1 && 0 >= splits1[0].Length)
            split_count1 = 0;

        try
        {
            Int64[][] ar = new Int64[split_count1][];
            for (Int32 i = 0; i < split_count1; i++)
            {
                String s = splits1[i];
                String[] splits2 = s.Split(split2.ToCharArray());
                Int32 split_count2 = splits2.Length;
                if (1 == split_count2 && 0 >= splits2[0].Length)
                    split_count2 = 0;
                ar[i] = new Int64[split_count2];
                for (Int32 j = 0; j < split_count2; j++)
                {
                    ar[i][j] = Int64.Parse(splits2[j]);
                }
            }
            return (ar);

        }
        catch (Exception)
        {
            return (new Int64[0][]);
        }
    }

    public void Close()
    {
        _CurrentRecord = null;
        _CurrentRecords = null;
        _CurrentConfig = null;
        _Root = null;
        _Document = null;
    }

    public String XmlPath(String file_title)
    {
        return (String.Format("Xml/{0}", file_title));
    }

    public String XmlContent(String file_title)
    {
        return (LoadText(XmlPath(file_title)));
    }

    public String LoadText(String name)
    {
        String text;
        lock (_LoadedTexts)
        {
            if (_LoadedTexts.TryGetValue(name, out text))
                return (text);
        }

        UnityObject obj = Resources.Load(name);
        if (null == obj)
            return ("");
        if (!(obj is TextAsset))
            return ("");
        text = obj.ToString();

        lock (_LoadedTexts)
        {
            _LoadedTexts.Add(name, text);
        }

        return (text);
    }

    private XmlDocument _Document;
    private XmlElement _Root;
    private XmlElement _CurrentConfig;
    private IEnumerator _CurrentRecords = null;
    private XmlElement _CurrentRecord;

    private LoadedTexts _LoadedTexts = new LoadedTexts();
}

xml文件范例

<?xml version="1.0"?>
<fcm count="1">
    <CFG0 count="2">
    <RECORD0>
      <area_id>1</area_id>
      <area_name>1区 狮子座</area_name>
      <area_state>新区</area_state>
      <state_code>0</state_code>
    </RECORD0>
    <RECORD1>
      <area_id>2</area_id>
      <area_name>2区 狮子座</area_name>
      <area_state>新区</area_state>
      <state_code>0</state_code>
    </RECORD1>
    </CFG0>
</fcm>

使用范例

        public override void OnInitialize()
        {
            XmlReader = new XmlReader ();
            if ( cfg.Open( "areas" ) )
            {
                cfg.SeekConfig();
                Int32 record_count = cfg.RecordCount;
                for ( Int32 i = 0; i < record_count; i++ )
                {
                    if ( cfg.SeekNextRecord() )
                    {
                        Int32 area_id= cfg.RecordInt( "area_id" );
                        String area_name= cfg.RecordString( "area_name" );
                    }
                }
            }
            else
            {
                String title = "No Exit Xml file : ";
                title += TableConfig.XmlTitle( TableConfigType.Resource );
                UnityEngine.Debug.LogWarning( "" + title );
            }
            cfg.Close();
        }