Unity 实现转策划Execl文档，并根据Xml配置文件生成代码

本工具主要还是依赖别人提供的一个解析Excel文件的工具。

下载链接：http://www.xuanyusong.com/archives/2429。

工具实现的过程是将Excel表中的数据根据xml配置文件读取出来后，然后又根据xml文件写入一个自定义的文件中。游戏中就还是根据xml配置读取数据。

首先来看一下xml配置文件吧：

<?xml version="1.0" encoding="gb2312" standalone="yes" ?>
<metalib tagsetversion="1" name="" version="1">
  <table name="test">
      <column  name="id" type="int" count ="1" descript ="id"/>
      <column  name="name" type="string" count ="1" descript ="name"/>
      <column  name="sex" type="int" count ="1" descript ="sex"/>
     <column  name="age" type="int" count ="1" descript ="age"/>
    <column  name="descrip" type="string" count ="1" descript ="descrip"/>
  </table>
  <table name="test1">
    <column  name="id" type="int" count ="1" descript ="id"/>
    <column  name="name" type="string" count ="3" descript ="name"/>
    <column  name="sex" type="int" count ="1" descript ="sex"/>
    <column  name="age" type="int" count ="1" descript ="age"/>
    <column  name="descrip" type="string" count ="1" descript ="descrip"/>
  </table>
  <table name="test2">
    <column  name="id" type="int" count ="1" descript ="id"/>
    <column  name="name" type="string" count ="1" descript ="name"/>
    <column  name="sex" type="int" count ="3" descript ="sex"/>
    <column  name="age" type="int" count ="1" descript ="age"/>
    <column  name="descrip" type="string" count ="1" descript ="descrip"/>
  </table>
</metalib>

这其中每一个table就对应一个Excel表，table标签中就是表的字段。

下面就是整个工具的全部代码：

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEditor;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.IO;
using Excel;
using System.Data;
using System.Xml;
using System.Threading;
using UObject = UnityEngine.Object;

public class ExeclRead : EditorWindow
{
    private static string m_TableXmlData = "GameData/Data.xml";
    private static string m_CsCodePath = "GameData/GameDataClass.cs";
    private static string m_ChangedTableDataPath = "GameData";
    private static string m_ChangedTableDataPathExtend = ".tdr";
    private static string m_GameDataParentClassName = "GameDataParent";
    private static string m_GameDataInitFunName = "SetData";

    private static string m_ApplictionDataPath = "";
    private static bool m_IsShowBar = false;
    private static float m_BarValue = 0.0f;
    private static string m_BarTitle = "";
    private static string m_BarMessage = "";

    private static bool m_IsRefreshAsset = false;
    [MenuItem("Tools/GameData/GenerateCode")]
    public static void GenerateCode()
    {
        m_ApplictionDataPath = Application.dataPath;
        new Thread(GenerateCodeTherad).Start();
    }

    [MenuItem("Tools/GameData/Execl")]
    public static void ChangeExcel()
    {
        m_ApplictionDataPath = Application.dataPath;
        UObject[] excelTables = Selection.GetFiltered(typeof(UObject), SelectionMode.DeepAssets);
        foreach (var table in excelTables)
        {
            string tableName = AssetDatabase.GetAssetPath(table);
            if (tableName.IndexOf(".xls") != -1 || tableName.IndexOf(".xlsx") != -1)
            {
                string tableCompeletPath = GetAssetPath(tableName);
                ChangeTable(tableCompeletPath);
            }
        }
    }

