class Property{
    public int Id
    {
        public get;
        private set;        
    }

    public int Value
    {
        public get;
        private set;
    }
}

// Property[0].Length : 2
// Proeprty[1].Length : 3
Property[2][] mPropertyArray;   // 存储表格数据的成员

//快速访问特定等级所加成的属性值
mPropertyArray[1][2]表示第二级所加成的第二个属性数据

using UnityEngine;

using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;

using System.IO;
using System.Runtime.Serialization.Formatters.Binary;

/// <summary>
/// 工具静态类
/// </summary>
public static class Utilities
{
    /// <summary>
    /// 本机打开特定目录(暂时只用于Windows)
    /// </summary>
    /// <param name="folderPath"></param>
    public static void OpenFolder(string folderPath)
    {
        if (Directory.Exists(folderPath))
        {
            ProcessStartInfo startInfo = new ProcessStartInfo(folderPath, "explorer.exe");
            Process.Start(startInfo);
        }
        else
        {
            UnityEngine.Debug.LogError(string.Format("{0} Directory does not exist!", folderPath));
        }
    }

    /// <summary>
    /// 检查指定目录是否存在，不存在创建一个
    /// </summary>
    public static void checkOrCreateSpecificFolder(string folderpath)
    {
        if (!Directory.Exists(folderpath))
        {
            Directory.CreateDirectory(folderpath);
        }
    }

    /// <summary>
    /// 无论目录是否存在都删除所有文件重新创建一个目录
    /// </summary>
    public static void recreateSpecificFolder(string folderpath)
    {
        if (Directory.Exists(folderpath))
        {
            Directory.Delete(folderpath, true);
        }
        Directory.CreateDirectory(folderpath);
    }

    /// <summary>
    /// 获取文件的目录名字
    /// </summary>
    /// <param name="filepath"></param>
    /// <returns></returns>
    public static string getFileFolderName(string filepath)
    {
        return Path.GetFileName(Path.GetDirectoryName(filepath));
    }
}

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

/// <summary>
/// 路径静态工具类
/// </summary>
public static class PathUtilties {

    #region Excel Data
    /// <summary>
    /// Excel数据文件夹目录路径
    /// </summary>
    public static string ExcelFileFolderPath = Application.dataPath + "/../ExcelDatas/Game/";

    /// <summary>
    /// Excel数据生成的对应代码目录
    /// Note:
    /// 因为序列化反序列化时要求Assemble信息一致，所以如果反序列化使用Unity 编译后的C#无法成功反序列化
    /// BinderToType低版本.Net可以用但BinderToName要求.Net 4.0
    /// 所以这里放弃了直接生成新的cs表代码通过Unity编译使用的方案，选择依然采用直接编译表代码成dll来使用
    /// 表代码依然生成，但放到Asset外部作为非有效代码存储方便查看
    /// 参考:
    /// https://stackoverflow.com/questions/505611/binary-deserialization-with-different-assembly-version
    /// https://www.codeproject.com/Tips/1101106/How-to-serialize-across-assemblies-with-the-Binary
    /// </summary>
    public static string ExcelScriptOutputFolderPath = Application.dataPath + "/../DataConfigScripts/";

    /// <summary>
    /// Excel数据序列化后的文件名
    /// </summary>
    public static string ExcelDataFileName = "dataconfig.byte";

    /// <summary>
    /// Excel数据序列化后的数据文件存储目录
    /// </summary>
    public static string ExcelDataFileOutputFolderPath = Application.dataPath + "/Resources/DataConfig/";

    /// <summary>
    /// Excel数据序列化后的数据文件相对于Resource目录的相对目录
    /// </summary>
    public static string ExcelDataFileOutputFolderRelativePath = "DataConfig/";

    /// <summary>
    /// Excel数据生成的对应Assembly&Script临时文件临时目录
    /// </summary>
    public static string ExcelScriptAssemblyFilePath = Application.dataPath + "/Scripts/Core/DataConfig/";

    /// <summary>
    /// Excel数据生成的对应Assembly临时文件名
    /// </summary>
    public static string ExcelScriptAssemblyFileName = "dataconfig.dll";

    /// <summary>
    /// 表格代码文件后缀
    /// </summary>
    public static string ExcelScriptFilePostFix = ".cs";

    /// <summary>
    /// 表格生成数据管理读取代码文件名
    /// </summary>
    public static string ExcelScriptDataManagerFileName = "DataManager.cs";

