string _filepath;

         /// <summary>

          /// 引用内存映射文件

          /// </summary>

          private MemoryMappedFile _memoryFile = null;

          /// <summary>

          /// 用于访问内存映射文件的存取对象

          /// </summary>

          private MemoryMappedViewAccessor _accessor = null;

         public ScientificData _ScientificData = new ScientificData();

         long _lenByte = ;

         public DatFileInfo(string filepath)

         {

             _filepath = filepath;

             _memoryFile = MemoryMappedFile.CreateFromFile(_filepath);

             _accessor = _memoryFile.CreateViewAccessor();

             // _stream = _memoryFile.CreateViewStream();

             FileInfo finfo = new FileInfo(filepath);

             _lenByte = finfo.Length;//文件字节大小

         }

         public void SaveRawData(string savepath)

         {

             int currentByteNum = ;//当前字节位置

             uint ACountint = ;

             uint RCountint = ;

             ScientificData scientificData = new ScientificData();

             byte[] data = new byte[ * ];

             while (currentByteNum<= (_lenByte-  * ))

             {

                 _accessor.Read<uint>(currentByteNum, out RCountint);

                 _accessor.Read<uint>(currentByteNum+, out ACountint);

                 if (RCountint <  && ACountint <  && _accessor.ReadByte(currentByteNum+)==0x0a && _accessor.ReadByte(currentByteNum + ) == 0x0b)//初步判断条件，节省解析结构体时间

                 {

                     _accessor.ReadArray(currentByteNum, data, , data.Length);//读取结构体数据到字节数组

                     scientificData = ByteToStructure<ScientificData>(data);//字节数组解析到结构体

                     if((scientificData.aux_3a1 == 0x3A) && (scientificData.aux_3a3 == 0x3A))//进一步判断

                     {

                         ushort[,] sdata = scientificData.GetImageData();//得到所需的数据

                         saveRawData(savepath + ((int)((ACountint - )/+)).ToString()+ "_" + (ACountint-).ToString() + "_"+ACountint + "_"+scientificData.aux_num + ".raw" , sdata);

                         currentByteNum +=  * ;

                     }

                     else

                         currentByteNum++;

                 }

                 else

                     currentByteNum++;

             }

         }

         /// <summary>

         /// 由byte数组转换为结构体

         /// </summary>

         public static T ByteToStructure<T>(byte[] dataBuffer)

         {

             object structure = null;

             int size = Marshal.SizeOf(typeof(T));

             IntPtr allocIntPtr = Marshal.AllocHGlobal(size);

             try

             {

                 Marshal.Copy(dataBuffer, , allocIntPtr, size);

                 structure = Marshal.PtrToStructure(allocIntPtr, typeof(T));

             }

             finally

             {

                 Marshal.FreeHGlobal(allocIntPtr);

             }

             return (T)structure;

         }

         private void saveRawData(string savepath,ushort[,] data)

         {

             int len = data.Length*;

             byte[] bdata = new byte[len];

             Buffer.BlockCopy(data,,bdata,,len);

             File.WriteAllBytes(savepath, bdata);

         }

         /// <summary>

         /// 由结构体转换为byte数组

         /// </summary>

         public static byte[] StructureToByte<T>(T structure)

         {

             int size = Marshal.SizeOf(typeof(T));

             byte[] buffer = new byte[size];

             IntPtr bufferIntPtr = Marshal.AllocHGlobal(size);

             try

             {

                 Marshal.StructureToPtr(structure, bufferIntPtr, true);

                 Marshal.Copy(bufferIntPtr, buffer, , size);

             }

             finally

             {

                 Marshal.FreeHGlobal(bufferIntPtr);

             }

             return buffer;

         }

  //一幅1036*1036字节数据定义

    public struct ScientificData

     {

        /参数信息

     [MarshalAs(UnmanagedType.ByValArray, SizeConst = )]

       public byte[] RelativePacketCount;

      [MarshalAs(UnmanagedType.ByValArray, SizeConst = )]

       public Byte[] AbsolutePacketCount;

     ........

      public byte aux_3a;//填充3A H

       .........

      [MarshalAs(UnmanagedType.ByValArray, SizeConst = )]

        public OneImageRow[] ImageData;//图像数据行

/// <summary>

/// 获取raw图数据

/// </summary>

/// <returns>图像数据</returns>

public ushort[,] GetImageData()

{

ushort[,] rawdata = new ushort[, ];

for (int i = ; i < ; i++)

{

var onerow = ImageData[i];

for (int j = ; j < ; j++)

{

rawdata[i, j] = (ushort)(((onerow.imagedata[j * ] << ) | onerow.imagedata[j *  + ])) ;

}

}

return rawdata;

}

}

    public struct OneImageRow

    {

        [MarshalAs(UnmanagedType.ByValArray, SizeConst = )]

        public byte[] RelativePacketCount;

        [MarshalAs(UnmanagedType.ByValArray, SizeConst = )]

        public byte[] AbsolutePacketCount;

        [MarshalAs(UnmanagedType.ByValArray, SizeConst = )]

        public byte[] linehead;//行头

        [MarshalAs(UnmanagedType.ByValArray, SizeConst = )]

        public byte[] linenum;//行号

        [MarshalAs(UnmanagedType.ByValArray, SizeConst = )]

        public byte[] imagedata;//图像数据512×2=1024字节

        public static string ByteToHex(byte[] bt)

        {

            var hex = BitConverter.ToString(bt, ).ToUpper();

            return hex;

        }

    }