    [MenuItem("Tools/GameData/Test")]
    public static void GameDataTest() {
        m_ApplictionDataPath = Application.dataPath;
        UObject[] excelTables = Selection.GetFiltered(typeof(UObject), SelectionMode.DeepAssets);
        string xmlPath = m_ApplictionDataPath + "/" + m_TableXmlData;
        XmlDocument xmlDoc = new XmlDocument();
        xmlDoc.Load(xmlPath);
        XmlNodeList tableNodes = xmlDoc.GetElementsByTagName("table");
        foreach (var table in excelTables)
        {
            string tableName = AssetDatabase.GetAssetPath(table);
            if (tableName.IndexOf(".tdr") != -1)
            {
                string tableCompeletPath = GetAssetPath(tableName);
                FileStream fileStream = File.Open(tableCompeletPath, FileMode.Open, FileAccess.Read);
                XmlNode targetTable = null;
                foreach (XmlNode fildtable in tableNodes)
                {
                    if (fildtable.Attributes["name"].Value == table.name)
                    {
                        targetTable = fildtable;
                        break;
                    }
                }
                if (targetTable == null) continue;
                XmlNodeList tableFilds = targetTable.ChildNodes;
                while (fileStream.Position < fileStream.Length) {
                    foreach (XmlNode fild in tableFilds)
                    {
                        string name = fild.Attributes["name"].Value;
                        string type = fild.Attributes["type"].Value;
                        int cout = int.Parse(fild.Attributes["count"].Value);
                        for (int k = 0; k < cout; k++)
                        {
                            switch (type)
                            {
                                case "float":
                                    byte[] fvalue = new byte[4];
                                    fileStream.Read(fvalue, 0, 4);
                                    float fvalu = BitConverter.ToSingle(fvalue,0);
                                    Debug.Log(fvalu);
                                    break;
                                case "int":
                                    byte[] ivalue = new byte[4];
                                    fileStream.Read(ivalue, 0, 4);
                                    int inva = BitConverter.ToInt32(ivalue,0);
                                    Debug.Log(inva);
                                    break;
                                case "string":
                                    byte[] blength = new byte[4];
                                    fileStream.Read(blength, 0, 4);
                                    int length= BitConverter.ToInt32(blength,0);
                                    byte[] bvalue = new byte[length];
                                    fileStream.Read(bvalue, 0, bvalue.Length);
                                    string temp = Encoding.UTF8.GetString(bvalue);
                                    Debug.Log(temp);
                                    break;
                            }
                        }
                    }
                }
                fileStream.Close();
            }
        }
    }

    /// <summary>
    /// 开始创建数据表对应的Class
    /// </summary>
    static void  GenerateCodeTherad() {
        string xmlPath = m_ApplictionDataPath + "/" + m_TableXmlData;
        if (!File.Exists(xmlPath)) return;
        XmlDocument xmlDoc = new XmlDocument();
        xmlDoc.Load(xmlPath);
        XmlNodeList tableNodes = xmlDoc.GetElementsByTagName("table");
        int allCount = tableNodes.Count;
        int currentCounut = 0;
        StringBuilder allCodeContent = new StringBuilder( "using System;\r\n using System.Collections; \r\n");
        //写入父类
        allCodeContent.Append(GenerParentClassCode(m_GameDataParentClassName, m_GameDataInitFunName));
        foreach (XmlNode table in tableNodes)
        {
            string tableName = table.Attributes["name"].Value;
            ShowBar("Generate Code", "generate code  " + tableName, currentCounut / allCount);
            allCodeContent.Append(StartGenerateCode(table));
        }
        string fileName = m_ApplictionDataPath + "/" + m_CsCodePath;
        if (File.Exists(fileName))
        {
            File.Delete(fileName);
        }
        FileStream csCodeFilStream = File.Open(fileName, FileMode.CreateNew, FileAccess.ReadWrite);
        byte[] csCodeContent = Encoding.UTF8.GetBytes(allCodeContent.ToString());
        csCodeFilStream.Write(csCodeContent, 0, csCodeContent.Length);
        csCodeFilStream.Close();
        HiddenBar();
        RefreshAsset();
    }

    /// <summary>
    /// 生成数据表对应的Class的父类
    /// </summary>
    /// <param name="className"></param>
    /// <param name="dataInitFunName"></param>
    /// <returns></returns>
    static string GenerParentClassCode(string className, string dataInitFunName) {
        if (string.IsNullOrEmpty(className) || string.IsNullOrEmpty(dataInitFunName)) return "";
        CsCodeBuild parent = new CsCodeBuild(className);
        CodeFunction codeFun = new CodeFunction();
        codeFun.name = dataInitFunName;
        codeFun.parms = new Dictionary<string, string>();
        codeFun.parms.Add("data", "Hashtable");
        codeFun.isVirtual = true;
        parent.AddCodeFunction(codeFun);
        return parent.codeContent;
    }

