对txt配置文件的 读取架构 1

索引,文本
名字_龙飞阵,龙飞阵
名字_天覆阵,天覆阵
名字_地载阵,地载阵
名字_云垂阵,云垂阵
名字_风扬阵,风扬阵
名字_暴怒阵,暴怒阵

对于一堆这样的配置文件 ，如何对它进行解析呢？

程序的结构和表结构息息相关，这里的各个表间的衔接通过一个表索引链接起来，程序的设计也是从这里开始；

DataTable所有表结构的基类，封装了表 数据 的加载， 解析。上代码：

using UnityEngine;
using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Text.RegularExpressions;
using System.Text;

/// <summary>
/// 配置表解析抽象类
/// </summary>
public abstract class DataTable
{
    protected int currLineValueCount;
    protected string[] currLineValues;
    private const string FILE_ENCODING = "GBK";
    /// <summary>当前加载的文件路径的数组下标索引 </summary>
    private int fileIndex=0;
    private string[] filePaths;
    /// <summary> 以每行具体的值为键,键有空.该值的列数为值,从零开始</summary>
    private Dictionary<string , int> name2Index;

    /// <summary>
    /// 
    /// </summary>
    /// <param name="paths">加载文件的路径</param>
    public DataTable(string[] paths)
    {
        this.filePaths = paths;
    }
    public DataTable(string path)
    {
        this.filePaths = new string[] { path };
    }

    #region 数值获取
    /// <summary>
    /// 删除包含整体文本的“ ” 
    /// </summary>
    /// <param name="s">要去除“ ” 的包含的整体文本值</param>
    /// <returns></returns>
    private string deleteQuotation(string s)
    {
        //string的 索引的是char ，是特性实现的。 string的 前后 是 “”
        if(((s.Length>0)&&(s[0]=='"'))&&(s[s.Length-1]=='"'))
        {
            //去点第一个 和最后一个
            s = s.Substring(1 , s.Length - 2);
        }
        return s;
    }

    /// <summary>
    /// 返回的是当前行里的 Name的值 ，如果存在的话
    /// </summary>
    /// <param name="name"></param>
    /// <returns></returns>
   protected string GetValueByName(string name)
   {
       int num=0;
       //字典中是否已存在  索引不超过本行所在的数量 本字符串要大于零
       if((this.name2Index.TryGetValue(name,out num)&&(num<this.currLineValueCount))&&(this.currLineValues[num].Length>0))
       {
           string str=this.currLineValues[num];
           //存的 null ...
           if(str!="null")
           {
               return str;
           }        
       }
        return null;
   }
 
    /// <summary>
    /// 看当前 字典里是否存在 Name的值(是否是真是数据)
    /// </summary>
    /// <param name="name"></param>要查找的值
    /// <param name="defaultValue"></param>
    /// <param name="mustExist"></param>
    /// <returns></returns>
    protected bool GetBoolean(string name,bool defaultValue,bool mustExist)
   {
       string valueByName = this.GetValueByName(name);
        if(valueByName==null)
        {
            if(mustExist)
            {
                throw new ColumnNotFoundException(name);
            }
            return defaultValue;
        }
        int result = 1;
        if(!int.TryParse(valueByName,out result))
        {
            throw new ParseException(valueByName);
        }
        return (result == 1);
   }

    /// <summary>
    /// 获取 一张 配置表里的 值 如果有的话
    /// </summary>
    /// <param name="name">要获取的string 名</param>
    /// <param name="defaultValue">默认值</param>
    /// <param name="mustExist"> 是否值 必须存在</param>
    /// <returns></returns>
    protected string GetString(string name , string defaultValue , bool mustExist)
    {
        string valueByName = this.GetValueByName(name);
        if (valueByName != null)
        {
            return valueByName;
        }
        if (mustExist)
        {
            throw new ColumnNotFoundException(name);
        }
        return defaultValue;
    }

    protected long GetLong(string name , long defaultValue , bool mustExist)
    {
        string valueByName = this.GetValueByName(name);
        if (valueByName == null)
        {
            if (mustExist)
            {
                throw new ColumnNotFoundException(name);
            } 
            return defaultValue;
        }
        long result = 0L;
        if(!long.TryParse(valueByName,out result))
        {
            throw new ParseException(valueByName);
        }
        return result;
    }
    protected  double GetDouble(string name,double defaultValue ,bool mustExist)
    {
        string valueByName = this.GetValueByName(name);
        if(valueByName==null)
        {
            if(mustExist)
            {
                throw new ColumnNotFoundException(name);
            }
            return defaultValue;
        }
        double result = 0.0;
        if(!double.TryParse(valueByName,out result))
        {
            throw new ParseException(valueByName);
        }
        return result;
    }

