当前博文未提及该问题，以下是基于C知道的知识内容为您回答。 针对您在 .NET 4.5.2 WinForm 环境下提出的文件上传需求，特别是增加了“运行内存占用小”这一优化指标，以下方案在之前的基础上进行了深度优化。本方案采用**流式处理**替代全量加载，并结合**内存优化策略**，确保程序在长时间运行或处理大量文件时依然保持轻量级。 ### 1. 核心架构与内存优化策略 为了满足“简洁高效”和“内存占用小”的要求，本方案在架构设计上做出了以下针对性调整： | 优化维度 | 具体策略 | 技术实现 | | :--- | :--- | :--- | | **I/O 处理** | 流式读写，避免文件全量加载至内存 | 使用 `FileStream` 进行分块读写 [ref_6] | | **日志管理** | 限制 UI 缓冲区，异步刷盘 | `StringBuilder` 拼接 + 定时清理 TextBox 内容 [ref_4] | | **并发控制** | 严格单线程串行上传，防止内存峰值 | `CancellationTokenSource` 互斥锁 [ref_5] | | **资源释放** | 及时释放文件句柄和流对象 | `using` 语句块显式 Dispose | ### 2. 完整代码实现 #### 2.1 轻量级日志组件 (优化版) 该组件优化了 TextBox 的内存占用，并确保日志不阻塞主线程。 ```csharp using System; using System.IO; using System.Text; using System.Threading; using System.Threading.Tasks; using System.Windows.Forms; public class OptimizedLogger : IDisposable { private readonly TextBox _uiTextBox; private readonly string _logFilePath; private readonly StringBuilder _logBuilder = new StringBuilder(); private readonly Timer _uiFlushTimer; private readonly object _lockObj = new object(); public OptimizedLogger(TextBox textBox, string logDirectory) { _uiTextBox = textBox; if (!Directory.Exists(logDirectory)) Directory.CreateDirectory(logDirectory); _logFilePath = Path.Combine(logDirectory, $"Log_{DateTime.Now:yyyyMMdd_HHmmss}.txt"); // 使用定时器降低 UI 刷新频率，减少 GDI 开销 [ref_4] _uiFlushTimer = new Timer(FlushUi, null, 500, 500); } public void Log(string message, bool isError = false) { string logEntry = $"[{DateTime.Now:HH:mm:ss.fff}] {(isError ? "[ERROR] " : "")}{message}"; // 1. 异步写入文件（不占用主线程资源） Task.Run(() => { try { File.AppendAllText(_logFilePath, logEntry + Environment.NewLine); } catch { /* 忽略文件 IO 异常 */ } }); // 2. 加入内存缓冲队列，准备显示 lock (_lockObj) { _logBuilder.AppendLine(logEntry); } } private void FlushUi(object state) { if (_uiTextBox == null || _uiTextBox.IsDisposed) return; string contentToDisplay; lock (_lockObj) { if (_logBuilder.Length == 0) return; contentToDisplay = _logBuilder.ToString(); _logBuilder.Clear(); } try { if (_uiTextBox.InvokeRequired) { _uiTextBox.Invoke(new Action(() => AppendTextToUi(contentToDisplay))); } else { AppendTextToUi(contentToDisplay); } } catch { } } private void AppendTextToUi(string text) { _uiTextBox.AppendText(text); // 内存优化：限制 TextBox 最大长度，防止内存无限增长 [ref_4] const int MAX_CHARS = 10000; if (_uiTextBox.TextLength > MAX_CHARS) { int removeLength = _uiTextBox.TextLength - MAX_CHARS; // 简单的截断策略，实际应用中可按行移除 _uiTextBox.Select(0, removeLength); _uiTextBox.SelectedText = string.Empty; } _uiTextBox.ScrollToCaret(); } public void Dispose() { _uiFlushTimer?.Dispose(); // 将剩余日志写入文件 if (_logBuilder.Length > 0) { File.AppendAllText(_logFilePath, _logBuilder.ToString()); } } } ``` #### 2.2 上传服务核心逻辑 (含超时与重试) 使用 `FileStream` 分块复制，降低内存占用，并实现严格的超时控制。 ```csharp using System; using System.IO; using System.Linq; using System.Threading; using System.Threading.Tasks; public class MemoryEfficientUploadService { private readonly OptimizedLogger _logger; private readonly int _maxRetryCount = 3; private readonly int _timeoutMilliseconds = 15000; // 15秒超时 public bool IsBusy { get; private set; } public CancellationTokenSource CurrentCts { get; private set; } public event Action<int, int, string> ProgressChanged; public MemoryEfficientUploadService(OptimizedLogger logger) { _logger = logger; } public async Task StartUploadAsync(string sourcePath, string targetPath) { if (IsBusy) { _logger.Log("系统正忙，任务执行中不可添加新任务。", true); return; } IsBusy = true; CurrentCts = new CancellationTokenSource(); try { _logger.Log($"开始扫描目录: {sourcePath}"); // 仅获取文件信息，不加载文件内容 [ref_1] var files = Directory.GetFiles(sourcePath, "*.*", SearchOption.TopDirectoryOnly); int totalFiles = files.Length; int processedFiles = 0; foreach (var file in files) { CurrentCts.Token.ThrowIfCancellationRequested(); string fileName = Path.GetFileName(file); string destFile = Path.Combine(targetPath, fileName); processedFiles++; ProgressChanged?.Invoke(processedFiles, totalFiles, fileName); await ProcessFileWithRetryAsync(file, destFile, CurrentCts.Token); } _logger.Log("所有文件处理完毕。"); } catch (OperationCanceledException) { _logger.Log("用户取消了上传任务。", true); } catch (Exception ex) { _logger.Log($"发生未处理异常: {ex.Message}", true); } finally { IsBusy = false; CurrentCts?.Dispose(); CurrentCts = null; // 建议在任务结束后手动触发一次 GC，虽然非必须，但在 WinForm 中有助于快速回收内存 [ref_4] GC.Collect(); GC.WaitForPendingFinalizers(); } } private async Task ProcessFileWithRetryAsync(string sourceFile, string destFile, CancellationToken token) { int retryCount = 0; bool success = false; while (!success && retryCount <= _maxRetryCount) { try { token.ThrowIfCancellationRequested(); _logger.Log($"正在上传: {Path.GetFileName(sourceFile)} (第 {retryCount + 1} 次尝试)"); // 定义上传任务 var uploadTask = CopyFileWithStreamAsync(sourceFile, destFile, token); // 定义超时任务 var timeoutTask = Task.Delay(_timeoutMilliseconds, token); // 等待任一任务完成 [ref_5] var completedTask = await Task.WhenAny(uploadTask, timeoutTask); if (completedTask == timeoutTask) { throw new TimeoutException("文件传输超时"); } await uploadTask; // 检查是否有内部异常 success = true; _logger.Log($"成功: {Path.GetFileName(sourceFile)}"); } catch (Exception ex) { retryCount++; if (retryCount > _maxRetryCount) { _logger.Log($"失败: {Path.GetFileName(sourceFile)} (超过重试限制)。原因: {ex.Message}", true); } else { _logger.Log($"重试中... 原因: {ex.Message}", true); await Task.Delay(2000, token); // 延迟 2 秒 } } } } // 使用流式复制，极大降低内存占用 [ref_6] private async Task CopyFileWithStreamAsync(string source, string destination, CancellationToken token) { await Task.Run(() => { string destDir = Path.GetDirectoryName(destination); if (!Directory.Exists(destDir)) Directory.CreateDirectory(destDir); // 使用 FileStream 缓冲区大小设置为 80KB，平衡速度与内存 using (FileStream sourceStream = new FileStream(source, FileMode.Open, FileAccess.Read, FileShare.Read, 81920, true)) using (FileStream destStream = new FileStream(destination, FileMode.Create, FileAccess.Write, FileShare.None, 81920, true)) { sourceStream.CopyTo(destStream, 81920); // 80KB buffer } }, token); } public void CancelUpload() { CurrentCts?.Cancel(); } } ``` #### 2.3 WinForm 界面调用 (集成进度条) ```csharp using System; using System.IO; using System.Windows.Forms; namespace MemoryEfficientUploader { public partial class MainForm : Form { private MemoryEfficientUploadService _uploadService; private OptimizedLogger _logger; private readonly string _sourcePath = @"C:\Temp\UploadSource"; private readonly string _targetPath = @"\\192.168.1.100\PublicShare"; // 示例公共盘 private readonly string _logDir = Path.Combine(Application.StartupPath, "Logs"); public MainForm() { InitializeComponent(); InitializeComponents(); } private void InitializeComponents() { _logger = new OptimizedLogger(txtLog, _logDir); _uploadService = new MemoryEfficientUploadService(_logger); _uploadService.ProgressChanged += OnProgressChanged; } private void btnStart_Click(object sender, EventArgs e) { // 防止重复点击 btnStart.Enabled = false; btnCancel.Enabled = true; // 异步启动 _uploadService.StartUploadAsync(_sourcePath, _targetPath); } private void btnCancel_Click(object sender, EventArgs e) { _uploadService.CancelUpload(); } private void OnProgressChanged(int current, int total, string fileName) { if (this.InvokeRequired) { this.Invoke(new Action<int, int, string>(OnProgressChanged), current, total, fileName); return; } progressBar1.Maximum = total; progressBar1.Value = current; lblStatus.Text = $"进度: {current}/{total} - {fileName}"; // 任务结束后恢复按钮状态 if (current == total) { btnStart.Enabled = true; btnCancel.Enabled = false; } } protected override void OnFormClosing(FormClosingEventArgs e) { _logger?.Dispose(); base.OnFormClosing(e); } } } ``` ### 3. 内存优化关键点解析 1. **流式文件复制**： 在 `CopyFileWithStreamAsync` 方法中，我们没有使用 `File.ReadAllBytes` 或 `File.Copy` 的简单封装，而是显式使用 `FileStream` 并指定了缓冲区大小（81920 字节）。这种方式允许操作系统高效地管理 I/O，而无需将整个大文件加载到应用程序的内存堆中 [ref_6]。 2. **UI 控件内存管理**： WinForm 的 `TextBox` 控件如果持有过长的文本，会消耗大量内存。在 `OptimizedLogger` 中，我们通过 `StringBuilder` 缓冲日志，并定期检查 `TextLength`，一旦超过阈值（如 10000 字符），即从头部移除旧文本。这确保了 UI 线程的内存占用保持稳定 [ref_4]。 3. **垃圾回收策略**： 在 `finally` 块中，建议调用 `GC.Collect()`。虽然在 .NET 中通常不推荐手动 GC，但在处理大量文件句柄和流对象的 WinForm 任务结束后，手动触发一次 GC 可以迅速释放不再使用的文件资源，防止内存泄漏导致的程序变慢 [ref_4]。 4. **异步非阻塞**： 所有的 I/O 操作（文件读写、日志写入）均使用 `Task.Run` 或异步 API 移至后台线程，主线程仅负责轻量的 UI 更新，这降低了 UI 线程的内存压力并保证界面流畅 [ref_3]。