DemoCommon.BinaryTable.Load C# (CSharp) Method

        public void Load(string file)
        {
            try {
                using (FileStream fs = new FileStream(file, FileMode.Open, FileAccess.Read, FileShare.Read)) {
                    FileHeader header = ReadFileHeader(fs);
                    if (header.m_Identity == c_Identity && header.m_Version == c_Version) {
                        Reset();

                        for (int i = 0; i < header.m_RecordNum && fs.Position < fs.Length; ++i) {
                            byte[] bytes = new byte[header.m_RecordSize];
                            fs.Read(bytes, 0, header.m_RecordSize);
                            m_Records.Add(bytes);
                        }

                        if (m_Records.Count > 0) {
                            fs.Position = header.m_StringOffset;
                            m_StringList = new List<string>(ReadStrArray(fs));

                            fs.Position = header.m_IntListOffset;
                            m_IntLists = new List<int>(ReadIntArray(fs));

                            fs.Position = header.m_FloatListOffset;
                            m_FloatLists = new List<float>(ReadFloatArray(fs));

                            fs.Position = header.m_StrListOffset;
                            m_StrLists = new List<int>(ReadIntArray(fs));

                            Update();

                            bool haveError = false;
                            int recordSize = m_Records[0].Length;
                            int recordNum = m_Records.Count;
                            for (int i = 1; i < recordNum; ++i) {
                                if (m_Records[i].Length != recordSize) {
                                    LogSystem.Error("Record Size not equal, {0}!={1}({2})", recordSize, m_Records[i].Length, i);
                                    haveError = true;
                                }
                            }
                            if (haveError) {
                                Reset();
                            }
                        }
                    } else {
                        LogSystem.Error("Unknown binary file tag {0} or error version {1}", header.m_Identity, header.m_Version);
                    }
                    fs.Close();
                }
            } catch (Exception ex) {
                LogSystem.Error("Exception:{0}\n{1}", ex.Message, ex.StackTrace);
            }
        }

        public bool LoadFromBinary(string file)
        {
            long        t1     = TimeUtility.GetElapsedTimeUs();
            bool        result = true;
            BinaryTable table  = new BinaryTable();

            table.Load(HomePath.GetAbsolutePath(file));
            long t2 = TimeUtility.GetElapsedTimeUs();

            long t3 = TimeUtility.GetElapsedTimeUs();

            for (int index = 0; index < table.Records.Count; ++index)
            {
                try {
                    TData  data = new TData();
                    bool   ret  = data.ReadFromBinary(table, index);
                    string info = string.Format("DataTableMgr.CollectDataFromBinary collectData Row:{0} failed!", index);
                    LogSystem.Assert(ret, info);
                    if (ret)
                    {
                        m_DataContainer.Add(data);
                    }
                    else
                    {
                        result = false;
                    }
                } catch (System.Exception ex) {
                    LogSystem.Error("CollectData failed. file:{0} rowIndex:{1}\nException:{2}\n{3}", file, index, ex.Message, ex.StackTrace);
                }
            }
            long t4 = TimeUtility.GetElapsedTimeUs();

            LogSystem.Info("binary load {0} parse {1}, file {2}", t2 - t1, t4 - t3, file);
            return(result);
        }