    /// <summary>
    /// 根据数据表创建对应的Class
    /// </summary>
    /// <param name="tableNode"></param>
    /// <returns></returns>
    public static string StartGenerateCode(XmlNode tableNode) {
        if (tableNode == null) return "";
        XmlAttributeCollection attrs = tableNode.Attributes;
        string className = attrs["name"].Value;
        CsCodeBuild codeBuulder = new CsCodeBuild(className);
        codeBuulder.AddExtendClass(m_GameDataParentClassName);
        XmlNodeList fildLists = tableNode.ChildNodes;
        StringBuilder functionContent = new StringBuilder("");
        foreach (XmlNode fild in fildLists) {
            int count = int.Parse(fild.Attributes["count"].Value);
            string type = fild.Attributes["type"].Value;
            string name = fild.Attributes["name"].Value;
            CodeFild codeFild = new CodeFild();
            codeFild.name = name;
            codeFild.type = type;
            codeFild.descript = fild.Attributes["descript"].Value;
            codeFild.isArray = count > 1;
            codeFild.arrayCount = count;
            codeBuulder.AddCodeFild(codeFild);
            functionContent.Append(GenerateFunctionContent(name,type,count));
        }
        Dictionary<string, string> parms = new Dictionary<string, string>();
        parms.Add("data", "Hashtable");
        CodeFunction codeFun = new CodeFunction();
        codeFun.name = m_GameDataInitFunName;
        codeFun.content = functionContent.ToString();
        codeFun.parms = parms;
        codeFun.isOverried = true;
        codeBuulder.AddCodeFunction(codeFun);
        return codeBuulder.codeContent;
    }

    /// <summary>
    /// 生成对应的列的读取方式
    /// </summary>
    /// <param name="name"></param>
    /// <param name="type"></param>
    /// <param name="count"></param>
    /// <returns></returns>
    static string GenerateFunctionContent(string name, string type, int count) {
        StringBuilder funcContent = new StringBuilder();
        funcContent.Append("\t\t\t");
        funcContent.Append(name);
        if (count > 1)
        {
            funcContent.Append( " = data[\"" );
            funcContent.Append( name );
            funcContent.Append("\"] as ");
            funcContent.Append( type );
            funcContent.Append("[];\r\n");
        }
        else
        {
            switch (type)
            {
                case "float":
                    funcContent.Append( " = Convert.ToSingle(data[\"");
                    funcContent.Append( name );
                    funcContent.Append("\"]);\r\n");
                    break;
                case "int":
                    funcContent.Append(" = Convert.ToInt32(data[\"");
                    funcContent.Append(name);
                    funcContent.Append("\"]);\r\n");
                    break;
                default:
                    funcContent.Append(" = data[\"" );
                    funcContent.Append(  name );
                    funcContent.Append( "\"] as ");
                    funcContent.Append(type);
                    funcContent.Append(";\r\n");
                    break;
            }
        }

        return funcContent.ToString();
    }

    public static void ChangeTable( string tableCompeletPath) {
        string xmlPath = m_ApplictionDataPath + "/" + m_TableXmlData;
        if (string.IsNullOrEmpty(tableCompeletPath)) return;
        if (!File.Exists(tableCompeletPath)) return;
        FileStream stream = File.Open(tableCompeletPath, FileMode.Open,FileAccess.Read);
        IExcelDataReader excelReader = ExcelReaderFactory.CreateOpenXmlReader(stream);
        DataSet result = excelReader.AsDataSet();
        int columns = result.Tables[0].Columns.Count;
        int rows = result.Tables[0].Rows.Count;

        FileInfo fileInfo = new FileInfo(tableCompeletPath);
        string tableName = fileInfo.Name.Substring(0, fileInfo.Name.IndexOf("."));
        string fileName = fileInfo.DirectoryName+"/" + tableName + m_ChangedTableDataPathExtend;
        XmlDocument xmlDoc = new XmlDocument();
        xmlDoc.Load(xmlPath);
        XmlNodeList tableNodes = xmlDoc.GetElementsByTagName("table");
        XmlNode targetTable = null;
        foreach (XmlNode table in tableNodes) {
            if (table.Attributes["name"].Value == tableName) {
                targetTable = table;
                break;
            }
        }
        if (targetTable == null) {
            Debug.LogError("dont find table " + tableName);
            return;
        }
        if (File.Exists(fileName))
        {
            File.Delete(fileName);
        }

        FileStream gameDataStream = File.Open(fileName, FileMode.CreateNew, FileAccess.ReadWrite);
        XmlNodeList fildLists = targetTable.ChildNodes;
        for (int i = 1; i < rows; i++)
        {
            for (int j = 0; j < columns; j++)
            {
                XmlNode fild = fildLists[j];
                string type = fild.Attributes["type"].Value;
                int cout = int.Parse(fild.Attributes["count"].Value);
                for (int k = 0; k < cout; k++) {
                    byte[] tempData = null;
                    string nvalue = result.Tables[0].Rows[i][j + k].ToString();
                    switch (type)
                    {
                        case "float":
                            float fvalue = float.Parse(nvalue);
                            tempData = BitConverter.GetBytes(fvalue);
                           // Debug.Log("write: " + fvalue + " length:" + tempData.Length);
                            break;
                        case "int":
                            int ivalue = int.Parse(nvalue);
                            tempData = BitConverter.GetBytes(ivalue);
                            //Debug.Log("write: " + ivalue + " length:" + tempData.Length);
                            break;
                        case "string":
                            tempData = Encoding.UTF8.GetBytes(nvalue);
                            int length = tempData.Length;
                            byte[] lengthData = BitConverter.GetBytes(length);
                            gameDataStream.Write(lengthData, 0, lengthData.Length);
                            //Debug.Log("write: " + nvalue + " length:" + tempData.Length);
                            break;
                    }
                    if (tempData == null) continue;
                    gameDataStream.Write(tempData, 0, tempData.Length);
                }
                j += (cout - 1);
            }
        }
        gameDataStream.Close();
    }

