C#读写大文件，如何提速

Question

大文件大小约1个G，文件的每一行基本都需要，需要按照每一行的字符串标识将大文件进行拆分，写到各个小文件中。现在我的读是用buffer读的，写每一行都需要写入新的小文件中，写到的小文件是根据每一行的标识来决定的。一般相邻10行左右的都会被写入同一个新文件，求大神给点建议呀。。

Answer 1

不妨试试下面这个链接的方法
转自 http://www.cnblogs.com/criedshy/archive/2010/06/13/1757826.html
C#内存映射文件代码
using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.InteropServices;
using System.IO;

namespace TestOpenFileMap
{
    public class FileMap
    {
        [StructLayout(LayoutKind.Sequential)]
        internal struct SYSTEM_INFO
        { 
            public uint dwOemId; 
            public uint dwPageSize; 
            public uint lpMinimumApplicationAddress; 
            public uint lpMaximumApplicationAddress; 
            public uint dwActiveProcessorMask; 
            public uint dwNumberOfProcessors; 
            public uint dwProcessorType; 
            public uint dwAllocationGranularity; 
            public uint dwProcessorLevel; 
            public uint dwProcessorRevision;    
        } 

        private const uint GENERIC_READ = 0x80000000;
        private const uint GENERIC_WRITE =0x40000000;
        private const int OPEN_EXISTING = 3;
        private const int INVALID_HANDLE_VALUE = -1;
        private const int FILE_ATTRIBUTE_NORMAL = 0x80;
        private const uint FILE_FLAG_SEQUENTIAL_SCAN = 0x08000000;
        private const uint PAGE_READWRITE = 0x04;

        private const int FILE_MAP_COPY = 1;
        private const int FILE_MAP_WRITE = 2;
        private const int FILE_MAP_READ = 4;

        /// <summary>
        /// 内存映射文件句柄
        /// </summary>
        /// <param name="hFile"></param>
        /// <param name="lpFileMappingAttributes"></param>
        /// <param name="flProtect"></param>
        /// <param name="dwMaximumSizeHigh"></param>
        /// <param name="dwMaximumSizeLow"></param>
        /// <param name="lpName"></param>
        /// <returns></returns>
        [DllImport("kernel32.dll")]
        internal static extern IntPtr CreateFileMapping(IntPtr hFile,
            IntPtr lpFileMappingAttributes, uint flProtect,
            uint dwMaximumSizeHigh,
            uint dwMaximumSizeLow, string lpName);
        /// <summary>
        /// 内存映射文件
        /// </summary>
        /// <param name="hFileMappingObject"></param>
        /// <param name="dwDesiredAccess"></param>
        /// <param name="dwFileOffsetHigh"></param>
        /// <param name="dwFileOffsetLow"></param>
        /// <param name="dwNumberOfBytesToMap"></param>
        /// <returns></returns>
        [DllImport("kernel32.dll")]
        internal static extern IntPtr MapViewOfFile(IntPtr hFileMappingObject, uint
            dwDesiredAccess, uint dwFileOffsetHigh, uint dwFileOffsetLow,
            uint dwNumberOfBytesToMap);

        /// <summary>
        /// 撤消文件映像
        /// </summary>
        /// <param name="lpBaseAddress"></param>
        /// <returns></returns>
        [DllImport("kernel32.dll")]
        internal static extern bool UnmapViewOfFile(IntPtr lpBaseAddress);

        /// <summary>
        /// 关闭内核对象句柄
        /// </summary>
        /// <param name="hObject"></param>
        /// <returns></returns>
        [DllImport("kernel32.dll")]
        internal static extern bool CloseHandle(IntPtr hObject);

        /// <summary>
        /// 打开要映射的文件
        /// </summary>
        /// <param name="lpFileName"></param>
        /// <param name="dwDesiredAccess"></param>
        /// <param name="dwShareMode"></param>
        /// <param name="securityAttrs"></param>
        /// <param name="dwCreationDisposition"></param>
        /// <param name="dwFlagsAndAttributes"></param>
        /// <param name="hTemplateFile"></param>
        /// <returns></returns>
        [DllImport("kernel32.dll")]
        internal static extern IntPtr CreateFile(string lpFileName,
            uint dwDesiredAccess, FileShare dwShareMode, IntPtr securityAttrs,
            FileMode dwCreationDisposition, uint dwFlagsAndAttributes, IntPtr hTemplateFile);
        /// <summary>
        /// 得到文件大小
        /// </summary>
        /// <param name="hFile"></param>
        /// <param name="highSize"></param>
        /// <returns></returns>
        [DllImport("kernel32.dll", SetLastError = true)]
        internal static extern uint GetFileSize(IntPtr hFile, out uint highSize);

        /// <summary>
        /// 得到系统信息
        /// </summary>
        /// <param name="lpSystemInfo"></param>
        [DllImport("kernel32.dll", SetLastError = true)]
        internal static extern void GetSystemInfo(ref SYSTEM_INFO lpSystemInfo);

