在C#中把二进制数据写入文件，并不是只有一种固定写法。字节数组可以直接落盘，基础类型可以通过BinaryWriter结构化写入，数据源是流式产生时则需要分块处理。不同的API在内存占用、写入粒度、异常处理上差别明显，用错场景可能带来内存峰值过高或文件只写了一半。本文从FileStream开始拆解，对比BinaryWriter、File.WriteAllBytes以及大文件分块写入的实现方式，最后补充异步写入和异常排查的要点。

一、用FileStream完成最基础的字节数组写入

FileStream是.NET里最底层的文件流类，适合需要对写入位置、文件共享模式、缓冲区大小做精细控制的场景。写入字节数组时，先通过构造参数指定文件路径、打开方式、访问权限和共享方式，再调用Write方法把byte[]中指定范围的数据刷到操作系统缓冲区。构造时若使用FileMode.Create，文件不存在会新建，已存在则截断清空；如果希望追加内容，应使用FileMode.Append。访问权限通常用FileAccess.Write，如果既要读又要写，就改成FileAccess.ReadWrite。

下面的示例展示了最基本的同步写入。代码中的文件路径使用本地磁盘，例如C:\temp\data.bin，注意使用using语句是为了确保FileStream及时释放文件句柄，否则后续再次打开该文件可能出现占用冲突。

using System;
using System.IO;
class Program
{
    static void Main()
    {
        string path = @"C:\temp\data.bin";
        byte[] data = new byte[] { 0x00, 0x1A, 0xFF, 0x30, 0x42 };
        using (FileStream fs = new FileStream(path, FileMode.Create, FileAccess.Write))
        {
            fs.Write(data, 0, data.Length);
            fs.Flush();
        }
        Console.WriteLine("二进制数据已写入文件");
    }
}

这段代码适合写入较小的字节数组。如果数据量较大，仍然把所有内容放在一个byte[]里，内存压力会上升；更合理的方式是分块读、分块写，这会在后面讲到。Flush方法会把内部缓冲区数据强制交给操作系统，但它不代表数据已经物理落盘，真正落盘还需要文件系统的缓存策略配合。

二、用BinaryWriter写入基础类型和结构化数据

BinaryWriter是对Stream的包装类，它在内部维护了一个编码器，能把int、long、float、string等基础类型转换成字节序列后写入底层流。这个类特别适合文件头、结构化记录或自定义二进制格式的写入。例如要写入一个文件标识、版本号、记录数量，再逐个写入数据项，直接手写BitConverter会很繁琐，而BinaryWriter的Write重载能显著简化代码。

需要注意BinaryWriter并不负责管理底层FileStream的生命周期，两个类都放进using语句才能可靠释放资源。写入字符串时默认使用UTF-8编码，并且会在字符串前写入长度前缀，读取时也得用对应的BinaryReader来解析；如果要和外部系统交换数据，务必确认对方是否接受这种长度前缀格式，否则可能出现错位。

using System;
using System.IO;
using System.Text;
class Program
{
    static void Main()
    {
        string path = @"C:\temp\record.dat";
        using (FileStream fs = new FileStream(path, FileMode.Create, FileAccess.Write))
        using (BinaryWriter writer = new BinaryWriter(fs, Encoding.UTF8, leaveOpen: false))
        {
            writer.Write(0x4D42);          // 写入一个文件标识
            writer.Write(1);               // 版本号
            writer.Write(3);               // 记录数量
            writer.Write("temperature");
            writer.Write(23.6f);
            writer.Write("humidity");
            writer.Write(58.2f);
            writer.Write("pressure");
            writer.Write(1013.25f);
        }
        Console.WriteLine("结构化二进制数据已写入");
    }
}

这个例子写入了一个简单的文件标识，再写入字符串和浮点数的组合记录。由于BinaryWriter内部有缓冲，单个Write调用不会每次都触发磁盘I/O，写入完成后即使不手动Flush，在Dispose时也会自动刷新。但如果写入过程中出现异常，缓冲区内容可能丢失，因此批量写入最好配合try-catch和事务式的临时文件策略。

三、File.WriteAllBytes与异步写入的适用边界

File.WriteAllBytes是最省事的静态方法，传入路径和byte[]就能一次写完。它在内部会创建FileStream、写入数据、关闭流，代码非常干净。缺点是必须提前把完整数据组装进一个字节数组，如果文件有几百MB甚至更大，内存中同时存在原始数据、中间产生的数组和文件流缓冲区，很容易把进程可用内存吃紧。对于几KB到几十MB的小文件，或者数据本身已经完整存在于内存的场景，这个方法非常合适。