   static  bool IsStandType(string typeName)
    {
        bool isStandType = false;
        switch (typeName) {
            case "float":
                isStandType = true;
                break;
            case "int":
                isStandType = true;
                break;
            case "string":
                isStandType = true;
                break;
        }
        return isStandType;
    }

    public static string GetAssetPath(string path) {
        if (string.IsNullOrEmpty(path)) return null;
        string compeletPath = Application.dataPath;
        compeletPath = compeletPath.Substring(0, compeletPath.IndexOf("Assets"))+path;
        return compeletPath;
    }

    public static void ShowBar(string barTitle,string barMessage,float barValue) {
        m_IsShowBar = true;
        m_BarTitle = barTitle;
        m_BarMessage = barMessage;
        m_BarValue = barValue;
    }

    public static void HiddenBar() {
        m_IsShowBar = false;
    }

    public static void RefreshAsset() {
        m_IsRefreshAsset = true;
    }

    void OnGUI()
    {
        if (m_IsShowBar) {
            EditorUtility.DisplayProgressBar(m_BarTitle,m_BarMessage, m_BarValue);
        }

        if (m_IsRefreshAsset) {
            AssetDatabase.Refresh();
            m_IsRefreshAsset = false;
        }
    }
}

public class CodeFild
{
    public string name = "";
    public string type = "";
    public bool isArray = false;
    public string descript = null;
    public int arrayCount = 0;
    public bool isStatic = false;
}

public class CodeFunction
{
    public string name = "";
    public Dictionary<string, string> parms = null;
    public string content = "";
    public string returnType = "void";
    public bool isStatic = false;
    public bool isOverried = false;
    public bool isVirtual = false;
}


public class CsCodeBuild{

    private string m_ClassName = "";
    private string m_CodeContent = "";
    private string m_SpaceNmae = "";
    private string m_ExtendClassName = "";
    public string codeContent {
        get {
            m_CodeContent = GenerCodeContent();
            return m_CodeContent;
        }
    }

    public string className {
        get {
            return m_ClassName;
        }
    }
    private List<string> m_UseSpaceName = new List<string>();
    private List<CodeFild> m_CodeFilds = new List<CodeFild>();
    private List<CodeFunction> m_CodeFunctions = new List<CodeFunction>();
  public  CsCodeBuild(string className)
    {
        if (!string.IsNullOrEmpty(className)) {
            m_ClassName = GenerateClassName(className);
        }
    }

    public static string GenerateClassName(string className) {
        if (string.IsNullOrEmpty(className)) return null;
        string tempClassName = "";
        string upClassName = className.ToUpper();
        string fistChar = upClassName.Substring(0, 1);
        tempClassName = fistChar + className.Substring(1);
        return tempClassName;
    }

    public void AddUseSpaceName(string spaceName) {
        m_UseSpaceName.Add(spaceName);
    }

    public void AddNameSpace(string spaceName) {
        m_SpaceNmae = spaceName;
    }

    public void AddExtendClass(string extendClassName) {
        m_ExtendClassName = extendClassName;
    }
    public void AddCodeFild(CodeFild codeFild) {
        if (codeFild == null) return;
        m_CodeFilds.Add(codeFild);
    }