        /// <summary>
        /// 使用内存文件映射得到文件内容
        /// </summary>
        /// <param name="path">文件路径</param>
        /// <returns></returns>
        public StringBuilder GetFileContent(string path)
        {
            StringBuilder sb = new StringBuilder();
            IntPtr fileHandle = CreateFile(path,
        GENERIC_READ | GENERIC_WRITE, FileShare.Read | FileShare.Write,
        IntPtr.Zero, FileMode.Open,
        FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN, IntPtr.Zero);
            if (INVALID_HANDLE_VALUE != (int)fileHandle)
            {
                IntPtr mappingFileHandle = CreateFileMapping(
                    fileHandle, IntPtr.Zero, PAGE_READWRITE, 0, 0, "~MappingTemp");
                if (mappingFileHandle != IntPtr.Zero)
                {
                    SYSTEM_INFO systemInfo = new SYSTEM_INFO(); ;
                    GetSystemInfo(ref systemInfo);
                    //得到系统页分配粒度
                    uint allocationGranularity = systemInfo.dwAllocationGranularity;
                    uint fileSizeHigh=0;
                    //get file size
                    uint fileSize = GetFileSize(fileHandle, out fileSizeHigh);
                    fileSize |= (((uint)fileSizeHigh) << 32);
                    //关闭文件句柄 
                    CloseHandle(fileHandle);
                    uint fileOffset = 0;
                    uint blockBytes = 1000 * allocationGranularity;
                    if (fileSize < 1000 * allocationGranularity)
                        blockBytes = fileSize;
                    //分块读取内存，适用于几G的文件
                    while (fileSize > 0)
                    {
                        // 映射视图，得到地址 
                        IntPtr lpbMapAddress = MapViewOfFile(mappingFileHandle, FILE_MAP_COPY | FILE_MAP_READ | FILE_MAP_WRITE,
                           (uint)(fileOffset >> 32), (uint)(fileOffset & 0xFFFFFFFF),
                           blockBytes);
                        if (lpbMapAddress == IntPtr.Zero)
                        {
                            return sb;
                        }
                        // 对映射的视图进行访问
                        byte[] temp = new byte[blockBytes];
                        //从非托管的内存中复制内容到托管的内存中
                        Marshal.Copy(lpbMapAddress, temp, 0, (int)blockBytes);

                        //用循环太慢了，文件有几M的时候就慢的要死，还是用上面的方法直接
                        //for (uint i = 0; i < dwBlockBytes; i++)
                        //{
                        //    byte vTemp = Marshal.ReadByte((IntPtr)((int)lpbMapAddress + i));
                        //    temp[i] = vTemp;
                        //}
                        
                        //此时用ASCII解码比较快，但有中文会有乱码，用gb2312即ANSI编码也比较快，16M的文件大概4秒就读出来了
                        //但用unicode解码，文件大的时候会非常慢，会现卡死的状态，不知道为什么？
                        //ASCIIEncoding encoding = new ASCIIEncoding();
                        //System.Text.UnicodeEncoding encoding = new UnicodeEncoding();
                        //sb.Append(encoding.GetString(temp));
                        sb.Append(System.Text.Encoding.GetEncoding("gb2312").GetString(temp));
                        // 撤消文件映像
                        UnmapViewOfFile(lpbMapAddress);
                        // 修正参数
                        fileOffset += blockBytes;
                        fileSize -= blockBytes;
                    }

                    //close file mapping handle
                    CloseHandle(mappingFileHandle);
                }
            }
            return sb;
        }

    }
}

Answer 2