    protected int GetInt(string name , int defaultValue , bool mustExist)
    {
        string valueByName = this.GetValueByName(name);
        if(valueByName==null)
        {
            if(mustExist)
            {
                throw new ColumnNotFoundException(name);
            }
            return defaultValue;
        }
        int result = 0;
        if(!int.TryParse(valueByName,out result))
        {
            throw new ParseException(valueByName);
        }
        return result;
    }

    protected float GetFloat(string name , float defaultValue , bool mustExist)
    {
        string valueByName = this.GetValueByName(name);
        if (valueByName == null)
        {
            if (mustExist)
            {
                throw new ColumnNotFoundException(name);
            }
            return defaultValue;
        }
        float result = 0f;
        if (!float.TryParse(valueByName , out result))
        {
            throw new ParseException(valueByName);
        }
        return result;
    }

    /// <summary>
    /// 看用在哪里 ，来判断他的用处
    /// </summary>
    /// <param name="name"></param>
    /// <param name="mustExist"></param>
    /// <returns></returns>
    protected DynamicParam GetDyncmicParam(string name, bool mustExist)
    {
        string s = this.GetString(name , string.Empty , mustExist);
        int result = 0;
        int.TryParse(s , out result);
        double num2 = 0.0;
        double.TryParse(s , out num2);
        return new DynamicParam(s , result , num2);
    }

    /// <summary>
    /// 获取一个数据集
    /// </summary>
    /// <param name="name"></param>
    /// <param name="mustExist"></param>
    /// <returns></returns>
    protected DataSet GetDataSet(string name,bool mustExist)
    {
        return new DataSet(name ,this.GetString(name,! mustExist ? string.Empty : null , mustExist));
    }
    #endregion

    #region 数据 类

    /// <summary>
    /// 
    /// </summary>
    public class DynamicParam
    {
        public double f;
        public int n;
        public string str;

        public DynamicParam(string str_,int n_ ,double f_)
        {
            this.f = f_;
            this.str = str_;
            this.n = n_;
        }
    }

    /// <summary>栏数据的特殊集 </summary>
    public class DataSet
    {
        private string columnName;
        /// <summary>光标</summary>
        private int cursor;

        /// <summary>
        /// 取得的每一行的文本 不是通过StreamRead 的方式
        /// </summary>
        private MatchCollection result;

        /// <summary>当前行的 信息</summary>
        private string[] values;
        public DataSet(string colName,string s)
        {
            if(s=="")
            {
                s = "\"(宝箱_金宝箱,0)\"";
            }
                //(?<=\() 匹配（后面的字符， (.*?)匹配 任意多个字符 ，(?=\))匹配 ）前面的字符
                this.result = Regex.Matches(s , @"(?<=\()(.*?)(?=\))");
                this.columnName = colName;       
        }

        #region 数据获取函数
        /// <summary>
        /// 通过索引获取double类型的值
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public double GetDouble(int index)
        {
            if(index >= this.values.Length)
            {
                throw new DataTable.ColumnNotFoundException(this.columnName);
            }
            double result = 0.0;
            //不是能转换的格式
            if(!double.TryParse(this.values[index],out result))
            {
                throw new DataTable.ParseException(this.values[index]);
            }
            return result;
        }

        public float GetFloat(int index)
        {
            if(index>=this.values.Length)
            {
                throw new DataTable.ColumnNotFoundException(this.columnName);
            }
            float result = 0f;
            if(!float.TryParse(this.values[index],out result))
            {
                throw new DataTable.ParseException(this.values[index]);
            }
            return result;
        }

        public int GetInt(int index)
        {
            if (index >= this.values.Length)
            {
                throw new DataTable.ColumnNotFoundException(this.columnName);
            }
            int result =0;
            if (!int.TryParse(this.values[index] , out result))
            {
                throw new DataTable.ParseException(this.values[index]);
            }
            return result;
        }

        public long GetLong(int index)
        {
            if (index >= this.values.Length)
            {
                throw new DataTable.ColumnNotFoundException(this.columnName);
            }
            long result = 0L;
            if (!long.TryParse(this.values[index] , out result))
            {
                throw new DataTable.ParseException(this.values[index]);
            }
            return result;
        }

        public string GetString(int index)
        {
            if (index >= this.values.Length)
            {
                throw new DataTable.ColumnNotFoundException(this.columnName);
            }
            return this.values[index];
        }
        #endregion

