当前博文未提及该问题，以下是基于C知道的知识内容为您回答。 针对您在 .NET Framework 4.5.2 的 WinForm 环境下，需要实现一个**无需按钮触发、支持任务取消、具备单文件超时重试机制、任务执行互斥且包含完善错误处理**的批量文件上传功能，以下提供一个可直接集成到现有 WinForm 程序中的完整解决方案。本方案充分利用 .NET 4.5.2 的异步编程模型和 `CancellationToken` 机制，确保代码简洁高效。 ### 1. 核心设计概览 我们将构建一个名为 `BatchFileUploadService` 的后台服务类，它封装所有上传逻辑，并通过事件与 WinForm 界面进行通信。服务启动后，将自动扫描并上传文件，同时允许用户通过界面取消任务。 下表概括了需求与实现方案的对应关系： | 需求点 | WinForm 实现方案 | 核心技术 | 说明 | | :--- | :--- | :--- | :--- | | **不用按钮触发** | 在窗体加载或特定业务逻辑（如定时器）中调用服务启动方法。 | `async/await`, `Task.Run` | 将上传任务作为后台服务运行，不阻塞UI线程。 | | **上传到公共盘** | 使用 `File.Copy` 方法操作网络共享路径（UNC）。 | `System.IO.File.Copy` | 适用于局域网文件共享。若需HTTP上传，可替换为 `WebClient` [ref_2]。 | | **可取消任务** | 提供 `Cancel` 方法，绑定到UI的取消按钮。 | `CancellationTokenSource` | 实现协作式取消，安全终止任务 [ref_5]。 | | **单文件超时机制** | 为每个文件创建带超时的 `CancellationTokenSource`。 | `CancellationTokenSource.CancelAfter()` | 每个文件独立计时，超时则触发取消。 | | **超时取消后重试** | 在循环中捕获超时异常，进行重试直至成功或达到最大次数。 | `try-catch`, `for` 循环 | 区分用户取消与超时取消，仅对后者重试。 | | **任务互斥** | 使用锁和状态标志，确保服务同一时间只运行一个实例。 | `lock` 语句, `bool` 标志 | 防止并发启动多个上传任务。 | | **错误处理机制** | 分层捕获并记录所有异常，通过事件通知UI。 | `try-catch`, 自定义事件 | 确保程序健壮性，并提供用户反馈。 | | **WinForm集成** | 通过事件更新进度条和日志文本框。 | `EventHandler<T>`，`Control.Invoke` | 实现线程安全的UI更新。 | ### 2. 核心服务类实现 创建一个 `BatchFileUploadService.cs` 文件，并添加以下代码： ```csharp using System; using System.Collections.Generic; using System.IO; using System.Linq; using System.Threading; using System.Threading.Tasks; namespace YourWinFormApp.Services { /// <summary> /// 批量文件上传服务（后台运行） /// </summary> public class BatchFileUploadService { private readonly object _lock = new object(); private bool _isRunning = false; private CancellationTokenSource _globalCts; // 定义上传进度事件参数 public class UploadProgressEventArgs : EventArgs { public string CurrentFile { get; set; } public int TotalFiles { get; set; } public int ProcessedCount { get; set; } public int SuccessCount { get; set; } public int FailedCount { get; set; } public string StatusMessage { get; set; } } // 定义日志事件参数 public class LogMessageEventArgs : EventArgs { public string Message { get; set; } public LogLevel Level { get; set; } } public enum LogLevel { Info, Warning, Error } // 事件：进度更新和日志消息 public event EventHandler<UploadProgressEventArgs> ProgressChanged; public event EventHandler<LogMessageEventArgs> LogMessage; /// <summary> /// 启动异步上传任务 /// </summary> /// <param name="sourceDirectory">本地源目录</param> /// <param name="targetDirectory">公共盘目标目录 (UNC路径，如 \\server\share)</param> /// <param name="searchPattern">文件搜索模式，默认所有文件</param> /// <param name="maxRetries">单个文件最大重试次数</param> /// <param name="perFileTimeoutMs">单个文件上传超时时间（毫秒）</param> /// <returns>表示异步操作的任务</returns> /// <exception cref="InvalidOperationException">当任务已在运行时抛出</exception> public async Task StartUploadAsync(string sourceDirectory, string targetDirectory, string searchPattern = "*.*", int maxRetries = 3, int perFileTimeoutMs = 10000) { // 1. 任务互斥检查 lock (_lock) { if (_isRunning) { throw new InvalidOperationException("上传任务正在执行中，无法启动新任务。"); } _isRunning = true; _globalCts = new CancellationTokenSource(); } int totalFiles = 0, processed = 0, success = 0, failed = 0; List<FileInfo> fileList = null; try { OnLogMessage($"开始扫描源目录: {sourceDirectory}", LogLevel.Info); var sourceDirInfo = new DirectoryInfo(sourceDirectory); if (!sourceDirInfo.Exists) { throw new DirectoryNotFoundException($"源目录不存在: {sourceDirectory}"); } // 使用 EnumerateFiles 进行高效文件遍历，支持递归 [ref_1] fileList = sourceDirInfo.EnumerateFiles(searchPattern, SearchOption.TopDirectoryOnly).ToList(); totalFiles = fileList.Count; if (totalFiles == 0) { OnLogMessage("未找到符合条件的文件。", LogLevel.Info); return; } OnLogMessage($"找到 {totalFiles} 个待上传文件。", LogLevel.Info); // 确保目标目录存在 if (!Directory.Exists(targetDirectory)) { Directory.CreateDirectory(targetDirectory); OnLogMessage($"已创建目标目录: {targetDirectory}", LogLevel.Info); } OnProgressChanged("开始上传...", null, totalFiles, processed, success, failed); // 2. 遍历并上传每个文件 foreach (var file in fileList) { // 检查全局取消请求 _globalCts.Token.ThrowIfCancellationRequested(); processed++; bool fileUploaded = false; Exception lastError = null; // 3. 单文件重试循环 for (int retryCount = 0; retryCount <= maxRetries; retryCount++) { if (_globalCts.Token.IsCancellationRequested) break; try { OnLogMessage($"正在上传 [{retryCount + 1}/{maxRetries + 1}]: {file.Name}", LogLevel.Info); // 执行带超时的文件上传 await UploadSingleFileWithTimeoutAsync(file, targetDirectory, perFileTimeoutMs, _globalCts.Token).ConfigureAwait(false); fileUploaded = true; success++; OnLogMessage($"文件 {file.Name} 上传成功。", LogLevel.Info); break; // 成功则跳出重试循环 } catch (OperationCanceledException) when (_globalCts.Token.IsCancellationRequested) { // 用户主动取消，直接抛出 throw; } catch (OperationCanceledException ex) { // 超时导致的取消 lastError = new TimeoutException($"文件 {file.Name} 上传超时（{perFileTimeoutMs}ms）。", ex); OnLogMessage($"文件 {file.Name} 第 {retryCount + 1} 次尝试超时。", LogLevel.Warning); } catch (IOException ioEx) { // 网络问题、文件被占用等IO错误 lastError = ioEx; OnLogMessage($"文件 {file.Name} IO错误: {ioEx.Message}", LogLevel.Error); } catch (UnauthorizedAccessException authEx) { // 权限错误 lastError = authEx; OnLogMessage($"文件 {file.Name} 权限错误: {authEx.Message}", LogLevel.Error); break; // 权限问题通常重试无效，直接失败 } catch (Exception ex) { // 其他未知错误 lastError = ex; OnLogMessage($"文件 {file.Name} 发生未知错误: {ex.Message}", LogLevel.Error); } // 如果失败且未达最大重试次数，等待后重试 if (!fileUploaded && retryCount < maxRetries) { await Task.Delay(2000, _globalCts.Token).ConfigureAwait(false); // 等待2秒后重试 } } if (!fileUploaded) { failed++; OnLogMessage($"文件 {file.Name} 上传失败，最终错误: {lastError?.Message}", LogLevel.Error); } // 更新进度 OnProgressChanged($"处理中: {file.Name}", file.Name, totalFiles, processed, success, failed); } OnProgressChanged("上传任务完成。", null, totalFiles, processed, success, failed); OnLogMessage($"任务完成。成功: {success}, 失败: {failed}", LogLevel.Info); } catch (OperationCanceledException) { OnProgressChanged("任务已被用户取消。", null, totalFiles, processed, success, failed); OnLogMessage("上传任务已取消。", LogLevel.Info); } catch (Exception ex) { OnProgressChanged($"任务发生错误: {ex.Message}", null, totalFiles, processed, success, failed); OnLogMessage($"任务严重错误: {ex.Message}", LogLevel.Error); throw; // 可选择向上抛出或在此处理 } finally { // 4. 清理状态 lock (_lock) { _isRunning = false; _globalCts?.Dispose(); _globalCts = null; } } } /// <summary> /// 取消当前正在运行的上传任务 /// </summary> public void CancelUpload() { lock (_lock) { if (_isRunning && _globalCts != null && !_globalCts.IsCancellationRequested) { _globalCts.Cancel(); OnLogMessage("已发送取消指令。", LogLevel.Info); } } } /// <summary> /// 获取服务当前运行状态 /// </summary> public bool IsRunning { get { lock (_lock) return _isRunning; } } /// <summary> /// 执行单个文件的带超时上传 /// </summary> private async Task UploadSingleFileWithTimeoutAsync(FileInfo sourceFile, string targetDir, int timeoutMs, CancellationToken globalToken) { // 创建链接的取消令牌源，同时响应全局取消和单文件超时 [ref_5] using (var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(globalToken)) { linkedCts.CancelAfter(timeoutMs); // 设置单文件超时 string targetFilePath = Path.Combine(targetDir, sourceFile.Name); // 将同步的 File.Copy 操作包装为异步任务 await Task.Run(() => { // 检查取消请求 linkedCts.Token.ThrowIfCancellationRequested(); // 核心文件复制操作 sourceFile.CopyTo(targetFilePath, overwrite: true); }, linkedCts.Token).ConfigureAwait(false); } } // 触发进度更新事件 protected virtual void OnProgressChanged(string status, string currentFile, int total, int processed, int success, int failed) { ProgressChanged?.Invoke(this, new UploadProgressEventArgs { StatusMessage = status, CurrentFile = currentFile, TotalFiles = total, ProcessedCount = processed, SuccessCount = success, FailedCount = failed }); } // 触发日志消息事件 protected virtual void OnLogMessage(string message, LogLevel level) { LogMessage?.Invoke(this, new LogMessageEventArgs { Message = $"[{DateTime.Now:HH:mm:ss}] {message}", Level = level }); } } } ``` ### 3. WinForm 界面集成示例 在您的主窗体（如 `MainForm.cs`）中，集成该服务并更新UI。 ```csharp using System; using System.Windows.Forms; using YourWinFormApp.Services; // 引入服务命名空间 namespace YourWinFormApp { public partial class MainForm : Form { private readonly BatchFileUploadService _uploadService = new BatchFileUploadService(); private bool _isUploading = false; public MainForm() { InitializeComponent(); SetupUploadServiceEvents(); // 示例：窗体加载后自动开始上传（模拟“不用按钮触发”） this.Load += MainForm_Load; } private void SetupUploadServiceEvents() { // 绑定服务的事件到UI更新方法 _uploadService.ProgressChanged += UploadService_ProgressChanged; _uploadService.LogMessage += UploadService_LogMessage; } private async void MainForm_Load(object sender, EventArgs e) { // 示例：程序启动后自动执行上传任务 // 在实际应用中，这里可以是定时器触发、文件系统监视器触发等 await StartAutoUploadAsync(); } private async Task StartAutoUploadAsync() { if (_isUploading) return; string localPath = @"C:\YourLocalFiles"; // 替换为您的本地路径 string networkPath = @"\\YourServer\PublicShare\TargetFolder"; // 替换为您的公共盘UNC路径 try { _isUploading = true; btnCancel.Enabled = true; // 假设有一个取消按钮 AppendLog("开始自动上传任务..."); // 启动上传服务 await _uploadService.StartUploadAsync( sourceDirectory: localPath, targetDirectory: networkPath, searchPattern: "*.*", maxRetries: 3, perFileTimeoutMs: 5000 // 5秒超时 ); } catch (InvalidOperationException ex) { MessageBox.Show(ex.Message, "提示", MessageBoxButtons.OK, MessageBoxIcon.Information); } catch (Exception ex) { AppendLog($"任务启动失败: {ex.Message}", isError: true); } finally { _isUploading = false; btnCancel.Enabled = false; } } // 处理进度更新事件（确保线程安全） private void UploadService_ProgressChanged(object sender, BatchFileUploadService.UploadProgressEventArgs e) { // 使用 Invoke 确保在UI线程上更新控件 if (this.InvokeRequired) { this.Invoke(new Action(() => UploadService_ProgressChanged(sender, e))); return; } lblStatus.Text = e.StatusMessage; progressBar1.Maximum = e.TotalFiles; progressBar1.Value = e.ProcessedCount; lblProgress.Text = $"进度: {e.ProcessedCount}/{e.TotalFiles} (成功: {e.SuccessCount}, 失败: {e.FailedCount})"; } // 处理日志消息事件 private void UploadService_LogMessage(object sender, BatchFileUploadService.LogMessageEventArgs e) { if (this.InvokeRequired) { this.Invoke(new Action(() => UploadService_LogMessage(sender, e))); return; } AppendLog(e.Message, e.Level == BatchFileUploadService.LogLevel.Error); } // 取消按钮点击事件 private void btnCancel_Click(object sender, EventArgs e) { _uploadService.CancelUpload(); } // 辅助方法：向日志文本框追加内容 private void AppendLog(string message, bool isError = false) { if (isError) txtLog.AppendText($"[错误] {message}{Environment.NewLine}"); else txtLog.AppendText($"{message}{Environment.NewLine}"); txtLog.ScrollToCaret(); } } } ``` ### 4. 关键特性与优化说明 1. **真正的后台任务**：通过 `async/await` 和 `Task.Run`，上传任务完全在后台线程执行，UI保持响应。用户可以在上传过程中进行其他操作或点击取消按钮 [ref_4]。 2. **精细的超时与取消控制**：`UploadSingleFileWithTimeoutAsync` 方法中使用了 `CancellationTokenSource.CreateLinkedTokenSource`，将全局取消令牌和单个文件的超时令牌链接。这意味着任何一方的取消请求都能立即中断文件复制操作，实现了精确控制 [ref_5]。 3. **健壮的错误处理与重试**：代码中针对不同类型的异常（`OperationCanceledException`、`IOException`、`UnauthorizedAccessException`）进行了分层捕获和处理。对于网络波动导致的超时或IO错误，会进行重试；对于权限错误等不可恢复问题，则直接标记失败。 4. **线程安全的UI更新**：所有通过事件从后台服务传递到UI的更新，都通过 `Control.Invoke` 方法确保在UI线程上执行，避免了跨线程访问控件导致的异常，这是 WinForm 多线程编程的必备技巧。 5. **高效的文件遍历**：服务中使用 `DirectoryInfo.EnumerateFiles` 而非 `GetFiles`。`EnumerateFiles` 采用延迟加载（yield return），在遍历海量文件时能显著降低内存占用，提升初始响应速度 [ref_1]。 6. **即插即用**：将 `BatchFileUploadService` 类放入您的项目，并在主窗体中实例化、绑定事件、调用 `StartUploadAsync` 方法即可。您可以根据需要，将启动逻辑放在 `Form_Load`、`Timer_Tick` 或任何业务触发点，完美实现“不用按钮触发”。