    /// <summary>
    /// 表代码Container后缀名
    /// </summary>
    public static string ExcelTableContainerPostfix = "Container";
    #endregion
}

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

using UnityEditor;

using Excel;
using System.IO;
using System.Data;
using System.Reflection;
using System.Text;
using Microsoft.CSharp;
using System.CodeDom.Compiler;
using System;
using System.Runtime.Serialization.Formatters.Binary;

/// <summary>
/// 表格数据抽象
/// </summary>
public class ConfigData
{
    /// <summary>
    /// 数据类型
    /// </summary>
    public string Type;

    /// <summary>
    /// 字段名字
    /// </summary>
    public string Name;

    /// <summary>
    /// 数据
    /// </summary>
    public string Data;
}

/// <summary>
/// 导表工具
/// </summary>
public class ExportExcelData {

    /// <summary>
    /// 字段名行号
    /// </summary>
    private const int NameLineNumber = 1;

    /// <summary>
    /// 字段类型行号
    /// </summary>
    private const int TypeLineNumber = 2;

    /// <summary>
    /// 数据开始行号
    /// </summary>
    private const int DataLineNumber = 3;

    /// <summary>
    /// 有效的数据类型
    /// </summary>
    private static List<string> ValideTypesList =  new List<string>(new string[]{"int", "float", "string"});

    [MenuItem("Tools/DataConfig/导出所有表格数据", false, 100)]
    public static void exportAllExcelData()
    {
        string[] excelfiles = Directory.GetFiles(PathUtilties.ExcelFileFolderPath, "*.xlsx");
        // 表格数据映射Map
        // Key为表格名字
        // Value为表格对应的数据列表，List的每一个元素代表一行的数据数组
        Dictionary<string, List<ConfigData[]>> datadic = new Dictionary<string, List<ConfigData[]>>();
        // 字段信息map
        // Key为表格名字
        // Value为对应表格的字段数据
        Dictionary<string, string[]> namedic = new Dictionary<string, string[]>();
        // 字段类型信息map
        // Key为表格名字
        // Value为对应表格的字段类型数据
        Dictionary<string, string[]> typedic = new Dictionary<string, string[]>();
        foreach (var excelfile in excelfiles)
        {
            if(!readAllDataFromExcelFile(excelfile, ref datadic, ref typedic, ref namedic))
            {
                return;
            }
        }

        // 表格代码映射map
        // Key为类名字，Value为对应代码数据
        Dictionary<string, string> codemap = new Dictionary<string, string>();
        //根据刚才记录的每一张表格数据生成对应代码数据
        foreach (var data in datadic)
        {
            string classname = data.Key;
            DataConfigScriptGenerator dcsg = new DataConfigScriptGenerator(classname, typedic[classname], namedic[classname]);
            codemap.Add(classname, dcsg.generateCode());
        }

        //删除前一次所有相关文件
        Utilities.recreateSpecificFolder(PathUtilties.ExcelScriptOutputFolderPath);
        Utilities.recreateSpecificFolder(PathUtilties.ExcelDataFileOutputFolderPath);
        Utilities.recreateSpecificFolder(PathUtilties.ExcelScriptAssemblyFilePath);

        //生成dll，Assemble文件用于序列化数据
        string[] scripts = new string[codemap.Values.Count];
        codemap.Values.CopyTo(scripts, 0);
        var assemblyfilepath = PathUtilties.ExcelScriptAssemblyFilePath + PathUtilties.ExcelScriptAssemblyFileName;
        Assembly assembly = compileCode(scripts, assemblyfilepath);

        if (assembly == null)
        {
            Debug.LogError("编译dll失败！");
            return;
        }

        //使用Assemble序列化数据
        foreach (var data in datadic)
        {
            object container = assembly.CreateInstance(data.Key + "Container");
            Type classtype = assembly.GetType(data.Key);
            if (!serialize(container, classtype, data.Value, PathUtilties.ExcelDataFileOutputFolderPath))
            {
                return;
            }
        }

        // 生成对应Manager加载管理的cs代码文件
        createDataManager(assembly, PathUtilties.ExcelScriptAssemblyFilePath);

        // 生成对应cs代码文件(如果删除dll，使用cs编译的Assembly-CSharp.dll会导致反序列化出问题。猜测是因为Assemly名字改变后，默认的序列化和反序列化的部分信息(e.g. 比如assembly name)对不上。)
        // 所以这里生成的代码仅供查看，释放到Asset上层目录的
        foreach (var code in codemap)
        {
            using (FileStream fs = File.Create(PathUtilties.ExcelScriptOutputFolderPath + code.Key + PathUtilties.ExcelScriptFilePostFix))
            {
                byte[] info = new UTF8Encoding(true).GetBytes(code.Value);
                fs.Write(info, 0, info.Length);
            }
        }

        //删除Assemble文件
        //File.Delete(assemblyfilepath);

        AssetDatabase.Refresh();
    }