        /// <summary>
        /// 开放当前行的数据集
        /// </summary>
        /// <returns></returns>
        public string[] Values()
        {
            return this.values;
        }
        /// <summary>
        /// 下个值是否存在
        /// </summary>
        public bool NextValues()
        {
            //超出了行数 结束
            if(this.cursor>=this.result.Count)
            {
                return false;
            }
            //获取当前 行（cursor 光标所在） 的行文本
            string str = this.result[this.cursor].Value;
            char[] sepatator = new char[] { ',' };
            this.values = str.Split(sepatator);
            // 同时对当前行的文本进行处理，这样在获取瞎哥值是否存在时，也能获取当前行的值
            for (int i=0;i<this.values.Length;i++)
            {
                this.values[i] = this.values[i].Trim();
            }
            this.cursor++;
            return true;
        }

    }
    #endregion

    #region 文件加载

    /// <summary>
    /// isPack 是打包通过unity加载 ,否者通过 C# 加载
    /// </summary>
    /// <returns></returns>
    public bool Load()
    {
        if (this.filePaths == null)
        {
            return false;
        }
        this.currLineValues = new string[0x400];
        this.currLineValueCount = 0;
        for (int i = 0 ; i < this.filePaths.Length ; i++)
        {
            string path = this.filePaths[i];
            path = DataMngr._GetDirPath() + path+".txt";
            //+DataMngr._GetExtName();
            bool parseColumn = true;
            if (!(!DataMngr._isPack() ? this.LoadByFile(path , parseColumn) : this.LoadByUnity(path , parseColumn)))
            {
                return false;
            }
        }
        this.currLineValues = null;
        this.currLineValueCount = 0;
        this.OnLoadComplete();
        return true;
    }


    /// <summary>
    /// 加载txt配置文件
    /// </summary>
    /// <param name="path">文件路径</param>
    /// <param name="parseColumn">是否加载栏</param>
    /// <returns>是否加载成功</returns>
    private bool LoadByFile(string path,bool parseColumn)
    {
        FileStream stream = null;
        try
        {
            stream = new FileStream(path , FileMode.Open , FileAccess.Read , FileShare.ReadWrite);
        }
        catch
        {
            return false;
        }
        StreamReader reader = null;
        try
        {
            reader = new StreamReader(stream ,Encoding.UTF8);
        }
        catch
        {//关闭流 ，取消引用
            stream.Close();
            stream = null;
            return false;
        }

        int lineNum = 0;
        bool flag = true;
        while(!reader.EndOfStream)
        {
            string lineStr = reader.ReadLine();
            //栏
            if(lineNum==0)
            {
                if(parseColumn)
                {//第一栏
                    this.ParseColumn(lineStr);
                }
            }
            else if(!this.ParseData(lineStr,lineNum))
            {//转换出错
                flag = false;
                Debug.LogError(string.Concat(new string[]{"file parse error.path=",path,",line=",lineNum.ToString()}));
                break;
            }
            lineNum++;
        }
        reader.Close();
        reader = null;
        stream.Close();
        stream = null;
        return flag;
    }

    private bool LoadByUnity(string path,bool parseColumn)
    {
        int num3=0;
        //所有资源打包为AssetsBundle 然后通过路径加载
        Res res = ResMngr.GetInstance().LoadSync("Data" , path);
        if(res==null)
        {
            return false;
        }
        TextAsset assetToUnload = (TextAsset)res.GetObject();
        if(assetToUnload==null)
        {
            return false;
        }
        string text = assetToUnload.text;
        if(text.Length<=0)
        {
            return false;
        }
        //Windows中每行结尾是“<换行><回车>”，即“\n\r”
        string str2 = "\r\n";
        int lineNum = 0;
        for(int i=0;i<text.Length;i=num3+str2.Length)
        {
            //OrdinalIgnoreCase使用序号排序规则并忽略被比较字符串的大小写，对字符串进行比较
            num3 = text.IndexOf(str2 , i , StringComparison.OrdinalIgnoreCase);
            string lineStr = text.Substring(i , num3 - i);
            if(lineNum==0)
            {
                if(parseColumn)
                {
                    this.ParseColumn(lineStr);
                }
            }
            else if(!this.ParseData(lineStr,lineNum))
            {
                return false;
            }
            lineNum++;
        }
        Resources.UnloadAsset(assetToUnload);
        return true;

    }

    //public bool LoadNotFromDataMngr()
    //{
    //    if(this.filePaths==null)
    //    {
    //        return false;
    //    }
    //     0x400 == 1024
    //    this.currLineValues = new string[0x400];
    //    this.currLineValueCount = 0;
    //    string str = string.Empty;
    //    string serverDataPath = string.Empty;
    //    bool flag = false;
    //    if(RunParam.Getins)