using System;
using System.IO;
using System.Threading.Tasks;
class Program
{
    static async Task Main()
    {
        string path = @"C:\temp\blob.bin";
        byte[] payload = new byte[1024 * 1024]; // 1MB测试数据
        new Random().NextBytes(payload);
        await File.WriteAllBytesAsync(path, payload);
        Console.WriteLine("异步写入完成");
    }
}

异步版本WriteAllBytesAsync适合客户端界面或Web服务中不想阻塞当前线程的场景。它内部使用异步I/O，写大文件时比同步版本对UI线程更友好。但异步并不解决一次性分配整个字节数组的问题，如果你已经有一个巨大的byte[]，异步只是让写入过程不阻塞调用线程，内存峰值并没有降低。要控制内存，就必须回到FileStream分块写入的思路。

四、大文件分块写入与缓冲区大小选择

当数据源是网络流、数据库游标、压缩后的序列化结果或者磁盘上的另一个文件时，最好的做法是使用固定大小的缓冲区循环搬运数据。每次从源流中读取一块，再原样写入目标流，读多少写多少，避免把完整文件内容加载到内存。缓冲区大小通常取4KB到1MB之间，太小会增加系统调用次数，太大又占用过多内存。对于顺序写入大文件，可以给FileStream指定FileOptions.SequentialScan，让操作系统优化顺序访问的缓存策略。

using System;
using System.IO;
class Program
{
    static void Main()
    {
        string sourcePath = @"C:\temp\source.bin";
        string targetPath = @"C:\temp\target.bin";
        byte[] buffer = new byte[81920]; // 80KB缓冲区
        using (FileStream source = new FileStream(sourcePath, FileMode.Open, FileAccess.Read))
        using (FileStream target = new FileStream(targetPath, FileMode.Create, FileAccess.Write))
        {
            int read;
            while ((read = source.Read(buffer, 0, buffer.Length)) > 0)
            {
                target.Write(buffer, 0, read);
            }
            target.Flush();
        }
        Console.WriteLine("大文件分块复制完成");
    }
}

这个循环每读出一块就写一块，read变量记录了实际读取到的字节数，最后一次写入时只写入实际数量，避免把缓冲区末尾的旧数据也写进去。如果希望进一步减少内存分配，可以使用ArrayPool<byte>.Shared租用缓冲区，用完归还。对于非常大的文件，还可以结合FileStream的Position或Seek方法实现断点续写，但这需要额外记录已写入偏移量。

五、异常处理与防止文件损坏的实用建议

文件写入最常见的异常包括IOException、UnauthorizedAccessException、DirectoryNotFoundException和PathTooLongException。目录不存在时先创建目录再写文件；路径过长在Windows上可以尝试使用长路径前缀；权限不足则要检查运行账号对目标文件夹的写权限。文件被其他进程占用时，构造FileStream可以传入FileShare.Read或FileShare.ReadWrite来允许共享，但并不是所有占用都能通过共享参数解决，必要时需要等待或提示用户关闭占用程序。

如果写入中途断电或程序崩溃，目标文件可能只写了一部分，导致数据不完整。对于重要数据，更稳妥的流程是先写到一个临时文件，例如data.bin.tmp，全部写入成功并Flush(true)后，再使用File.Move把临时文件重命名为正式文件。这样可以避免消费者读到半截文件。调用Flush(true)会将数据强制写入磁盘，代价是性能下降，需要根据可靠性要求权衡。

using System;
using System.IO;
class Program
{
    static void Main()
    {
        string targetPath = @"C:\temp\data.bin";
        string tempPath = targetPath + ".tmp";
        byte[] data = new byte[4096];
        new Random().NextBytes(data);
        try
        {
            using (FileStream fs = new FileStream(tempPath, FileMode.Create, FileAccess.Write))
            {
                fs.Write(data, 0, data.Length);
                fs.Flush(true);
            }
            File.Move(tempPath, targetPath, overwrite: true);
            Console.WriteLine("临时文件写入并替换成功");
        }
        catch (Exception ex)
        {
            if (File.Exists(tempPath))
            {
                File.Delete(tempPath);
            }
            Console.WriteLine("写入失败：" + ex.Message);
        }
    }
}

这段代码把数据写入临时文件后，再用File.Move覆盖目标文件。由于Move在相同磁盘卷上基本是原子操作，读取方要么看到旧文件，要么看到新文件，几乎不会读到中间状态。最后不要忘记在catch中清理临时文件，避免留下垃圾文件。根据具体场景，还可以加入重试机制、写入前的数据校验和日志审计，提升文件写入的健壮性。