    /// <summary>
    /// 读取excel里所有数据
    /// </summary>
    /// <param name="excelfile">excel文件</param>
    /// <param name="datadic">表格数据</param>]
    /// <param name="names">字段数据</param>
    /// <param name="typs">类型数据</param>
    /// <returns></returns>
    private static bool readAllDataFromExcelFile(string excelfile, ref Dictionary<string, List<ConfigData[]>> datadic, ref Dictionary<string, string[]> typesmap, ref Dictionary<string, string[]> namesmap)
    {
        Debug.Log(string.Format("excelfile: {0}", excelfile));
        FileStream fs = File.Open(excelfile, FileMode.Open, FileAccess.Read);
        IExcelDataReader excelreader = ExcelReaderFactory.CreateOpenXmlReader(fs);
        if (!excelreader.IsValid)
        {
            Debug.LogError(string.Format("Excel文件:{0}读取失败！", excelfile));
            return false;
        }
        else
        {
            Debug.Log(string.Format("Excel文件.Name:{0}", excelreader.Name));
            var dataset = excelreader.AsDataSet();
            if (dataset.Tables.Count > 1)
            {
                Debug.LogError(string.Format("Excel文件:{0},不允许一个Excel多张Table!", excelreader.Name));
                return false;
            }
            else if (datadic.ContainsKey(excelreader.Name))
            {
                Debug.LogError(string.Format("有同名的Excel Table存在!同名Excel:{0}!", excelreader.Name));
                return false;
            }
            else
            {
                int currentlinenumber = 1;
                string[] types = null;
                string[] names = null;
                datadic.Add(excelreader.Name, new List<ConfigData[]>());
                while(excelreader.Read())
                {
                    //读取每一行的数据
                    string[] datas = new string[excelreader.FieldCount];
                    for (int i = 0; i < excelreader.FieldCount; i++)
                    {
                        datas[i] = excelreader.GetString(i);
                    }

                    // 字段信息
                    if (currentlinenumber == NameLineNumber)
                    {
                        names = datas;
                        if(checkRepeatedNameString(names))
                        {
                            Debug.LogError(string.Format("Excel Table:{0}", excelreader.Name));
                            return false;
                        }
                        namesmap.Add(excelreader.Name, names);
                    }
                    // 字段类型信息
                    else if(currentlinenumber == TypeLineNumber)
                    {
                        types = datas;
                        if (checkInvalideType(types))
                        {
                            Debug.LogError(string.Format("Excel Table:{0}", excelreader.Name));
                            return false;
                        }
                        typesmap.Add(excelreader.Name, types);
                    }
                    else if(currentlinenumber >= DataLineNumber)
                    {
                        // 记录每一行所有数据的字段名，字段类型，字段数据
                        ConfigData[] configdatas = new ConfigData[datas.Length];
                        for(int m = 0; m < datas.Length; m++)
                        {
                            ConfigData cd = new ConfigData();
                            cd.Type = types[m];
                            cd.Name = names[m];
                            cd.Data = datas[m];
                            if(string.IsNullOrEmpty(cd.Type))
                            {
                                Debug.LogError(string.Format("数据第{0}行，第{1}列字段类型不能为空!", currentlinenumber, m));
                                return false;
                            }
                            else if(string.IsNullOrEmpty(cd.Name))
                            {
                                Debug.LogError(string.Format("数据第{0}行，第{1}列字段名字不能为空!", currentlinenumber, m));
                                return false;
                            }
                            configdatas[m] = cd;
                        }
                        datadic[excelreader.Name].Add(configdatas);
                    }
                    else
                    {
                        Debug.LogError(string.Format("无效的行号:{0}", currentlinenumber));
                        return false;
                    }
                    currentlinenumber++;
                }
                return true;
            }
        }
    }