    //}

    /// <summary>
    ///转换第一行的栏 
    /// </summary>
    /// <param name="lineStr">当前行的文本,这里是第一行栏的文本</param>
    protected void ParseColumn(string lineStr)
    {
        this.name2Index = new Dictionary<string , int>();
        //文本的分割器
        char[] separator = new char[] { ',' };
        string[] strArray = lineStr.Split(separator);
        for(int i=0;i<strArray.Length;i++)
        {
            //每行的每个值作为 键 
            string key = strArray[i];
            //作为栏 是一定不会键位空值的
            if(this.name2Index.ContainsKey(key))
            {
                Debug.LogError("File["+this.filePaths[this.fileIndex]+"]colum["+key+"]had exist!");
                return;
            }
            this.name2Index.Add(key , i);
        }
    }

    /// <summary>
    /// 转换每个配置表里的值 
    /// </summary>
    /// <param name="lineStr">每行的文本</param>
    /// <param name="lineNum">文本的所在行位置，第几行</param>
    /// <returns>GetBoolean 函数定义了抛出异常的条件，这里扑捉异常</returns>
    protected bool ParseData(string lineStr,int lineNum)
    {
        try
        {
            //行开头以"//"始 是一个完整的文本
            if(lineStr.Substring(0,2).Equals("//"))
            {
                return true;
            }
        }
        catch(Exception)
        {
            //这行数据为空 会报错哦
            Debug.LogError("ParseData Exception");
        }
        //这里进行 数据的转换 ，包括格式定义的检查 分割，并给当前行赋值
        this.currLineValueCount = this.SplitColumn(lineStr);
        try
        {
           if(!this.OnParseLine(lineNum))
           {
               Debug.LogError(string.Concat(new string[] { "File[" , this.GetFilePath() , "]Line[" , lineNum.ToString() , "]prototype may had exist!" }));
               return false;
           }
        }
        catch(ColumnNotFoundException ex)
        {
            Debug.LogError(string.Concat(new string[] { "Line[" , lineNum.ToString() , "]could not find\"" , ex.GetColumnName() , "\"column!" }));
            return false;
        }
        catch(ParseException ex1)
        {
            Debug.LogError(string.Concat(new string[] { "Line[" , lineNum.ToString() , "]parse failed ! data=\"" , ex1.GetParseData() , "\"" }));
            return false;
        }
        return true;
    }

    public string GetFilePath()
    {
        return this.filePaths[this.fileIndex];
    }

    /// <summary>
    /// 获取栏数,并对栏进行处理，对于有‘”’标记整体的栏值 去‘“’ 处理,currentValues 也一并处理了
    /// </summary>
    /// <param name="lineStr">当前的一行文本</param>
    /// <returns></returns>
    private int SplitColumn(string lineStr)
    {
        int num = 0;
        bool flag = false;
        int startIndex = 0;
        for(int i=0;i<lineStr.Length;i++)
        {
            char ch = lineStr[i];
            //文本中字符包含 “ 见文本char_rate_params.txt 这是被标记的文本，其中包含‘，’但是是一个整体要特殊处理
            if(ch=='"')
            {
                flag = !flag;
            }
                //有 段落值标记时,该段内只一个整体 不对‘，’进行分割
            else if((ch==',')&&!flag)
            {
                string s = lineStr.Substring(startIndex , i - startIndex);
                startIndex = i + 1;
                this.currLineValues[num++] = this.deleteQuotation(s);
            }
        }
        //不是用Split 分割 ，最后一个‘，’之后 不会再分割，还要再加上去
        if(startIndex<lineStr.Length)
        {
            string str2 = lineStr.Substring(startIndex , lineStr.Length - startIndex);
            this.currLineValues[num++] = this.deleteQuotation(str2);
        }
        return num;
    }



    /// <summary>
    /// 转换行
    /// </summary>
    /// <param name="lineNum">文本所在行数</param>
    /// <returns></returns>
    protected abstract bool OnParseLine(int lineNum);
    /// <summary>
    /// 构建表数据
    /// </summary>
    /// <returns></returns>
    public abstract bool OnBuild();

    protected abstract bool OnLoadComplete();
    #endregion 

    #region 异常类
    public class ParseException:Exception
    {
        private string data;
        public ParseException(string d)
        {
            this.data = d;
        }
        public string GetParseData()
        {
            return this.data;
        }
    }
    public class ColumnNotFoundException:Exception
    {
        private string columnName;
        public ColumnNotFoundException(string name)
        {
            this.columnName = name;
        }
        public string GetColumnName()
        {
            return this.columnName;
        }
    }
    #endregion

}