读取dbf类

  /// <summary>
    /// .dbf 文件的字段信息类
    /// </summary>
    internal class DBFField
    {
        public const int DBFFieldSize = 32;
        /* 字段名称 */
        public byte[] Name = new byte[11];
        /* 字段类型 C - 字符型  
                   Y - 货币型  
                   N - 数值型  
                   F - 浮点型  
                   D - 日期型  
                   T - 日期时间型  
                   B - 双精度型  
                   I - 整型  
                   L - 逻辑型 
                   M - 备注型  
                   G - 通用型  
                   C - 字符型（二进制） 
                   M - 备注型（二进制） 
                   P - 图片型  
       */
        public sbyte Type;
        /* 字段偏移量 */
        public uint Offset;
        /* 字段长度 */
        public byte Length;
        /* 浮点数小数部分长度 */
        public byte Precision;
        /* 保留 */
        public byte[] Reserved = new byte[2];
        /* dBASE IV work area id */
        public sbyte DbaseivID;
        /* */
        public byte[] Reserved2 = new byte[10];
        /* */
        public sbyte ProductionIndex;
    }

/// <summary>
    /// .dbf文件操作类
    /// </summary>
    public class DBFFile : IDisposable
    {
        private const string MSG_OPEN_FILE_FAIL = "不能打开文件{0}";

        private bool _isFileOpened;
        private byte[] _recordBuffer;
        private DBFField[] _dbfFields;
        private System.IO.FileStream _fileStream = null;
        private System.IO.BinaryReader _binaryReader = null;
        private string _fileName = string.Empty;
        private uint _fieldCount = 0;
        private int _recordIndex = -1;
        private uint _recordCount = 0;
        private DBFHeader _dbfHeader = null;

        /// <summary>
        /// 构造函数
        /// </summary>
        public DBFFile()
        {
        }

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="fileName"></param>
        public DBFFile(string fileName)
        {
            if (null != fileName && 0 != fileName.Length)
                this._fileName = fileName;
        }

        /// <summary>
        /// 清理所有正在使用的资源。
        /// </summary>
        protected virtual void Dispose(bool disposing)
        {
            if (disposing)
            {
                this._recordBuffer = null;
                this._dbfHeader = null;
                this._dbfFields = null;

                if (this.IsFileOpened && null != this._fileStream)
                {
                    this._fileStream.Close();
                    this._binaryReader.Close();
                }
                this._fileStream = null;
                this._binaryReader = null;

                this._isFileOpened = false;
                this._fieldCount = 0;
                this._recordCount = 0;
                this._recordIndex = -1;
            }
        }

        /// <summary>
        /// 打开dbf文件
        /// </summary>
        /// <returns></returns>
        public bool Open()
        {
            try
            {
                return this.Open(null);
            }
            catch (Exception e)
            {
                throw e;
            }
        }

        /// <summary>
        /// 打开dbf文件
        /// </summary>
        /// <param name="fileName"></param>
        /// <returns></returns>
        public bool Open(string fileName)
        {
            if (null != fileName)
                this._fileName = fileName;

            bool ret = false;

            try
            {
                if (!this.OpenFile())
                {
                    // 不能打开dbf文件，抛出不能打开文件异常
                    throw new Exception(string.Format(MSG_OPEN_FILE_FAIL, this._fileName));
                }

                // 读取文件头信息
                ret = this.ReadFileHeader();

                // 读取所有字段信息
                if (ret)
                    ret = this.ReadFields();

                // 分配记录缓冲区
                if (ret && null == this._recordBuffer)
                {
                    this._recordBuffer = new byte[this._dbfHeader.RecordLength];

                    if (null == this._recordBuffer)
                        ret = false;
                }

                // 如果打开文件或读取信息不成功，关闭dbf文件
                if (!ret)
                    this.Close();
            }
            catch (Exception e)
            {
                throw e;
            }

            // 设置当前记录索引为
            this._recordIndex = -1;

            // 返回打开文件并且读取信息的成功状态
            return ret;
        }

        /// <summary>
        /// 获取dbf表文件对应的DataSet
        /// </summary>
        /// <returns></returns>
        public System.Data.DataSet GetDataSet()
        {
            // 确保文件已经打开
            if (!this.IsFileOpened || (this.IsBOF && this.IsEOF))
                return null;

            // 构造表格
            System.Data.DataSet ds = new System.Data.DataSet();
            System.Data.DataTable dt = new System.Data.DataTable(System.IO.Path.GetFileNameWithoutExtension(this._fileName));

            try
            {
                // 添加表格列
                for (uint i = 0; i < this._fieldCount; i++)
                {
                    System.Data.DataColumn col = new System.Data.DataColumn();
                    string colText = string.Empty;

                    // 获取并设置列标题
                    if (this.GetFieldName(i, ref colText))
                    {
                        col.ColumnName = colText;
                        col.Caption = colText;
                    }

                    // 设置列类型
                    switch (this._dbfFields[i].Type)
                    {
                        // C - 字符型、字符型（二进制）
                        case (sbyte)‘C‘:
                            col.DataType = typeof(System.String);
                            break;
                        // Y - 货币型
                        case (sbyte)‘Y‘:
                            col.DataType = typeof(System.Decimal);    // 虽然dbf中‘Y‘长度为64位，但是Double的精度不够，所以指定Decimal
                            break;
                        // N - 数值型
                        case (sbyte)‘N‘:
                            col.DataType = typeof(System.Decimal);    // dbf中‘N‘的精度可以达到19，所以用Decimal
                            break;
                        // F - 浮点型
                        case (sbyte)‘F‘:
                            col.DataType = typeof(System.Decimal);    // dbf中‘F‘的精度可以达到19，所以用Decimal
                            break;
                        // D - 日期型
                        case (sbyte)‘D‘:
                            col.DataType = typeof(System.DateTime);
                            break;
                        // T - 日期时间型
                        case (sbyte)‘T‘:
                            col.DataType = typeof(System.DateTime);
                            break;
                        // B - 双精度型
                        case (sbyte)‘B‘:
                            col.DataType = typeof(System.Double);
                            break;
                        // I - 整型
                        case (sbyte)‘I‘:
                            col.DataType = typeof(System.Int32);
                            break;
                        // L - 逻辑型
                        case (sbyte)‘L‘:
                            col.DataType = typeof(System.Boolean);
                            break;
                        // M - 备注型、备注型（二进制）
                        case (sbyte)‘M‘:
                            col.DataType = typeof(System.String);
                            break;
                        // G - 通用型
                        case (sbyte)‘G‘:
                            col.DataType = typeof(System.String);
                            break;
                        // P - 图片型
                        case (sbyte)‘P‘:
                            col.DataType = typeof(System.String);
                            break;
                        // 缺省字符串型
                        default:
                            col.DataType = typeof(System.String);
                            break;
                    }

                    // 添加列信息
                    dt.Columns.Add(col);
                }

                // 添加所有的记录信息
                this.MoveFirst();

                while (!this.IsEOF)
                {
                    // 创建新记录行
                    System.Data.DataRow row = dt.NewRow();

                    // 循环获取所有字段信息，添加到新的记录行内
                    for (uint i = 0; i < this._fieldCount; i++)
                    {
                        string temp = string.Empty;

                        if (this._dbfFields[i].Offset > this._recordBuffer.Length)
                        {
                            this._recordCount = Convert.ToUInt32(this._recordIndex);
                            break;
                        }

                        // 获取字段值成功后才添加到记录行中
                        if (this.GetFieldValue(i, ref temp))
                        {
                            // 如果获取的字段值为空，设置DataTable里字段值为DBNull
                            //                            if (string.Empty != temp)
                            row[(int)i] = temp.Trim();
                            //                            else
                            //                                row[(int)i] = System.DBNull.Value;
                        }

                    }

                    // 添加记录行
                    if (!this.IsEOF)
                    {
                        dt.Rows.Add(row);

                        // 后移记录
                        this.MoveNext();
                    }
                }
            }
            catch (Exception e)
            {
                throw e;
            }

            ds.Tables.Add(dt);
            return ds;
        }

        /// <summary>
        /// 获取相应索引序号处的字段名称
        /// </summary>
        /// <param name="fieldIndex"></param>
        /// <param name="fieldName"></param>
        /// <returns></returns>
        public bool GetFieldName(uint fieldIndex, ref string fieldName)
        {
            // 确保文件已经打开
            if (!this.IsFileOpened)
                return false;

            // 索引边界检查
            if (fieldIndex >= this._fieldCount)
            {
                fieldName = string.Empty;
                return false;
            }

            try
            {
                // 反解码
                fieldName = System.Text.Encoding.Default.GetString(this._dbfFields[fieldIndex].Name).Replace("\0", "");

                return true;
            }
            catch (Exception e)
            {
                throw e;
            }
        }

        /// <summary>
        /// 获取相应索引序号处的字段文本值
        /// </summary>
        /// <param name="fieldIndex"></param>
        /// <param name="fieldValue"></param>
        /// <returns></returns>
        public bool GetFieldValue(uint fieldIndex, ref string fieldValue)
        {
            // 安全性检查
            //if (!this.IsFileOpened || this.IsBOF || this.IsEOF || null == this._recordBuffer)
            if (!this.IsFileOpened || this.IsEOF || null == this._recordBuffer)
                return false;

            // 字段索引超过最大值
            if (fieldIndex >= this._fieldCount)
            {
                fieldValue = string.Empty;
                return false;
            }

            try
            {
                uint offset = 0;
                for (int i = 0; i < fieldIndex; i++)
                {
                    offset += _dbfFields[i].Length;
                }

                this._dbfFields[fieldIndex].Offset = offset;

                // 从记录缓冲区中获取对应字段的byte[]
                byte[] tmp = GetSubBytes(this._recordBuffer, this._dbfFields[fieldIndex].Offset,
                    this._dbfFields[fieldIndex].Length);

                //
                // 开始byte数组的反解码过程
                //
                if (((sbyte)‘I‘) == this._dbfFields[fieldIndex].Type)
                {
                    // 整形字段的反解码过程
                    int num1 = Byte2Int32(tmp);
                    fieldValue = num1.ToString();
                }
                else if (((sbyte)‘B‘) == this._dbfFields[fieldIndex].Type)
                {
                    // 双精度型字段的反解码过程
                    double num1 = Byte2Double(tmp);
                    fieldValue = num1.ToString();
                }
                else if (((sbyte)‘Y‘) == this._dbfFields[fieldIndex].Type)
                {
                    //
                    // 货币型字段的反解码过程
                    // 货币型存储的时候应该是将字段值放大10000倍，变成long型存储
                    // 所以先将byte数组恢复成long类型数值，然后缩小10000倍。
                    //
                    long num1 = Byte2Int64(tmp);
                    fieldValue = (((decimal)num1) / 10000).ToString();
                }
                else if (((sbyte)‘D‘) == this._dbfFields[fieldIndex].Type)
                {
                    //
                    // 日期型字段的反解码过程
                    //
                    DateTime date1 = Byte2Date(tmp);
                    fieldValue = date1.ToShortDateString();
                }
                else if (((sbyte)‘T‘) == this._dbfFields[fieldIndex].Type)
                {
                    //
                    // 日期时间型字段的反解码过程
                    //
                    DateTime date1 = Byte2DateTime(tmp);
                    fieldValue = date1.ToString();
                }
                else
                {
                    // 其他字段值与字符存储方式类似，直接反解码成字符串就可以
                    fieldValue = System.Text.Encoding.Default.GetString(tmp);
                }

                // 消除字段数值的首尾空格
                fieldValue = fieldValue.Replace("\0", "");

                // 如果本子段类型是数值相关型，进一步处理字段值
                if (((sbyte)‘N‘) == this._dbfFields[fieldIndex].Type ||    // N - 数值型
                    ((sbyte)‘F‘) == this._dbfFields[fieldIndex].Type)    // F - 浮点型
                {
                    if (0 == fieldValue.Length)
                        // 字段值为空，设置为0
                        fieldValue = "0";
                    else if ("." == fieldValue)
                        // 字段值为"."，也设置为0
                        fieldValue = "0";
                    else if (fieldValue.Equals("         -"))
                        // 字段值为"."，也设置为0
                        fieldValue = "0";
                    else if (fieldValue.Equals("   -.---"))
                        // 字段值为"."，也设置为0
                        fieldValue = "0";
                    else
                    {
                        // 将字段值先转化为Decimal类型然后再转化为字符串型，消除类似“.000”的内容
                        // 如果不能转化则为0
                        try
                        {
                            fieldValue = System.Convert.ToDecimal(fieldValue).ToString();


                        }
                        catch (Exception)
                        {
                            fieldValue = "0";
                        }
                    }
                }
                // 逻辑型字段
                else if (((sbyte)‘L‘) == this._dbfFields[fieldIndex].Type)    // L - 逻辑型
                {
                    if ("T" != fieldValue)
                        fieldValue = "false";
                    else
                        fieldValue = "true";
                }
                // 日期型字段
                else if (((sbyte)‘D‘) == this._dbfFields[fieldIndex].Type ||    // D - 日期型
                    ((sbyte)‘T‘) == this._dbfFields[fieldIndex].Type)    // T - 日期时间型
                {
                    // 暂时不做任何处理
                }

                return true;
            }
            catch (Exception e)
            {
                throw e;
            }
        }

        /// <summary>
        /// 获取buf的子数组
        /// </summary>
        /// <param name="buf"></param>
        /// <param name="startIndex"></param>
        /// <param name="length"></param>
        /// <returns></returns>
        private static byte[] GetSubBytes(byte[] buf, uint startIndex, long length)
        {
            // 参数检查
            if (null == buf)
            {
                throw new ArgumentNullException("buf");
            }
            if (startIndex >= buf.Length)
            {
                throw new ArgumentOutOfRangeException("startIndex");
            }
            if (0 == length)
            {
                throw new ArgumentOutOfRangeException("length", "参数length必须大于0");
            }
            if (length > buf.Length - startIndex)
            {
                // 子数组的长度超过从startIndex起到buf末尾的长度时，修正为剩余长度
                length = buf.Length - startIndex;
            }

            byte[] target = new byte[length];

            // 逐位复制
            for (uint i = 0; i < length; i++)
            {
                target[i] = buf[startIndex + i];
            }

            // 返回buf的子数组
            return target;
        }

        /// <summary>
        /// byte数组存储的数值转换为int32类型
        /// </summary>
        /// <param name="buf"></param>
        /// <returns></returns>
        private static int Byte2Int32(byte[] buf)
        {
            // 参数检查
            if (null == buf)
            {
                // 参数为空
                throw new ArgumentNullException("buf");
            }
            if (4 != buf.Length)
            {
                // 如果参数buf的长度不为4，抛出参数异常
                throw new ArgumentException("函数Byte2Int32(byte[])的参数必须是长度为4的有效byte数组", "buf");
            }

            // byte[] 解码成 int
            return (int)((((buf[0] & 0xff) | (buf[1] << 8)) | (buf[2] << 0x10)) | (buf[3] << 0x18));
        }

        /// <summary>
        /// byte数组存储的数值转换为int64类型
        /// </summary>
        /// <param name="buf"></param>
        /// <returns></returns>
        private static long Byte2Int64(byte[] buf)
        {
            // 参数检查
            if (null == buf)
            {
                // 参数为空
                throw new ArgumentNullException("buf");
            }
            if (8 != buf.Length)
            {
                // 如果参数buf的长度不为4，抛出参数异常
                throw new ArgumentException("函数Byte2Int64(byte[])的参数必须是长度为8的有效byte数组", "buf");
            }

            // byte[] 解码成 long
            uint num1 = (uint)(((buf[0] | (buf[1] << 8)) | (buf[2] << 0x10)) | (buf[3] << 0x18));
            uint num2 = (uint)(((buf[4] | (buf[5] << 8)) | (buf[6] << 0x10)) | (buf[7] << 0x18));

            return (long)(((ulong)num2 << 0x20) | num1);
        }

        /// <summary>
        /// byte数组存储的数值转换为double类型
        /// </summary>
        /// <param name="buf"></param>
        /// <returns></returns>
        private static double Byte2Double(byte[] buf)
        {
            // 参数检查
            if (null == buf)
            {
                // 参数为空
                throw new ArgumentNullException("buf");
            }
            if (8 != buf.Length)
            {
                // 如果参数buf的长度不为8，抛出参数异常
                throw new ArgumentException("函数Byte2Double(byte[])的参数必须是长度为8的有效byte数组", "buf");
            }

            double num1 = 0;
            unsafe
            {    // 在unsafe环境下使用指针
                fixed (byte* numRef1 = buf)
                {
                    num1 = *((double*)numRef1);
                }
            }

            return num1;
        }

        /// <summary>
        /// byte数组存储的数值转换为只包含日期的DateTime类型
        /// </summary>
        /// <param name="buf"></param>
        /// <returns></returns>
        private static DateTime Byte2Date(byte[] buf)
        {
            // 参数检查
            if (null == buf)
            {
                // 参数为空
                throw new ArgumentNullException("buf");
            }
            if (8 != buf.Length)
            {
                // 如果参数buf的长度不为8，抛出参数异常
                throw new ArgumentException("函数Byte2DateTime(byte[])的参数必须是长度为8的有效byte数组", "buf");
            }

            try
            {
                string str1 = System.Text.Encoding.Default.GetString(buf);
                if (str1.Trim().Length < 8)
                    return new DateTime(1000, 1, 1);
                int year = int.Parse(str1.Substring(0, 4));
                int month = int.Parse(str1.Substring(4, 2));
                int day = int.Parse(str1.Substring(6, 2));

                return new DateTime(year, month, day);
            }
            catch (Exception e)
            {
                throw e;

            }
        }

        /// <summary>
        /// byte数组存储的数值转换为DateTime类型
        /// byte数组为8位，前32位存储日期的相对天数，后32位存储时间的总毫秒数
        /// </summary>
        /// <param name="buf"></param>
        /// <returns></returns>
        private static DateTime Byte2DateTime(byte[] buf)
        {
            // 参数检查
            if (null == buf)
            {
                // 参数为空
                throw new ArgumentNullException("buf");
            }
            if (8 != buf.Length)
            {
                // 如果参数buf的长度不为8，抛出参数异常
                throw new ArgumentException("函数Byte2DateTime(byte[])的参数必须是长度为8的有效byte数组", "buf");
            }

            try
            {
                byte[] tmp = GetSubBytes(buf, 0, 4);
                tmp.Initialize();
                // 获取天数
                int days = Byte2Int32(tmp);

                // 获取毫秒数
                tmp = GetSubBytes(buf, 4, 4);
                int milliSeconds = Byte2Int32(tmp);

                // 在最小日期时间的基础上添加刚获取的天数和毫秒数，得到日期字段数值
                DateTime dm1 = DateTime.MinValue;
                dm1 = dm1.AddDays(days - 1721426);
                dm1 = dm1.AddMilliseconds((double)milliSeconds);

                return dm1;
            }
            catch (Exception e)
            {
                throw e;
            }
        }

        /// <summary>
        /// 获取对应字段的文本值
        /// </summary>
        /// <param name="fieldName"></param>
        /// <param name="fieldValue"></param>
        /// <returns></returns>
        public bool GetFieldValue(string fieldName, ref string fieldValue)
        {
            // 确认目标文件已经打开
            if (!this.IsFileOpened)
                return false;

            if (this.IsBOF || this.IsEOF)
                return false;

            if (null == this._recordBuffer || null == fieldName || 0 == fieldName.Length)
                return false;

            // 获取字段名称的索引
            int fieldIndex = GetFieldIndex(fieldName);

            if (-1 == fieldIndex)
            {
                fieldValue = string.Empty;
                return false;
            }

            try
            {
                // 返回根据字段索引获取的字段文本值
                return GetFieldValue((uint)fieldIndex, ref fieldValue);
            }
            catch (Exception e)
            {
                throw e;
            }
        }

        /// <summary>
        /// 获取当前纪录的文本值
        /// </summary>
        /// <param name="record"></param>
        /// <returns></returns>
        public bool GetRecordValue(ref string record)
        {
            // 安全性检查
            if (!this.IsFileOpened || this.IsBOF || this.IsEOF || null == this._recordBuffer)
                return false;

            try
            {
                // 反解码
                record = System.Text.Encoding.Default.GetString(this._recordBuffer);

                return true;
            }
            catch (Exception e)
            {
                throw e;
            }
        }

        /// <summary>
        /// 将纪录指针移动到第一条记录
        /// </summary>
        public void MoveFirst()
        {
            // 重新设置当前记录的索引
            this._recordIndex = 0;

            // 确认目标文件已经打开
            if (!this.IsFileOpened)
                return;

            if (this.IsBOF && this.IsEOF)
                return;

            try
            {
                // 读取当前记录信息
                ReadCurrentRecord();
            }
            catch (Exception e)
            {
                throw e;
            }

            return;
        }

        /// <summary>
        /// 将记录指针前移一个记录
        /// </summary>
        public void MovePrevious()
        {
            // 重新设置当前记录的索引
            this._recordIndex -= 1;

            // 确认目标文件已经打开
            if (!this.IsFileOpened)
                return;

            if (this.IsBOF)
                return;

            try
            {
                // 读取当前记录信息
                ReadCurrentRecord();
            }
            catch (Exception e)
            {
                throw e;
            }

            return;
        }

        /// <summary>
        /// 将记录指针后移一个记录
        /// </summary>
        public void MoveNext()
        {
            // 确认目标文件已经打开
            if (!this.IsFileOpened)
                return;

            // 重新设置当前记录的索引
            this._recordIndex += 1;

            if (this.IsEOF)
                return;

            try
            {
                // 读取当前记录信息
                ReadCurrentRecord();
            }
            catch (Exception e)
            {
                throw e;
            }

            return;
        }

        /// <summary>
        /// 将记录指针移动到最后一条记录
        /// </summary>
        public void MoveLast()
        {
            // 确认目标文件已经打开
            if (!this.IsFileOpened)
                return;

            if (this.IsBOF && this.IsEOF)
                return;

            // 重新设置当前记录的索引
            this._recordIndex = (int)this._recordCount - 1;

            try
            {
                // 读取当前记录信息
                ReadCurrentRecord();
            }
            catch (Exception e)
            {
                throw e;
            }

            return;
        }

        /// <summary>
        /// 关闭dbf文件
        /// </summary>
        public void Close()
        {
            this.Dispose(true);
        }

        /// <summary>
        /// 根据字段名称获取字段的索引值
        /// </summary>
        /// <param name="fieldName"></param>
        /// <returns></returns>
        private int GetFieldIndex(string fieldName)
        {
            // 确认文件已经打开
            if (!this.IsFileOpened)
                return -1;

            // 字段名称有效性检查
            if (null == fieldName || 0 == fieldName.Length)
                return -1;

            int index = -1;
            string dest;

            fieldName = fieldName.Trim();

            // 查找所有字段名称信息，查找与fieldName匹配的项目
            for (uint i = 0; i < this._fieldCount; i++)
            {
                dest = System.Text.Encoding.Default.GetString(this._dbfFields[i].Name);
                dest = dest.Replace("\0", "");

                // 检查当前字段名称与指定的字段名称是否匹配
                if (fieldName.Equals(dest))
                {
                    index = (int)i;
                    break;
                }
            }

            return index;
        }

        /// <summary>
        /// 打开dbf文件
        /// </summary>
        /// <returns></returns>
        private bool OpenFile()
        {
            // 如果文件已经打开，则先关闭然后重新打开
            if (this.IsFileOpened)
            {
                this.Close();
            }

            // 校验文件名
            if (null == this._fileName || 0 == this._fileName.Length)
            {
                return false;
            }

            this._isFileOpened = false;

            try
            {
                // 打开dbf文件，获取文件流对象
                this._fileStream = File.Open(this._fileName, FileMode.Open, FileAccess.Read, FileShare.Read);
                // 使用获取的文件流对象构造二进制读取器对象
                this._binaryReader = new BinaryReader(this._fileStream, System.Text.Encoding.Default);

                this._isFileOpened = true;
            }
            catch (Exception e)
            {
                throw e;
            }

            return this._isFileOpened;
        }

        /// <summary>
        /// 读取当前记录信息
        /// </summary>
        private void ReadCurrentRecord()
        {
            // 确认目标文件已经打开
            if (!this.IsFileOpened)
            {
                return;
            }

            if (this.IsBOF && this.IsEOF)
            {
                return;
            }

            try
            {
                this._fileStream.Seek(this._dbfHeader.HeaderLength + this._dbfHeader.RecordLength * this._recordIndex, SeekOrigin.Begin);
                byte deleteFlag = this._binaryReader.ReadByte();  // 删除标志
                this._recordBuffer = this._binaryReader.ReadBytes(this._dbfHeader.RecordLength - 1);
            }
            catch (Exception e)
            {
                throw e;
            }
        }

        /// <summary>
        /// 从dbf文件中读取所有字段信息
        /// </summary>
        /// <returns></returns>
        private bool ReadFields()
        {
            // 确认目标文件已经打开
            if (!this.IsFileOpened)
                return false;

            // 必须存在文件头对象信息
            if (null == this._dbfHeader)
                return false;

            // 尝试构造字段信息对象数组
            if (null == this._dbfFields)
                this._dbfFields = new DBFField[this._fieldCount];

            try
            {
                // 定位字段信息结构区起点
                this._fileStream.Seek(DBFHeader.DBFHeaderSize, SeekOrigin.Begin);

                // 读取所有字段信息
                for (int i = 0; i < this._fieldCount; i++)
                {
                    this._dbfFields[i] = new DBFField();
                    this._dbfFields[i].Name = this._binaryReader.ReadBytes(11);
                    this._dbfFields[i].Type = this._binaryReader.ReadSByte();
                    //this._dbfFields[i].Offset = this._binaryReader.ReadUInt32();
                    this._binaryReader.ReadBytes(4);
                    this._dbfFields[i].Length = this._binaryReader.ReadByte();
                    this._dbfFields[i].Precision = this._binaryReader.ReadByte();
                    this._dbfFields[i].Reserved = this._binaryReader.ReadBytes(2);
                    this._dbfFields[i].DbaseivID = this._binaryReader.ReadSByte();
                    this._dbfFields[i].Reserved2 = this._binaryReader.ReadBytes(10);
                    this._dbfFields[i].ProductionIndex = this._binaryReader.ReadSByte();
                }
            }
            catch (Exception e)
            {
                throw e;
            }

            return true;
        }

        /// <summary>
        /// 从dbf文件中读取文件头信息
        /// </summary>
        /// <returns></returns>
        private bool ReadFileHeader()
        {
            // 确认目标文件已经打开
            if (!this.IsFileOpened)
                return false;

            // 尝试构造新的dbf文件头对象
            if (null == this._dbfHeader)
                this._dbfHeader = new DBFHeader();

            try
            {
                this._dbfHeader.Version = this._binaryReader.ReadSByte();
                this._dbfHeader.LastModifyYear = this._binaryReader.ReadByte();
                this._dbfHeader.LastModifyMonth = this._binaryReader.ReadByte();
                this._dbfHeader.LastModifyDay = this._binaryReader.ReadByte();
                this._dbfHeader.RecordCount = this._binaryReader.ReadUInt32();
                this._dbfHeader.HeaderLength = this._binaryReader.ReadUInt16();
                this._dbfHeader.RecordLength = this._binaryReader.ReadUInt16();
                this._dbfHeader.Reserved = this._binaryReader.ReadBytes(16);
                this._dbfHeader.TableFlag = this._binaryReader.ReadSByte();
                this._dbfHeader.CodePageFlag = this._binaryReader.ReadSByte();
                this._dbfHeader.Reserved2 = this._binaryReader.ReadBytes(2);
            }
            catch (Exception e)
            {
                throw e;
            }

            // 设置记录数目
            this._recordCount = this._dbfHeader.RecordCount;
            uint fieldCount = (uint)((this._dbfHeader.HeaderLength - DBFHeader.DBFHeaderSize - 1) / DBFField.DBFFieldSize);
            this._fieldCount = 0;

            // 由于有些dbf文件的文件头最后有附加区段，但是有些文件没有，在此使用笨方法计算字段数目
            // 就是测试每一个存储字段结构区域的第一个字节的值，如果不为0x0D，表示存在一个字段
            // 否则从此处开始不再存在字段信息
            try
            {
                for (uint i = 0; i < fieldCount; i++)
                {
                    // 定位到每个字段结构区，获取第一个字节的值
                    this._fileStream.Seek(DBFHeader.DBFHeaderSize + i * DBFField.DBFFieldSize, SeekOrigin.Begin);
                    byte flag = this._binaryReader.ReadByte();

                    // 如果获取到的标志不为0x0D，则表示该字段存在；否则从此处开始后面再没有字段信息
                    if (0x0D != flag)
                        this._fieldCount++;
                    else
                        break;
                }
            }
            catch (Exception e)
            {
                throw e;
            }

            return true;
        }

        #region properties

        /// <summary>
        /// 获取当前记录是否被删除
        /// </summary>
        public bool IsRecordDeleted
        {
            get
            {
                if (!this.IsFileOpened)
                    return false;

                if (this.IsBOF || this.IsEOF)
                    return false;

                // 只有记录缓冲的第一个字节的值为删除标志（0x2A）才表示当前纪录被删除了
                if (0x2A == this._recordBuffer[0])
                    return true;
                else
                    return false;
            }
        }

        /// <summary>
        /// 获取记录长度
        /// </summary>
        public uint RecordLength
        {
            get
            {
                if (!this.IsFileOpened)
                    return 0;

                return this._dbfHeader.RecordLength;
            }
        }

        /// <summary>
        /// 获取字段数目
        /// </summary>
        public uint FieldCount
        {
            get
            {
                if (!this.IsFileOpened)
                    return 0;

                return this._fieldCount;
            }
        }

        /// <summary>
        /// 获取记录数目
        /// </summary>
        public uint RecordCount
        {
            get
            {
                if (!this.IsFileOpened)
                    return 0;

                return this._recordCount;
            }
        }

        /// <summary>
        /// 获取是否记录指针已经移动到记录最前面
        /// </summary>
        public bool IsBOF
        {
            get
            {
                return (0 == this._recordIndex);
            }
        }

        /// <summary>
        /// 获取是否记录指针已经移动到记录最后面
        /// </summary>
        public bool IsEOF
        {
            get
            {
                return ((uint)this._recordIndex == this._recordCount);
            }
        }

        /// <summary>
        /// 获取dbf文件是否已经被打开
        /// </summary>
        private bool IsFileOpened
        {
            get
            {
                return this._isFileOpened;
            }
        }

        #endregion


        #region IDisposable 成员

        void System.IDisposable.Dispose()
        {
            // TODO:  添加 DBFFile.System.IDisposable.Dispose 实现
            this.Dispose(true);
        }

        #endregion
    }

  /// <summary>
    /// .dbf 文件的文件头信息类
    /// </summary>
    internal class DBFHeader
    {
        public const int DBFHeaderSize = 32;
        /* 版本标志
                   0x02    FoxBASE  
                   0x03    FoxBASE+/dBASE III PLUS，无备注  
                   0x30    Visual FoxPro  
                   0x43    dBASE IV SQL 表文件，无备注  
                   0x63    dBASE IV SQL 系统文件，无备注  
                   0x83    FoxBASE+/dBASE III PLUS，有备注  
                   0x8B    dBASE IV 有备注  
                   0xCB    dBASE IV SQL 表文件，有备注  
                   0xF5    FoxPro 2.x（或更早版本）有备注  
                   0xFB    FoxBASE  
       */
        public sbyte Version;
        /* 最后更新年 */
        public byte LastModifyYear;
        /* 最后更新月 */
        public byte LastModifyMonth;
        /* 最后更新日 */
        public byte LastModifyDay;
        /* 文件包含的总记录数 */
        public uint RecordCount;
        /* 第一条记录的偏移值，这个值也可以表示文件头长度 */
        public ushort HeaderLength;
        /* 记录长度，包括删除标志*/
        public ushort RecordLength;
        /* 保留 */
        public byte[] Reserved = new byte[16];
        /* 表的标志
                    0x01具有 .cdx 结构的文件
                   0x02文件包含备注
                   0x04文件是数据库（.dbc） 
                   标志可OR 
       */
        public sbyte TableFlag;
        /* 代码页标志 */
        public sbyte CodePageFlag;
        /* 保留 */
        public byte[] Reserved2 = new byte[2];
    }