    /// <summary>
    /// 检查是否有重复的字段名
    /// </summary>
    /// <param name="names"></param>
    /// <returns></returns>
    private static bool checkRepeatedNameString(string[] names)
    {
        var tempdic = new Dictionary<string, string>();
        foreach (var name in names)
        {
            if (tempdic.ContainsKey(name))
            {
                Debug.LogError(string.Format("同名字段:{0}!", name));
                return true;
            }
            else
            {
                tempdic.Add(name, name);
            }
        }
        return false;
    }

    /// <summary>
    /// 检查是否有无效的字段类型
    /// </summary>
    /// <param name="types"></param>
    /// <returns></returns>
    private static bool checkInvalideType(string[] types)
    {
        foreach(var type in types)
        {
            if(!ValideTypesList.Contains(type))
            {
                Debug.LogError(string.Format("无效类型:{0}", type));
                return true;
            }
        }
        return false;
    }

    /// <summary>
    /// 编译代码到dll
    /// </summary>
    /// <param name="scripts"></param>
    /// <param name="outputfile"></param>
    /// <returns>返回Assembly</returns>
    private static Assembly compileCode(string[] scripts, string outputfile)
    {
        //编译参数
        CSharpCodeProvider codeprovider = new CSharpCodeProvider();
        CompilerParameters objcompilerparameters = new CompilerParameters();
        objcompilerparameters.ReferencedAssemblies.AddRange(new string[] { "System.dll" });
        objcompilerparameters.OutputAssembly = outputfile;
        objcompilerparameters.GenerateExecutable = false;
        objcompilerparameters.GenerateInMemory = true;

        //开始编译脚本
        CompilerResults cr = codeprovider.CompileAssemblyFromSource(objcompilerparameters, scripts);
        if (cr.Errors.HasErrors)
        {
            Debug.LogError("编译错误：");
            foreach (CompilerError err in cr.Errors)
                Debug.LogError(err.ErrorText);
            return null;
        }
        return cr.CompiledAssembly;
    }

    /// <summary>
    /// 序列化数据
    /// </summary>
    /// <param name="container">数据容器对象</param>
    /// <param name="type">数据Class类型</param>
    /// <param name="datalist">数据列表</param>
    /// <param name="outputpath">输出目录</param>
    private static bool serialize(object container, Type type, List<ConfigData[]> datalist, string outputpath)
    {
        FieldInfo dictInfo = container.GetType().GetField("Dict");
        object dict = dictInfo.GetValue(container);
        //读取每一行数据并填充到实例对象里
        foreach (var datas in datalist)
        {
            object instance = type.Assembly.CreateInstance(type.FullName);
            //填充实例对象数据
            foreach (var data in datas)
            {
                FieldInfo fieldinfo = type.GetField(data.Name);
                fieldinfo.SetValue(instance, parseValue(data.Type, data.Data));
            }
            //将实例对象数据添加到Container Map里，后续用于序列化数据
            object id = type.GetField("id").GetValue(instance);
            bool isExist = (bool)dict.GetType().GetMethod("ContainsKey").Invoke(dict, new object[] { id });
            if (isExist)
            {
                Debug.LogError("Repetitive key " + id + " in " + container.GetType().Name);
                return false;
            }
            dict.GetType().GetMethod("Add").Invoke(dict, new object[] { id, instance });
        }

        //将数据序列化到本地文件
        var bf = new BinaryFormatter();
        var s = new FileStream(outputpath + type.Name + ".bytes", FileMode.CreateNew, FileAccess.Write);
        bf.Serialize(s, container);
        s.Close();
        return true;
    }