FileStream常用的属性和方法：
　　属性：
　　CanRead 判断当前流是否支持读取，返回bool值，True表示可以读取
　　CanWrite 判断当前流是否支持写入，返回bool值，True表示可以写入
　　方法：
　　Read() 从流中读取数据，返回字节数组
　　Write() 将字节块(字节数组)写入该流
　　Seek() 设置文件读取或写入的起始位置
　　Flush() 清除该流缓冲区，使得所有缓冲的数据都被写入到文件中
　　Close() 关闭当前流并释放与之相关联的所有系统资源
　　文件的访问方式：(FileAccess)
　　包括三个枚举：
　　FileAccess.Read(对文件读访问)
　　FileAccess.Write(对文件进行写操作)
　　FileAccess.ReadWrite(对文件读或写操作)
　　文件打开模式：(FileMode)包括6个枚举
　　FileMode.Append 打开现有文件准备向文件追加数据，只能同FileAccess.Write一起使用
　　FileMode.Create 指示操作系统应创建新文件，如果文件已经存在，它将被覆盖
　　FileMode.CreateNew 指示操作系统应创建新文件，如果文件已经存在，将引发异常
　　FileMode.Open 指示操作系统应打开现有文件，打开的能力取决于FileAccess所指定的值
　　FileMode.OpenOrCreate 指示操作系统应打开文件，如果文件不存在则创建新文件
　　FileMode.Truncate 指示操作系统应打开现有文件，并且清空文件内容
　　文件共享方式：(FileShare)
　　FileShare方式是为了避免几个程序同时访问同一个文件会造成异常的情况。
　　文件共享方式包括四个：
　　FileShare.None 谢绝共享当前文件
　　FileShare.Read 充许别的程序读取当前文件
　　FileShare.Write 充许别的程序写当前文件
　　FileShare.ReadWrite 充许别的程序读写当前文件
　　使用FileStream类创建文件流对象：
　　FileStream(String 文件路径，FileMode 文件打开模式)
　　FileStream(String 文件路径，FileMode 文件打开模式，FileAccess 文件访问方式)
　　FileStream(String 文件路径，FileMode 文件打开模式，FileAccess 文件访问方式，FileShare 文件共享方式)
　　例：
　　//在C盘创建a.txt文件，使用fs流对象对文件进行操作，fs的工作模式是新建(FileMode.Create)
　　FileStream fs=new FileStream(@"c:a.txt",FileMode.Create);
　　//在C盘创建a.txt文件，使用fs流对象对文件进行操作，fs工作模式是新建(FileMode.Create)文件的访问模式是写入(Fileaccess.Write)
　　FileStream fs=new FileStream(@"c:a.txt",FileMode.Create,FileAccess.Write);
　　//在C盘创建a.txt文件，使用fs流对象对文件进行操作，fs工作模式是新建(FileMode.Create)文件的访问模式是写入(FileAccess.Write)文件的共享模式是谢绝共享(FileShare.None)
　　FileStream fs=new FileStream(@"c:a.txt",FileMode.Create,FileAccess.Write,FileShare.None);
　　使用File类来创建对象：(常用)
　　自定义打开文件的方式：File.Open(String，FileMode);
　　打开文件进行读取： File.OpenRead(String);
　　打开文件进行写入： File.OpenWrite(String);
　　示例如下：
　　//在C盘新建123.txt文件，使用流对象fs对文件进行操作，fs可以行文件内容追加操作FileMode.Append
　　FileStream fs=File.Open(@"c:123.txt",FileMode.Append);
　　//在C盘新建123.txt文件，使用流对象fs对文件进行操作，fs可以进行读文件File.OpenRead()
　　FileStream fs=File.OpenRead(@"c:123.txt");
　　//在C盘新建123.txt文件，使用流对象fs对文件进行操作，fs可以进行写操作File.OpenWrite()
　　FileStream fs=File.OpenWrite(@"c:123.txt");
　　使用File例：
　　对文件进行读操作：
　　//新建fs流对象对象产生的路径是textbox1.text的值，文件的模式是FileMode.OpenOrCreate(可读可写)
　　using (FileStream fs = File.Open(textBox1.Text, FileMode.OpenOrCreate))
　　{
　　//新建字节型数组，数组的长度是fs文件对象的长度(后面用于存放文件)
　　byte[] bt=new byte[fs.Length];
　　//通过fs对象的Read方法bt得到了fs对象流中的内容
　　fs.Read(bt,0,bt.Length);
　　//关闭fs流对象
　　fs.Close();
　　//将bt字节型数组中的数据由Encoding.Default.GetString(bt)方法取出，交给textbox2.text
　　textBox2.Text = System.Text.Encoding.Default.GetString(bt);
　　}
　　对文件进行写入操作：
　　//新建fs流对象，对象操作的文件路径在textbox1.text中，fs的操作模式是FileMode.Create
　　using (FileStream fs = File.Open(textBox1.Text, FileMode.Create))
　　{
　　//新建字节型数组bt对象，bt对象得到了textbox2.text的Encoding的值
　　byte[] bt = System.Text.Encoding.Default.GetBytes(textBox2.Text);
　　//将bt字节型数组对象的值写入到fs流对象中(文件)
　　fs.Write(bt,0,bt.Length);
　　//关闭流对象
　　fs.Close();
　　}
　　注：
　　对文件的读写操多不管代码有多少，无非就是下面的三步：
　　1.创建文件读写流对象
　　2.对文件进行读写
　　3.关闭文件流

Answer 3

先一次把1G的文件都读出来，不做任何处理，读出来存起来。

读完了在用缓存中的内容存成小文件能快点。追问

先把1G文件读出来，存在哪里呀？
可否给我一个例子，跪谢了。。

追答

你是什么文件啊，文件有1G内容不定到1G了啊。

你创建个很长很长的string数组存起来呗。我没操作过这么大的文件，但是我操作过500M的数据库数据。就是这么操作的。

例子我没有啊，我只是说下想法，抱歉啊

追问

是数据库的log文件，要对log文件进行分析