    public void AddCodeFunction(CodeFunction codeFunction) {
        if (codeFunction == null) return;
        m_CodeFunctions.Add(codeFunction);
    }

    string GenerCodeContent() {
        StringBuilder content = new StringBuilder("");
        //写入引用命名空间
        foreach (string spaceName in m_UseSpaceName) {
            content.Append("using ");
            content.Append(spaceName);
            content.Append(";\r\n");
        }
        //写入命名空间
        if (!string.IsNullOrEmpty(m_SpaceNmae)) {
            content.Append ( "namespace ");
            content.Append( m_SpaceNmae);
            content.Append(" { \r\n");
        }
        content.Append("public class ");
        content.Append(m_ClassName);
        //写入父类
        if (!string.IsNullOrEmpty(m_ExtendClassName)) {
            content.Append(" : ");
            content.Append(m_ExtendClassName);
        }
        content.Append(" {\r\n");
        //写入属性
        foreach (var fild in m_CodeFilds) {
            content.Append(GenerateFild(fild));
        }
        //写入方法
        foreach (var function in m_CodeFunctions) {
            content.Append(GenerateFunctionCode(function));
        }

        if (!string.IsNullOrEmpty(m_SpaceNmae))
        {
            content.Append("\t\t } \r\n");
        }

        content.Append( "\t } \r\n  \r\n");
        return content.ToString();
    }
    string GenerateFild(CodeFild codeFild) {
        if (codeFild == null) return "";
        StringBuilder fildCode = new StringBuilder();
        fildCode.Append("\t\t public ");
        fildCode.Append(codeFild.type);
        fildCode.Append(" ");
        if (codeFild.isArray)
        {
            fildCode.Append("[] ");
        }
        fildCode.Append(codeFild.name);
        fildCode.Append("; ");
        if (!string.IsNullOrEmpty(codeFild.descript))
        {
            fildCode.Append("//");
            fildCode.Append(codeFild.descript);
        }
        fildCode.Append("\r\n");
        return fildCode.ToString();
    }

    string GenerateFunctionCode(CodeFunction codeFun) {
        if (codeFun == null) return "";
        StringBuilder functionCode = new StringBuilder();
        functionCode.Append("\t\t public ");
        if (codeFun.isStatic)
        {
            functionCode.Append("static ");
        }
        if (codeFun.isOverried) {
            functionCode.Append("override ");
        }
        if (codeFun.isVirtual) {
            functionCode.Append("virtual ");
        }

        functionCode.Append(codeFun.returnType);
        functionCode.Append(" ");
        functionCode.Append(codeFun.name);
        functionCode.Append("(");
        if (codeFun.parms != null)
        {
            foreach (var parm in codeFun.parms)
            {
                functionCode.Append(parm.Value );
                functionCode.Append(" ");
                functionCode.Append(parm.Key);
            }
        }
        functionCode.Append(") { \r\n");
        functionCode.Append(codeFun.content);
        functionCode.Append(" \t\t\t } \r\n");
        return functionCode.ToString();
    }
}

代码有点多。不足的地方还请各位大神指出。

其中生成cs代码的部分还不是特别的完善。

下面就是一个读取的类：

using System.Collections;
using System.Collections.Generic;
using System.Xml;
using UnityEngine;
using System.IO;
using System;
using System.Text;
using CObject = System.Object;
public class TableDataMannager  {
    private static TableDataMannager s_Instance = null;


    private static readonly string s_XmlFilePath = "/GameData/Data.xml";
    private static readonly string s_TableParentDir = "/GameData/";


    public static TableDataMannager instance {
        get {
            if (s_Instance == null) {
                s_Instance = new TableDataMannager();
            }
            return s_Instance;
        }
    }


    private Dictionary<string, CObject> readTableData = new Dictionary<string, CObject>();


    private XmlNodeList m_XmlTable = null;
    public XmlNodeList xmlTable {
        get {
            if (m_XmlTable == null) {
                string xmlPath = Application.dataPath + s_XmlFilePath;
                XmlDocument xmlDoc = new XmlDocument();
                xmlDoc.Load(xmlPath);
                m_XmlTable = xmlDoc.GetElementsByTagName("table");
            }
            return m_XmlTable;
        }
    }