    /// <summary>
    /// 创建生成反序列化加载接口代码
    /// </summary>
    /// <param name="assembly"></param>
    /// <param name="outputpath">输出路径</param>
    /// <returns></returns>
    private static bool createDataManager(Assembly assembly, string outputpath)
    {
        StringBuilder source = new StringBuilder();
        source.Append("/*\n");
        source.Append("\tAuto create\n");
        source.Append("\tDon't Edit it\n");
        source.Append("*/\n");
        source.Append("\n");

        source.Append("using System;\n");
        source.Append("using UnityEngine;\n");
        source.Append("using System.Runtime.Serialization;\n");
        source.Append("using System.Runtime.Serialization.Formatters.Binary;\n");
        source.Append("using System.IO;\n\n");
        source.Append("[Serializable]\n");
        source.Append("public class DataManager : SingletonTemplate<DataManager>\n");
        source.Append("{\n");

        //定义所有Container的成员变量
        var types = assembly.GetTypes();
        foreach(var type in types)
        {
            if(!type.Name.EndsWith(PathUtilties.ExcelTableContainerPostfix))
            {
                continue;
            }
            source.Append("\tpublic " + type.Name + " " + type.Name.Remove(0, 2) + ";\n");
        }
        source.Append("\n");
        
        //加载所有配置表
        source.Append("\tpublic void loadAll()\n");
        source.Append("\t{\n");
        foreach (var type in types)
        {
            if (!type.Name.EndsWith("Container"))
            {
                continue;
            }
            string typeName = type.Name.Remove(type.Name.IndexOf("Container"));
            source.Append("\t\t" + type.Name.Remove(0, 2) + " = Load(" + '"' + typeName + '"' + ") as " + type.Name + ";\n");
        }
        source.Append("\t}\n\n");

        //反序列化接口方法
        source.Append("\tprivate System.Object Load(string name)\n");
        source.Append("\t{\n");
        source.Append("\t\tvar bf = new BinaryFormatter();\n");
        source.Append("\t\tTextAsset text = Resources.Load<TextAsset>(" + '"' + PathUtilties.ExcelDataFileOutputFolderRelativePath + '"' + " + name);\n");
        source.Append("\t\tStream s = new MemoryStream(text.bytes);\n");
        source.Append("\t\tSystem.Object obj = bf.Deserialize(s);\n");
        source.Append("\t\ts.Close();\n");
        source.Append("\t\treturn obj;\n");
        source.Append("\t}\n");

        // 数据加载接口
        foreach (var type in types)
        {
            if (type.Name.EndsWith("Container"))
            {
                continue;
            }
            var classname = type.Name;
            source.Append("\t\n");
            source.Append("\tpublic " + classname + " get" + classname.Substring(2) + "Data(int id)\n");
            source.Append("\t{\n");
            source.Append("\t\t" + classname + " data = null;\n");
            source.Append("\t\t" + classname.Substring(2) + "Container.getMap().TryGetValue(id, out data);\n");
            source.Append("\t\tif(data == null)\n");
            source.Append("\t\t{\n");
            source.Append("\t\t\tDebug.LogError(string.Format(\"表格:{ 0}找不到id: { 1}的数据!\", data.GetType().ToString(), id));\n");
            source.Append("\t\t}\n");
            source.Append("\t\treturn data;\n");
            source.Append("\t}\n");
        }

        source.Append("}\n");

        //保存脚本
        StreamWriter sw = new StreamWriter(outputpath + PathUtilties.ExcelScriptDataManagerFileName);
        sw.WriteLine(source.ToString());
        sw.Close();
        return true;
    }

    /// <summary>
    /// 根据字符串解析类型(暂时只支持基础类型)
    /// </summary>
    /// <param name="type"></param>
    /// <param name="data"></param>
    /// <returns></returns>
    private static object parseValue(string type, string data)
    {
        if (type.Equals("string"))
        {
            return data;
        }
        else if(type.Equals("int"))
        {
            return int.Parse(data);
        }
        else if(type.Equals("float"))
        {
            return float.Parse(data);
        }
        else
        {
            Debug.LogError(string.Format("类型字符串:{0}不支持该类型数据解析!", type));
            return data;
        }
    }
}

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

/// <summary>
/// 导表代码生成工具
/// </summary>
public class DataConfigScriptGenerator {

    /// <summary>
    /// 类名
    /// </summary>
    public string ClassName
    {
        get;
        private set;
    }

    /// <summary>
    /// 成员字段类型数据
    /// </summary>
    public string[] TypeDatas
    {
        get;
        private set;
    }

    /// <summary>
    /// 成员字段名字数据
    /// </summary>
    public string[] TypeNameDatas
    {
        get;
        private set;
    }

    public DataConfigScriptGenerator(string classname, string[] typedatas, string[] typenamedatas)
    {
        ClassName = classname;
        TypeDatas = typedatas;
        TypeNameDatas = typenamedatas;
    }

    /// <summary>
    /// 生成对应表代码外部接口
    /// </summary>
    /// <returns></returns>
    public string generateCode()
    {
        if(string.IsNullOrEmpty(ClassName) || TypeDatas == null || TypeNameDatas == null)
        {
            return null;
        }
        return generateRealCode();
    }

