引言
在C#开发中,文件操作是几乎所有应用程序都会涉及的核心功能。无论是读取配置文件、保存用户数据,还是处理大型数据集,掌握高效的文件操作技巧都至关重要。本文将从基础的文件读写开始,逐步深入到异常处理、性能优化等高级主题,帮助你构建健壮且高效的文件处理代码。
1. 基础文件操作
1.1 文件读取
使用
File.ReadAllText
读取文本文件
这是最简单的文本文件读取方式,适合处理小型文件:
using System;
using System.IO;
class Program
{
static void Main()
{
string filePath = “example.txt”;
// 检查文件是否存在
if (File.Exists(filePath))
{
// 一次性读取所有内容
string content = File.ReadAllText(filePath);
Console.WriteLine(“文件内容:”);
Console.WriteLine(content);
}
else
{
Console.WriteLine(“文件不存在!”);
}
}
}
使用
StreamReader
逐行读取
对于大文件,逐行读取可以避免内存溢出:
using System;
using System.IO;
class Program
{
static void Main()
{
string filePath = “largefile.txt”;
using (StreamReader reader = new StreamReader(filePath))
{
string line;
int lineNumber = 1;
// 逐行读取直到文件末尾
while ((line = reader.ReadLine()) != null)
{
Console.WriteLine($”第 {lineNumber} 行: {line}”);
lineNumber++;
}
}
}
}
1.2 文件写入
使用
File.WriteAllText
写入文本文件
最简单的写入方式:
using System;
using System.IO;
class Program
{
static void Main()
{
string filePath = “output.txt”;
string content = “这是写入文件的内容。\n第二行内容。”;
// 写入内容(如果文件存在则覆盖)
File.WriteAllText(filePath, content);
Console.WriteLine(“文件写入完成!”);
}
}
使用
StreamWriter
追加写入
using System;
using System.IO;
class Program
{
static void Main()
{
string filePath = “log.txt”;
// 使用追加模式写入
using (StreamWriter writer = new StreamWriter(filePath, true))
{
writer.WriteLine($”[{DateTime.Now}] 应用程序启动”);
writer.WriteLine($”[{DateTime.Now}] 执行任务A”);
writer.WriteLine($”[{DateTime.Now}] 任务完成”);
}
}
}
2. 文件和目录操作
2.1 文件操作
检查文件是否存在
if (File.Exists(“myfile.txt”))
{
Console.WriteLine(“文件存在!”);
}
复制、移动和删除文件
// 复制文件
File.Copy(“source.txt”, “destination.txt”, true); // 第三个参数表示是否覆盖
// 移动文件
File.Move(“oldlocation.txt”, “newlocation.txt”);
// 删除文件
File.Delete(“filetodelete.txt”);
获取文件信息
FileInfo fileInfo = new FileInfo(“myfile.txt”);
Console.WriteLine($”文件名: {fileInfo.Name}”);
Console.WriteLine($”文件大小: {fileInfo.Length} 字节”);
Console.WriteLine($”创建时间: {fileInfo.CreationTime}”);
Console.WriteLine($”最后修改时间: {fileInfo.LastWriteTime}”);
2.2 目录操作
创建和删除目录
// 创建目录
Directory.CreateDirectory(“NewFolder”);
// 删除目录(第二个参数表示是否递归删除子目录和文件)
Directory.Delete(“NewFolder”, true);
遍历目录中的文件
// 获取所有文件
string[] files = Directory.GetFiles(“C:\\MyFolder”);
foreach (string file in files)
{
Console.WriteLine(Path.GetFileName(file));
}
// 获取所有子目录
string[] directories = Directory.GetDirectories(“C:\\MyFolder”);
foreach (string dir in directories)
{
Console.WriteLine(Path.GetFileName(dir));
}
// 递归遍历所有文件
var allFiles = Directory.GetFiles(“C:\\MyFolder”, “*.*”, SearchOption.AllDirectories);
3. 异常处理
3.1 常见的文件操作异常
文件操作可能遇到的异常类型包括:
FileNotFoundException
: 文件不存在
DirectoryNotFoundException
: 目录不存在
IOException
: IO相关错误
UnauthorizedAccessException
: 权限不足
PathTooLongException
: 路径过长
3.2 基本异常处理
using System;
using System.IO;
class Program
{
static void Main()
{
string filePath = “important.txt”;
try
{
string content = File.ReadAllText(filePath);
Console.WriteLine(content);
}
catch (FileNotFoundException ex)
{
Console.WriteLine($”错误:文件未找到 – {ex.Message}”);
}
catch (UnauthorizedAccessException ex)
{
Console.WriteLine($”错误:没有访问权限 – {ex.Message}”);
}
catch (IOException ex)
{
Console.WriteLine($”IO错误:{ex.Message}”);
}
catch (Exception ex)
{
Console.WriteLine($”未知错误:{ex.Message}”);
}
}
}
3.3 使用 finally 块确保资源释放
StreamReader reader = null;
try
{
reader = new StreamReader(“file.txt”);
// 处理文件
}
catch (Exception ex)
{
Console.WriteLine($”错误:{ex.Message}”);
}
finally
{
// 确保资源被释放
reader?.Dispose();
}
3.4 使用 try-finally 和 using 语句
C# 提供了
using
语句来自动处理资源释放:
using (StreamReader reader = new StreamReader(“file.txt”))
{
// 处理文件
// reader 会在代码块结束时自动释放
}
或者使用 C# 8.0 的简化语法:
using var reader = new StreamReader(“file.txt”);
// 处理文件
// reader 会在方法结束时自动释放
4. 高级文件操作
4.1 文件流操作
使用 FileStream 进行二进制文件读写
using System;
using System.IO;
class Program
{
static void Main()
{
// 写入二进制数据
byte[] data = { 1, 2, 3, 4, 5 };
using (FileStream fs = new FileStream(“data.bin”, FileMode.Create))
{
fs.Write(data, 0, data.Length);
}
// 读取二进制数据
using (FileStream fs = new FileStream(“data.bin”, FileMode.Open))
{
byte[] buffer = new byte[fs.Length];
fs.Read(buffer, 0, buffer.Length);
Console.WriteLine(“读取的数据:”);
foreach (byte b in buffer)
{
Console.Write(b + ” “);
}
}
}
}
使用 MemoryMappedFile 处理大文件
using System;
using System.IO;
using System.IO.MemoryMappedFiles;
class Program
{
static void Main()
{
string filePath = “largefile.dat”;
// 创建或打开内存映射文件
using (var mmf = MemoryMappedFile.CreateFromFile(filePath))
{
using (var accessor = mmf.CreateViewAccessor())
{
// 读取文件开头的4个字节
int value = accessor.ReadInt32(0);
Console.WriteLine($”第一个整数: {value}”);
// 修改数据
accessor.Write(0, 12345);
}
}
}
}
4.2 文件监控
使用 FileSystemWatcher 监控文件变化
using System;
using System.IO;
class Program
{
static void Main()
{
FileSystemWatcher watcher = new FileSystemWatcher();
watcher.Path = @”C:\MyFolder”;
watcher.Filter = “*.txt”;
watcher.NotifyFilter = NotifyFilters.LastWrite | NotifyFilters.FileName | NotifyFilters.DirectoryName;
// 注册事件处理器
watcher.Changed += OnChanged;
watcher.Created += OnCreated;
watcher.Deleted += OnDeleted;
watcher.Renamed += OnRenamed;
// 开始监控
watcher.EnableRaisingEvents = true;
Console.WriteLine(“开始监控文件变化,按任意键退出…”);
Console.ReadKey();
}
private static void OnChanged(object source, FileSystemEventArgs e)
{
Console.WriteLine($”文件 {e.Name} 已修改”);
}
private static void OnCreated(object source, FileSystemEventArgs e)
{
Console.WriteLine($”新文件创建: {e.Name}”);
}
private static void OnDeleted(object source, FileSystemEventArgs e)
#
{
Console.WriteLine($”文件被删除: {e.Name}”);
}
private static void OnRenamed(object source, RenamedEventArgs e)
{
Console.WriteLine($”文件重命名: {e.OldName} -> {e.Name}”);
}
}
5. 性能优化
5.1 缓冲区大小调整
// 默认缓冲区大小通常为4KB,对于大文件操作可以增大缓冲区
using (FileStream fs = new FileStream(“largefile.dat”, FileMode.Open, FileAccess.Read, FileShare.Read, 65536))
{
// 使用64KB缓冲区
byte[] buffer = new byte[65536];
int bytesRead;
while ((bytesRead = fs.Read(buffer, 0, buffer.Length)) > 0)
{
// 处理数据
}
}
5.2 异步文件操作
using System;
using System.IO;
using System.Threading.Tasks;
class Program
{
static async Task Main()
{
string filePath = “asyncfile.txt”;
// 异步写入
string content = “这是异步写入的内容”;
await File.WriteAllTextAsync(filePath, content);
// 异步读取
string readContent = await File.ReadAllTextAsync(filePath);
Console.WriteLine(readContent);
// 使用 FileStream 进行异步操作
using (FileStream fs = new FileStream(“async.dat”, FileMode.Create, FileAccess.Write, FileShare.None, 4096, true))
{
byte[] data = System.Text.Encoding.UTF8.GetBytes(“异步写入的数据”);
await fs.WriteAsync(data, 0, data.Length);
}
}
}
5.3 使用 FileOptions.Asynchronous 提升性能
using (FileStream fs = new FileStream(“asyncfile.dat”,
FileMode.Create,
FileAccess.Write,
FileShare.None,
4096,
FileOptions.Asynchronous))
{
// 异步操作
}
5.4 使用 FileOptions.DeleteOnClose
// 创建临时文件,在关闭时自动删除
using (FileStream fs = new FileStream(“tempfile.tmp”,
FileMode.Create,
FileAccess.ReadWrite,
FileShare.None,
4096,
FileOptions.DeleteOnClose))
{
// 使用临时文件
// 文件会在 using 块结束时自动删除
}
6. 实战案例:日志系统
6.1 设计一个简单的日志系统
using System;
using System.IO;
using System.Threading;
public class Logger
{
private readonly string _logFilePath;
private readonly object _lockObject = new object();
public Logger(string logFilePath)
{
_logFilePath = logFilePath;
}
public void Log(string message)
{
string logEntry = $”[{DateTime.Now:yyyy-MM-dd HH:mm:ss.fff}] {message}”;
lock (_lockObject)
{
// 使用追加模式写入
using (StreamWriter writer = new StreamWriter(_logFilePath, true))
{
writer.WriteLine(logEntry);
}
}
}
public void LogWithRetry(string message, int maxRetries = 3)
{
for (int i = 0; i < maxRetries; i++)
{
try
{
Log(message);
return;
}
catch (IOException)
{
if (i == maxRetries - 1)
throw;
// 等待后重试
Thread.Sleep(100);
}
}
}
}
// 使用示例
class Program
{
static void Main()
{
Logger logger = new Logger("app.log");
// 正常日志
logger.Log("应用程序启动");
// 带重试的日志
logger.LogWithRetry("执行关键操作");
// 并发日志测试
Parallel.For(0, 10, i =>
{
logger.Log($”线程 {i} 写入日志”);
});
}
}
6.2 日志系统优化
using System;
using System.Collections.Concurrent;
using System.IO;
using System.Threading;
using System.Threading.Tasks;
public class AsyncLogger
{
private readonly string _logFilePath;
private readonly BlockingCollection
private readonly Task _processingTask;
private readonly CancellationTokenSource _cts;
public AsyncLogger(string logFilePath)
{
_logFilePath = logFilePath;
_logQueue = new BlockingCollection
_cts = new CancellationTokenSource();
// 启动后台处理任务
_processingTask = Task.Run(() => ProcessLogs(_cts.Token));
}
public void Log(string message)
{
string logEntry = $”[{DateTime.Now:yyyy-MM-dd HH:mm:ss.fff}] {message}”;
_logQueue.Add(logEntry);
}
private async Task ProcessLogs(CancellationToken token)
{
while (!token.IsCancellationRequested)
{
try
{
// 批量处理日志
var batch = new List
// 收集一批日志(最多100条或最多等待100ms)
for (int i = 0; i < 100; i++)
{
if (_logQueue.TryTake(out string logEntry, 100, token))
{
batch.Add(logEntry);
}
else
{
break;
}
}
if (batch.Count > 0)
{
// 异步写入
using (StreamWriter writer = new StreamWriter(_logFilePath, true))
{
foreach (var entry in batch)
{
await writer.WriteLineAsync(entry);
}
}
}
}
catch (OperationCanceledException)
{
break;
}
catch (Exception ex)
{
// 记录错误到备用位置
Console.WriteLine($”日志写入失败: {ex.Message}”);
}
}
}
public async Task ShutdownAsync()
{
_cts.Cancel();
await _processingTask;
}
}
// 使用示例
class Program
{
static async Task Main()
{
var logger = new AsyncLogger(“async_app.log”);
// 并发写入日志
var tasks = new List
for (int i = 0; i < 1000; i++)
{
int id = i;
tasks.Add(Task.Run(() => logger.Log($”日志条目 {id}”)));
}
await Task.WhenAll(tasks);
// 关闭日志系统
await logger.ShutdownAsync();
Console.WriteLine(“日志写入完成”);
}
}
7. 最佳实践总结
7.1 资源管理
始终使用
using
语句或
try-finally
确保资源释放
避免在循环中频繁打开/关闭文件
对于大文件,使用流式处理而非一次性加载
7.2 异常处理
针对不同异常类型提供具体处理
实现重试机制应对临时性错误
记录详细的错误信息用于调试
7.3 性能优化
根据文件大小调整缓冲区
对IO密集型操作使用异步方法
考虑使用内存映射文件处理超大文件
7.4 安全性
验证用户输入的路径
处理权限问题
防止路径注入攻击
7.5 跨平台考虑
使用
Path.Combine()
而不是硬编码路径分隔符
注意不同平台的路径长度限制
处理大小写敏感性问题
8. 总结
本文详细介绍了C#中文件操作的各个方面,从基础的读写操作到高级的异常处理和性能优化。通过合理运用这些技术和最佳实践,你可以构建出健壮、高效且易于维护的文件处理代码。记住,良好的文件操作不仅要实现功能,还要考虑错误处理、性能和资源管理等多个方面。
在实际开发中,建议根据具体需求选择合适的API和策略。对于简单任务,
File
类的静态方法足够;对于复杂场景,可能需要使用流式处理、异步操作或内存映射文件等高级技术。持续学习和实践是掌握文件操作的关键。