    public List<T> GetTableData<T>(string tableName) where T : GameDataParent ,new(){
        CObject temptable;
        tableName = tableName.ToLower();
        if (readTableData.TryGetValue(tableName, out temptable)) {
            return temptable as List<T>;
        }
        List<T> table = new List<T>();
        string tdrFile = Application.dataPath+ s_TableParentDir + tableName + ".tdr";
        XmlNodeList tableNodes = xmlTable;
        if (tableNodes == null) { return null; }
        XmlNode targetTable = null;
        for (int i=0;i<tableNodes.Count;i++)
        {
            if (tableNodes[i].Attributes["name"].Value.ToLower() == tableName)
            {
                targetTable = tableNodes[i];
                break;
            }
        }
        if (targetTable == null) return table;
        FileStream fileStream = File.Open(tdrFile, FileMode.Open, FileAccess.Read);
        BufferedStream bufferReader = new BufferedStream(fileStream);
        XmlNodeList tableFilds = targetTable.ChildNodes;
        while (bufferReader.Position < bufferReader.Length)
        {
            T clown = new T();
            Hashtable data = new Hashtable();
            for (int i=0;i<tableFilds.Count;i++)
            {
                string name = tableFilds[i].Attributes["name"].Value;
                string type = tableFilds[i].Attributes["type"].Value;
                int cout = int.Parse(tableFilds[i].Attributes["count"].Value);
                switch (type)
                {
                    case "float":
                        if (cout > 1)
                        {
                            data[name] = ReadFloatArray(bufferReader, cout);
                        }
                        else {
                            data[name] = ReadSingleFloat(bufferReader);
                        }
                        break;
                    case "int":
                        if (cout > 1)
                        {
                            data[name] = ReadIntArray(bufferReader, cout);
                        }
                        else {
                            data[name] = ReadSingInt(bufferReader);
                        }
                        break;
                    case "string":
                        if (cout > 1)
                        {
                            data[name] = ReadStringArray(bufferReader,cout);
                        }
                        else {
                            data[name] = ReadSingString(bufferReader);
                        }
                        break;
                }
            }
            clown.SetData(data);
            table.Add(clown);
        }
        fileStream.Close();
        readTableData.Add(tableName, table );
        return table;
    }


    float ReadSingleFloat(BufferedStream bufferReader) {
        byte[] fvalue = new byte[4];
        bufferReader.Read(fvalue, 0, 4);
         return BitConverter.ToSingle(fvalue, 0);
    }


    float[] ReadFloatArray(BufferedStream bufferReader, int count) {
        float[] data = new float[count];
        for (int i = 0; i < count; i++) {
            byte[] fvalue = new byte[4];
            bufferReader.Read(fvalue, 0, 4);
            data[i]=BitConverter.ToSingle(fvalue, 0);
        }
        return data;
    }


    int ReadSingInt(BufferedStream bufferReader) {
        byte[] ivalue = new byte[4];
        bufferReader.Read(ivalue, 0, 4);
       return BitConverter.ToInt32(ivalue, 0);
    }


    int[] ReadIntArray(BufferedStream bufferReader, int count) {
        int[] data = new int[count];
        for (int i = 0; i < count; i++)
        {
            byte[] fvalue = new byte[4];
            bufferReader.Read(fvalue, 0, 4);
            data[i] = BitConverter.ToInt32(fvalue, 0);
        }
        return data;
    }


    string ReadSingString(BufferedStream bufferReader) {
        byte[] blength = new byte[4];
        bufferReader.Read(blength, 0, 4);
        int length = BitConverter.ToInt32(blength, 0);
        byte[] bvalue = new byte[length];
        bufferReader.Read(bvalue, 0, bvalue.Length);
         return Encoding.UTF8.GetString(bvalue);
    }


    string[] ReadStringArray(BufferedStream bufferReader, int count) {
        string[] data = new string[count];
        for (int i = 0; i < count; i++)
        {
            byte[] blength = new byte[4];
            bufferReader.Read(blength, 0, 4);
            int length = BitConverter.ToInt32(blength, 0);
            byte[] bvalue = new byte[length];
            bufferReader.Read(bvalue, 0, bvalue.Length);
            data[i] = Encoding.UTF8.GetString(bvalue);
        }
        return data;
    }
}

整个的读取速度还是挺快的，经测试，10多万行也就一秒左右。（对我来说还是挺满意的）。有不足的地方还请各路大神多度指教。。