    /// <summary>
    /// 生成表代码
    /// </summary>
    /// <returns></returns>
    private string generateRealCode()
    {
        //生成类文件头
        StringBuilder classsource = new StringBuilder();
        classsource.Append("/*\n");
        classsource.Append("\tAuto create\n");
        classsource.Append("\tDon't Edit it\n");
        classsource.Append("*/\n");
        classsource.Append("\n");
        classsource.Append("using System;\n");
        classsource.Append("using System.Reflection;\n");
        classsource.Append("using System.Collections.Generic;\n");
        classsource.Append("\n");
        classsource.Append("[Serializable]\n");
        classsource.Append("public class " + ClassName + "\n");
        classsource.Append("{\n");

        //生成成员声明数据
        for(int i = 0; i < TypeDatas.Length; i++)
        {
            classsource.Append(filedString(TypeDatas[i], TypeNameDatas[i]));
        }
        classsource.Append("}\n");

        //生成Container
        classsource.Append("\n");
        classsource.Append("[Serializable]\n");
        classsource.Append("public class " + ClassName + PathUtilties.ExcelTableContainerPostfix + "\n");
        classsource.Append("{\n");
        classsource.Append("\tpublic " + "Dictionary<int, " + ClassName + ">" + " Dict" + " = new Dictionary<int, " + ClassName + ">();\n");
        classsource.Append("\tpublic " + "Dictionary<int, " + ClassName + ">" + " getMap()\n");
        classsource.Append("\t{\n");
        classsource.Append("\t\treturn Dict;\n");
        classsource.Append("\t}\n");
        classsource.Append("}\n");

        return classsource.ToString();
    }

    /// <summary>
    /// 成员声明数据
    /// </summary>
    /// <param name="type">成员类型</param>
    /// <param name="field">成员名</param>
    /// <returns></returns>
    private string filedString(string type, string field)
    {
        if (string.IsNullOrEmpty(type) || string.IsNullOrEmpty(field))
            return null;

        StringBuilder sbProperty = new StringBuilder();
        sbProperty.Append("\tpublic " + type + " " + field + ";\n");
        return sbProperty.ToString();
    }
}

/*
    Auto create
    Don't Edit it
*/

using System;
using System.Reflection;
using System.Collections.Generic;

[Serializable]
public class t_game
{
    public int id;
    public string author;
    public string sex;
    public int age;
    public float money;
}

[Serializable]
public class t_gameContainer
{
    public Dictionary<int, t_game> Dict = new Dictionary<int, t_game>();
    public Dictionary<int, t_game> getMap()
    {
        return Dict;
    }
}

GUILayout.BeginHorizontal();
if (GUILayout.Button("加载所有表格数据", GUILayout.MaxWidth(250.0f), GUILayout.MaxHeight(50.0f)))
{
    Debug.Log("加载所有表格数据");
    DataManager.Singleton.loadAll();
}
if (GUILayout.Button("打印所有表格数据", GUILayout.MaxWidth(250.0f), GUILayout.MinHeight(50.0f)))
{
    Debug.Log("打印所有表格数据");
    for (int i = 1; i <= DataManager.Singleton.gameContainer.Dict.Count; i++)
    {
        var data = DataManager.Singleton.getgameData(i);
        Debug.Log(string.Format("data.id : {0}, data.author : {1}, data.age : {2}, data.sex : {3}, data.money : {4}", data.id, data.author, data.age, data.sex, data.money));
    }
}
GUILayout.EndHorizontal();

private static long mHeapMemorySize;
/// <summary>
/// 显示堆内存使用准备工作(在调用ShowHeapMemoryUsing打印堆内存分配之前调用此方法确保计算显示的堆内存数据申请正确)
/// </summary>
private static void TonyTangShowHeapMemoryUsingPrepration()
{
    // 确保得到正确的起始Heap Memory Size
    GC.Collect();
    mHeapMemorySize = GC.GetTotalMemory(true);
}

/// <summary>
/// 显示堆内存使用情况
/// </summary>
/// <param name="postfix"></param>
private static void TonyTangShowHeapMemoryUsing(string postfix)
{
    var newestheapmemorysize = GC.GetTotalMemory(false);
    var heapmemoryoffset = newestheapmemorysize - mHeapMemorySize;
    Console.WriteLine(string.Format("Heap Memory Size = {0} Pre Memory Size = {1} Memory Offset = {2} -- {3}", newestheapmemorysize, mHeapMemorySize, heapmemoryoffset, postfix));
    mHeapMemorySize = newestheapmemorysize;
}

