我太懂这种感觉了——涉及系统剪贴板、文件操作的单元测试总是比普通业务逻辑难搞，要么依赖真实资源慢得要死，要么测试用例容易污染环境，网上的教程又总是讲得太抽象。针对你贴的DoCtrlV方法，我给你一套能直接落地的方案，分步骤来：

直接用System.Windows.Clipboard这种静态类的话，单元测试里根本没法模拟它的行为，所以第一步要把硬依赖的系统服务抽象出来：

1. 抽象剪贴板操作接口 #

public interface IClipboardService
{
    StringCollection GetFileDropList();
    // 如果有其他剪贴板操作（比如设置内容），也可以在这里加对应的方法
}

2. 实现生产环境用的剪贴板服务 #

public class WpfClipboardService : IClipboardService
{
    public StringCollection GetFileDropList()
    {
        return System.Windows.Clipboard.GetFileDropList();
    }
}

3. 改造你的资源管理器类，用依赖注入替代直接调用静态类 #

public class FileExplorer
{
    private readonly IClipboardService _clipboardService;
    // 后面还要抽象文件系统操作，这里先留位置：private readonly IFileSystemService _fileSystem;

    // 通过构造函数注入依赖，测试时可以传Mock对象
    public FileExplorer(IClipboardService clipboardService/*, IFileSystemService fileSystem*/)
    {
        _clipboardService = clipboardService;
        // _fileSystem = fileSystem;
    }

    public void DoCtrlV(object obj)
    {
        try
        {
            StopWait();
            // 把原来的System.Windows.Clipboard改成用注入的服务
            var list = _clipboardService.GetFileDropList(); 
            if (list.Count > 0)
            {
                // 原来的文件复制/移动逻辑，后面要改成调用抽象的文件系统服务
            }
        }
        catch (Exception ex)
        {
            // 异常处理逻辑
        }
    }

    // 如果这个方法有副作用，测试时可以改成protected virtual，方便子类重写为空实现
    private void StopWait()
    {
        // 你的原有实现
    }
}

和剪贴板一样，直接用System.IO的API会依赖真实文件系统，同样要抽象：

1. 定义文件系统操作接口 #

public interface IFileSystemService
{
    void CopyFile(string sourcePath, string destPath, bool overwrite);
    void MoveFile(string sourcePath, string destPath);
    bool DirectoryExists(string path);
    bool FileExists(string path);
    // 根据你的业务逻辑补充需要的方法
}

2. 实现生产环境的文件系统服务 #

public class RealFileSystemService : IFileSystemService
{
    public void CopyFile(string sourcePath, string destPath, bool overwrite)
    {
        File.Copy(sourcePath, destPath, overwrite);
    }

    public void MoveFile(string sourcePath, string destPath)
    {
        File.Move(sourcePath, destPath);
    }

    public bool DirectoryExists(string path)
    {
        return Directory.Exists(path);
    }

    public bool FileExists(string path)
    {
        return File.Exists(path);
    }
}

然后把FileExplorer的构造函数和内部文件操作逻辑改成调用这个接口，替换掉直接的File/Directory调用。

现在所有依赖都可以Mock了，用xUnit + Moq（或者你熟悉的测试框架）就能写精准的测试用例：

场景1：剪贴板为空，DoCtrlV不执行任何操作 #