//Note:
//注释掉的部分就是自定义序列化和反序列化的代码部分
[Serializable]
public class Map //: ISerializable, IDeserializationCallback
{
    //Special construct(required by ISerializable) to control deserialization
    //[SecurityPermissionAttribute(SecurityAction.Demand, SerializationFormatter = true)]
    //protected Map(SerializationInfo info, StreamingContext context)
    //{
    //    m_SiInfo = info;
    //}

    //[SecurityPermissionAttribute(SecurityAction.Demand, SerializationFormatter = true)]
    //public virtual void GetObjectData(SerializationInfo info, StreamingContext context)
    //{
    //    info.AddValue("mID", mID);
    //    info.AddValue("mMapName", mMapName);
    //}

    //void IDeserializationCallback.OnDeserialization(Object sender)
    //{
    //    if (m_SiInfo == null)
    //    {
    //        return;
    //    }

    //    mID = m_SiInfo.GetInt32("mID");
    //    mMapName = m_SiInfo.GetString("mMapName");
    //}

    //private SerializationInfo m_SiInfo;

    public Map()
    {
        mID = 0;
        mMapName = "DefaultMap";
    }

    public int ID
    {
        get
        {
            return mID;
        }
        set
        {
            mID = value;
        }

    }
    private int mID;

    public string MapName
    {
        get
        {
            return mMapName;
        }
        set
        {
            mMapName = value;
        }
    }
    private string mMapName;
}

//Serialization
string mMapSavePath = "./mapInfo.dat";
for(int id = 0; id < 500; id++)
{
    Map map = new Map();
    map.ID = id;
    map.MapName = id.ToString();
    BinaryFormatter bf = new BinaryFormatter();
    var mapsavepath = mMapSavePath + id;
    if (!File.Exists(mapsavepath))
    {
        FileStream fsc = File.Create(mapsavepath);
        fsc.Close();
    }

    FileStream fs = File.Open(mapsavepath, FileMode.Open);
    bf.Serialize(fs, map);
    fs.Close();
}

//Deserialization
ShowHeapMemoryUsingPrepration();
TimeCounter.Singleton.Restart("Deserialization");
Map mDSMap;
BinaryFormatter dsbf = new BinaryFormatter ();
for (int id = 0; id < 500; id++)
{
    var mapsavepath = mMapSavePath + id;
    if (File.Exists(mapsavepath))
    {
        FileStream dsfs = File.Open(mapsavepath, FileMode.Open);
        mDSMap = (Map)dsbf.Deserialize(dsfs);
        dsfs.Close();
    }
}
TimeCounter.Singleton.End();
ShowHeapMemoryUsing("Serialization");

Install-Package protobuf-net

using UnityEngine;
using System.Collections;
using ProtoBuf;

[ProtoContract]
public class PlayerData {
    [ProtoMember(1)]
    public string SceneName
    {
        get;
        set;
    }

    [ProtoMember(2)]
    public int Scores
    {
        get;
        set;
    }

    [ProtoMember(3)]
    public int SpeedLevel
    {
        get;
        set;
    }
}

public void Awake()
{
   ......

    mPlayerData = new PlayerData();

    mProfilePath =  Application.persistentDataPath + "/PlayerProile.bin";
    Debug.Log("mProfilePath = " + mProfilePath);
}

public void SavePlayerData()
{
    //Do serialization for player data
    FileStream profile;
    if(File.Exists(mProfilePath))
    {
        profile = File.Open(mProfilePath, FileMode.Open);
        Serializer.Serialize(profile, mPlayerData);
    }
    else
    {
        profile = File.Create(mProfilePath);
        Serializer.Serialize(profile, mPlayerData);
    }
}

private void LoadPlayerData()
{
    FileStream profile;
    if(File.Exists(mProfilePath))
    {
        profile = File.OpenRead(mProfilePath);
        mPlayerData = Serializer.Deserialize<PlayerData>(profile);
    }
    else
    {
        mPlayerData = new PlayerData();
        mPlayerData.SceneName = Application.productName;
        mPlayerData.Scores = 0;
        mPlayerData.SpeedLevel = 1;
        SavePlayerData();
    }
}

//PlayerData.proto
syntax = "proto2";

package NGUI2DGame;

message PlayerData{
    optional string SceneName = 1;
    optional int32 Scores = 2;
    optional int32 SpeedLevel = 3;
}

protogen -i:PlayerData.proto -o:PlayerData.cs -ns:NGUI2DGame

precompile PlayerData.dll -o:ProtobufSerializer.dll -t:com.TonyTang.ProtobufSerializer

//Serialization
ProtobufSerializer serializer = new ProtobufSerializer();       
profile = File.Open(mProfilePath, FileMode.Open);
serializer.Serialize(profile, mPlayerData);
//Deserialization
profile = File.OpenRead(mProfilePath);
mPlayerData = serializer.Deserialize(profile,null,typeof(PlayerData)) as PlayerData;

/*
 * Description:             UIDebugMonoScript.cs
 * Author:                  TONYTANG
 * Create Date:             2018/08/19
 */

using GameData;
using Google.Protobuf;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using UnityEngine;
using UnityEngine.UI;

/// <summary>
/// UIDebugMonoScript.cs
/// 快速访问UI组件测试挂在脚本
/// </summary>
public class UIDebugMonoScript : MonoBehaviour {

    /// <summary>
    /// 创建GameConfig按钮
    /// </summary>
    public Button mBtnCreateGameConfig;

    /// <summary>
    /// 读取GameConfig按钮
    /// </summary>
    public Button mBtnReadGameConfig;
    
    private void Start()
    {
        mBtnCreateGameConfig.onClick.AddListener(onCreateGameConfigClick);
        mBtnReadGameConfig.onClick.AddListener(onReadGameConfigClick);
    }

    private void OnDestroy()
    {
        mBtnCreateGameConfig.onClick.RemoveAllListeners();
        mBtnReadGameConfig.onClick.RemoveAllListeners();
    }

    /// <summary>
    /// 创建GameConfig按钮点击
    /// </summary>
    private void onCreateGameConfigClick()
    {
        Debug.Log("onCreateGameConfigClick()");
        Debug.Log("PathUtilities.ProtobufDataFolderPath : " + PathUtilities.ProtobufDataFolderPath);
        PathUtilities.checkAndCreateFolder(PathUtilities.ProtobufDataFolderPath);
        GameConfig gameconfig = new GameConfig();
        gameconfig.DifficultyLevel = "Easy";
        gameconfig.VersionNumber = 1;
        gameconfig.ResourceNumber = 1;
        using (var output = File.Create(PathUtilities.ProtobufDataFolderPath + "GameConfig.data"))
        {
            gameconfig.WriteTo(output);
        }
    }

    /// <summary>
    /// 读取GameConfig按钮点击
    /// </summary>
    private void onReadGameConfigClick()
    {
        Debug.Log("onReadGameConfigClick()");
        Debug.Log("PathUtilities.ProtobufDataFolderPath : " + PathUtilities.ProtobufDataFolderPath);
        GameConfig gameconfig;
        using (var intput = File.OpenRead(PathUtilities.ProtobufDataFolderPath + "GameConfig.data"))
        {
            gameconfig = GameConfig.Parser.ParseFrom(intput);
        }
        Debug.Log("gameconfig.DifficultyLevel : " + gameconfig.DifficultyLevel);
        Debug.Log("gameconfig.VersionNumber : " + gameconfig.VersionNumber);
        Debug.Log("gameconfig.ResourceNumber : " + gameconfig.ResourceNumber);
    }
}

/*
 * Description:             路径静态工具类
 * Author:                  tanghuan
 * Create Date:             2018/03/12
 */

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

/// <summary>
/// 路径静态工具类
/// </summary>
public static class PathUtilities
{
    //******

    #region Protobuf
#if UNITY_EDITOR
    /// <summary>
    /// Protobuf生成数据目录
    /// </summary>
    public static string ProtobufDataFolderPath = Application.dataPath + "/Resources/ProtoData/";
#elif UNITY_ANDROID
    public static string ProtobufDataFolderPath = Application.temporaryCachePath + "/ProtoData/";
#elif UNITY_IOS
    public static string ProtobufDataFolderPath = Application.temporaryCachePath + "/ProtoData/";
#endif
    #endregion

    #region 公用方法
    /// <summary>
    /// 检查并确保目录存在
    /// </summary>
    /// <param name="folderpath"></param>
    public static void checkAndCreateFolder(string folderpath)
    {
        if(!Directory.Exists(folderpath))
        {
            Directory.CreateDirectory(folderpath);
        }
    }
    #endregion
}