[Fact]
public void DoCtrlV_WhenClipboardIsEmpty_DoesNothing()
{
    // Arrange
    var mockClipboard = new Mock<IClipboardService>();
    // 模拟空剪贴板
    mockClipboard.Setup(c => c.GetFileDropList()).Returns(new StringCollection());
    var mockFileSystem = new Mock<IFileSystemService>();
    var explorer = new FileExplorer(mockClipboard.Object, mockFileSystem.Object);

    // Act
    explorer.DoCtrlV(@"C:\target\"); // 假设obj是目标路径

    // Assert
    // 验证文件系统的复制/移动方法完全没被调用
    mockFileSystem.Verify(f => f.CopyFile(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<bool>()), Times.Never);
    mockFileSystem.Verify(f => f.MoveFile(It.IsAny<string>(), It.IsAny<string>()), Times.Never);
}

场景2：剪贴板有有效文件，执行复制操作 #

[Fact]
public void DoCtrlV_WhenClipboardHasValidFiles_CallsCopyFile()
{
    // Arrange
    var testFiles = new StringCollection { @"C:\source\file1.txt", @"C:\source\file2.jpg" };
    var mockClipboard = new Mock<IClipboardService>();
    mockClipboard.Setup(c => c.GetFileDropList()).Returns(testFiles);
    
    var mockFileSystem = new Mock<IFileSystemService>();
    // 模拟目标目录存在
    mockFileSystem.Setup(f => f.DirectoryExists(@"C:\target\")).Returns(true);
    // 模拟源文件存在
    foreach (var file in testFiles)
    {
        mockFileSystem.Setup(f => f.FileExists(file)).Returns(true);
    }
    
    var explorer = new FileExplorer(mockClipboard.Object, mockFileSystem.Object);

    // Act
    explorer.DoCtrlV(@"C:\target\");

    // Assert
    // 验证每个文件都被调用了一次复制
    foreach (var file in testFiles)
    {
        var destPath = Path.Combine(@"C:\target\", Path.GetFileName(file));
        mockFileSystem.Verify(f => f.CopyFile(file, destPath, It.IsAny<bool>()), Times.Once);
    }
}

场景3：剪贴板里的文件不存在，验证异常处理 #

[Fact]
public void DoCtrlV_WhenClipboardFileDoesNotExist_HandlesExceptionGracefully()
{
    // Arrange
    var nonExistentFile = @"C:\nonexistent\file.txt";
    var mockClipboard = new Mock<IClipboardService>();
    mockClipboard.Setup(c => c.GetFileDropList()).Returns(new StringCollection { nonExistentFile });
    
    var mockFileSystem = new Mock<IFileSystemService>();
    mockFileSystem.Setup(f => f.FileExists(nonExistentFile)).Returns(false);
    // 或者模拟调用CopyFile时抛出异常
    // mockFileSystem.Setup(f => f.CopyFile(nonExistentFile, It.IsAny<string>(), It.IsAny<bool>()))
    //               .Throws(new FileNotFoundException());
    
    var explorer = new FileExplorer(mockClipboard.Object, mockFileSystem.Object);

    // Act
    // 验证方法没有抛出未处理的异常
    var exception = Record.Exception(() => explorer.DoCtrlV(@"C:\target\"));

    // Assert
    Assert.Null(exception);
    // 如果你的方法会记录日志，可以加ILogger的Mock来验证日志是否正确输出
}

单元测试测的是逻辑正确性，集成测试可以验证真实场景下的行为，但要注意清理资源：

[Fact]
public void DoCtrlV_RealClipboardAndFiles_CopiesFilesSuccessfully()
{
    // Arrange
    // 创建临时测试目录和文件
    var tempRoot = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
    var sourceDir = Path.Combine(tempRoot, "source");
    var targetDir = Path.Combine(tempRoot, "target");
    Directory.CreateDirectory(sourceDir);
    Directory.CreateDirectory(targetDir);

    var testFile = Path.Combine(sourceDir, "test.txt");
    File.WriteAllText(testFile, "test content");

    // 设置真实剪贴板
    var fileList = new StringCollection { testFile };
    System.Windows.Clipboard.SetFileDropList(fileList);

    // 用真实的服务实例
    var explorer = new FileExplorer(new WpfClipboardService(), new RealFileSystemService());

    // Act
    explorer.DoCtrlV(targetDir);

    // Assert
    var destFile = Path.Combine(targetDir, "test.txt");
    Assert.True(File.Exists(destFile));
    Assert.Equal("test content", File.ReadAllText(destFile));

    // Cleanup：删除临时目录，清空剪贴板
    Directory.Delete(tempRoot, recursive: true);
    System.Windows.Clipboard.Clear();
}

• 如果StopWait()方法有副作用（比如操作UI），可以把它改成protected virtual，测试时用子类重写为空实现
• 用Moq的Verify方法可以精确验证方法的调用参数、次数，确保逻辑符合预期
• 对于复杂的逻辑（比如重复文件重命名），可以单独提取成私有方法，再通过反射或者拆分成公共方法来测试

内容的提问来源于stack exchange，提问作者Maverick Meerkat