在 .NET 中使用流比较比较 Word 文档（C#）

介绍

如果您需要在 .NET 应用程序中 compare word documents c# 并保持低内存使用，那么您来对地方了。传统的基于文件的比较会将整个文档加载到 RAM 中，这在处理大型 Word 文件或仅有流的云原生场景时会迅速成为瓶颈。本教程将逐步演示如何使用 GroupDocs.Comparison 执行基于流的文档比较，并提供真实案例、性能技巧和故障排除建议。

快速答案

  • 哪个库处理流比较？ GroupDocs.Comparison for .NET。
  • 我可以直接从 MemoryStream 比较 Word 文件吗？ 是的 – 只需将流传递给比较器。
  • 生产环境需要许可证吗？ 绝对需要；有效的 GroupDocs.Comparison 许可证会去除水印。
  • 支持哪些 .NET 版本？ .NET Framework 4.6.1+、.NET Core 2.0+、.NET 5/6/7。
  • 是否内置异步支持？ 本身不支持，但可以将调用包装在 Task.Run 中实现基本的异步行为。

什么是基于流的文档比较？

Comparer 类在 GroupDocs.Comparison 中可以从任何 Stream 实现读取文档数据，实现无需将文件写入磁盘的比较。这使其非常适合云存储、大文件处理和高并发 Web 服务。

为什么使用基于流的比较来比较 Word 文档（C#）？

基于流的比较通过分块处理数据而不是一次性加载整个文件，降低了内存压力。GroupDocs.Comparison 支持 50+ 输入和输出格式——包括 DOCX、PDF、PPTX 和 XLSX，并且能够处理数百页的文档而不会耗尽服务器 RAM。该方法还与 Azure Blob、AWS S3 或任何基于 HTTP 的存储完美匹配，在这些场景中您收到的是 Stream 而不是物理文件路径。

前提条件

  • GroupDocs.Comparison for .NET（版本 25.4.0 或更高）– 支持 50+ 格式。
  • .NET Framework 4.6.1+ 或 .NET Core 2.0+（包括 .NET 5/6/7）。
  • 支持 C# 的 IDE（Visual Studio、VS Code 或 Rider）。
  • 具备 C# 流（FileStream、MemoryStream）和 using 语句的基础知识。

设置 GroupDocs.Comparison for .NET

安装步骤

使用 NuGet 包管理器控制台

Install-Package GroupDocs.Comparison -Version 25.4.0

Install-Package GroupDocs.Comparison -Version 25.4.0

使用 .NET CLI

dotnet add package GroupDocs.Comparison --version 25.4.0

dotnet add package GroupDocs.Comparison --version 25.4.0

技巧提示： 固定版本号以避免在出现新主版本时出现意外的破坏性更改。

许可证设置（重要！）

GroupDocs.Comparison 在生产环境中需要许可证。您可以先使用免费试用，获取临时许可证用于概念验证，或购买完整许可证以实现无限部署。详情请访问 GroupDocs 购买。

基本许可证初始化

var license = new GroupDocs.Comparison.License();
license.SetLicense("GroupDocs.Comparison.lic");

using GroupDocs.Comparison;
using System.IO;

// This is your foundation for all comparisons
Comparer comparer = new Comparer();

现在，您已准备好从任何流来源比较文档。

如何使用流比较 Word 文档（C#）？

将源和目标 Word 文件加载为流，传递给 Comparer，并将结果写入输出流。完整流程如下图所示。

步骤 1：准备源、目标和输出流

using (var sourceStream = File.OpenRead("Original.docx"))
using (var targetStream = File.OpenRead("Revised.docx"))
using (var resultStream = File.Create("ComparisonResult.docx"))
{
    // Comparison logic goes here
}

string sourceDocumentPath = Path.Combine("YOUR_DOCUMENT_DIRECTORY", "source.docx");
string targetDocumentPath = Path.Combine("YOUR_DOCUMENT_DIRECTORY", "target.docx");
string outputDirectory = Path.Combine("YOUR_OUTPUT_DIRECTORY", ".");
string outputFileName = Path.Combine(outputDirectory, "comparison_result.docx");

using (Comparer comparer = new Comparer(File.OpenRead(sourceDocumentPath)))
{
    // Step 2: Add the Target Document
    comparer.Add(File.OpenRead(targetDocumentPath));

    // Step 3: Perform Comparison and Save Results
    comparer.Compare(File.Create(outputFileName));
}

说明：

  • File.OpenRead 为两个 Word 文件创建只读流。
  • File.Create 打开只写流，用于保存比较结果。
  • using 语句确保在代码块结束时立即释放每个流，防止文件锁定和内存泄漏。

步骤 2：使用源流初始化 Comparer

var comparer = new GroupDocs.Comparison.Comparer(sourceStream);

// Example: Comparing documents from byte arrays
byte[] sourceBytes = GetDocumentFromDatabase(sourceId);
byte[] targetBytes = GetDocumentFromDatabase(targetId);

using (var sourceStream = new MemoryStream(sourceBytes))
using (var targetStream = new MemoryStream(targetBytes))
using (var outputStream = new MemoryStream())
using (var comparer = new Comparer(sourceStream))
{
    comparer.Add(targetStream);
    comparer.Compare(outputStream);
    
    // Now you can work with the result in memory
    byte[] resultBytes = outputStream.ToArray();
}

定义锚点： Comparer 类是 GroupDocs.Comparison 的核心组件，负责在两个或多个文档流之间进行加载、分析和生成差异。

步骤 3：添加目标流

comparer.Add(targetStream);

// If you must reuse a stream, reset its position
stream.Position = 0;

您可以多次调用 Add，在一次运行中将源与多个目标版本进行比较。

步骤 4：执行比较并写入结果

ComparisonResult 表示比较的结果，包含差异文档及相关元数据。

var result = comparer.Compare();
result.Save(resultStream);

// Good - automatic disposal
using (var stream = File.OpenRead(path))
{
    // Use stream
}

// Also good - manual disposal
var stream = File.OpenRead(path);
try
{
    // Use stream
}
finally
{
    stream?.Dispose();
}

这里发生了什么？

  • Compare() 处理两个流，检测插入、删除和格式更改，并返回一个 ComparisonResult 对象。
  • Save() 将带有高亮的比较文档写入您之前创建的 resultStream。

高级流处理

使用 MemoryStream（例如，通过 HTTP 上传的文件）

当您的应用接收到文件上传时，通常会得到一个 MemoryStream。相同的 API 可以直接使用，无需修改：

var uploadedSource = new MemoryStream(await httpRequest.Form.Files[0].OpenReadStream().ReadAllBytesAsync());
var uploadedTarget = new MemoryStream(await httpRequest.Form.Files[1].OpenReadStream().ReadAllBytesAsync());

var comparer = new GroupDocs.Comparison.Comparer(uploadedSource);
comparer.Add(uploadedTarget);
var result = comparer.Compare();

await result.SaveAsync(response.Body);

if (stream.CanSeek)
{
    // Safe to use Position and Length properties
}

为什么重要： 使用 MemoryStream 消除了对磁盘临时文件的需求，从而提升了无状态 Web 服务和容器化环境的性能。

常见陷阱及解决方案

陷阱 #1：流位置未重置

问题： 如果流之前已被读取（例如用于验证），其位置可能在末尾，导致比较器读取到零字节。
解决方案： 在传递流之前重置位置：

sourceStream.Position = 0;
targetStream.Position = 0;

// Example of async file reading (though GroupDocs.Comparison doesn't support async yet)
var sourceBytes = await File.ReadAllBytesAsync(sourcePath);
using (var sourceStream = new MemoryStream(sourceBytes))
{
    // Comparison logic
}

陷阱 #2：忘记释放流

问题： 未释放的流会保持文件句柄打开，导致“文件被占用”错误。
解决方案： 始终使用 using 块包装流，或显式调用 Dispose()，如核心实现所示。

陷阱 #3：使用不可定位的流

问题： 某些网络流（例如 NetworkStream）不支持定位，而比较器可能需要定位功能。
解决方案： 首先将不可定位的流复制到 MemoryStream 中：

var seekableStream = new MemoryStream();
await nonSeekableStream.CopyToAsync(seekableStream);
seekableStream.Position = 0;

[HttpPost]
public async Task<IActionResult> CompareDocuments(IFormFile sourceFile, IFormFile targetFile)
{
    using (var sourceStream = sourceFile.OpenReadStream())
    using (var targetStream = targetFile.OpenReadStream())
    using (var outputStream = new MemoryStream())
    using (var comparer = new Comparer(sourceStream))
    {
        comparer.Add(targetStream);
        comparer.Compare(outputStream);
        
        return File(outputStream.ToArray(), "application/vnd.openxmlformats-officedocument.wordprocessingml.document", "comparison.docx");
    }
}

性能最佳实践

优化内存使用

  • 缓冲区大小调优： 对于大于 50 MB 的文档，将内部缓冲区大小提升至 1 MB，以减少读写循环。
  • 异步 I/O： 在 ASP.NET Core 中，使用异步文件 API（FileStream.OpenReadAsync）以在 I/O 期间释放线程。

监控资源消耗

  • 性能计数器： 在比较前后跟踪 Process.PrivateMemorySize64，以验证内存影响。
  • 基准测试： 运行 dotnet benchmark 测试，比较基于文件与基于流的方法；在 200 页 DOCX 文件上，基于流的运行通常快 20‑30 %。

并发控制

  • 队列系统： 将同时进行的比较数量限制为 CPU 核心数，以避免内存耗尽崩溃。
  • 提前释放： 在 Compare() 返回后立即释放源和目标流；结果流可以保持打开状态，直到写入客户端。

实际使用案例

用例 1：Web 应用文档审阅

一个 SaaS 平台允许用户上传合同的两个版本进行并排审阅。上传的文件以 IFormFile 对象形式到达，随后转换为 MemoryStream 并即时比较，返回带有修订痕迹的可下载 DOCX。

用例 2：来自云存储的批处理

Azure Function 在容器中新 Blob 触发时运行，将每个 Blob 读取为流，与存储在另一个容器中的基线版本进行比较，并将比较结果写回到 “results” 容器。

用例 3：版本控制集成

DevOps 流水线从 Git 仓库提取 Word 文件，将其流式传入 GroupDocs.Comparison，并生成差异报告，随后将报告附加到构建产物供审计员使用。

故障排除指南

IssueLikely CauseFix
“Stream does not support reading”传入了只写流（例如 File.OpenWrite）使用 File.OpenRead 或确保 CanRead 为 true。
“Object reference not set to an instance of an object”流为 null 或在比较前已被释放验证流的初始化，并在 Compare() 之后保持 using 块打开。
Poor performance on 100 MB+ files默认缓冲区大小太小，或并发任务过多增大缓冲区大小，限制并发，并使用 dotMemory 进行分析。
Licensing errors in production许可证文件缺失或路径不正确将 GroupDocs.Comparison.lic 放置在应用根目录，并在启动时尽早调用 SetLicense。
Corrupted stream data从云存储下载时网络中断在比较前验证流长度和校验和。

高级配置选项

var options = new CompareOptions
{
    HighlightColor = Color.Yellow,
    ShowDeletedContent = true,
    ShowInsertedContent = true,
    StyleChangeDetection = true,
    Password = "optionalPassword"
};
var comparer = new GroupDocs.Comparison.Comparer(sourceStream, options);

public async Task<byte[]> CompareCloudDocuments(string sourceUrl, string targetUrl)
{
    using (var httpClient = new HttpClient())
    using (var sourceStream = await httpClient.GetStreamAsync(sourceUrl))
    using (var targetStream = await httpClient.GetStreamAsync(targetUrl))
    using (var outputStream = new MemoryStream())
    using (var comparer = new Comparer(sourceStream))
    {
        comparer.Add(targetStream);
        comparer.Compare(outputStream);
        return outputStream.ToArray();
    }
}

定义锚点： CompareOptions 是一个配置对象，允许您控制视觉样式、密码保护以及报告的更改类型。

与流行 .NET 框架的集成

ASP.NET Core 集成

public async Task<IActionResult> Compare(IFormFile source, IFormFile target)
{
    using var sourceStream = new MemoryStream();
    using var targetStream = new MemoryStream();
    await source.CopyToAsync(sourceStream);
    await target.CopyToAsync(targetStream);
    sourceStream.Position = 0;
    targetStream.Position = 0;

    var comparer = new GroupDocs.Comparison.Comparer(sourceStream);
    comparer.Add(targetStream);
    var result = comparer.Compare();

    var output = new MemoryStream();
    result.Save(output);
    output.Position = 0;
    return File(output, "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
                "ComparisonResult.docx");
}

public DocumentComparisonResult CompareDocumentVersions(int documentId, int version1, int version2)
{
    var doc1Stream = GetDocumentVersionStream(documentId, version1);
    var doc2Stream = GetDocumentVersionStream(documentId, version2);
    
    using (doc1Stream)
    using (doc2Stream)
    using (var outputStream = new MemoryStream())
    using (var comparer = new Comparer(doc1Stream))
    {
        comparer.Add(doc2Stream);
        comparer.Compare(outputStream);
        
        return new DocumentComparisonResult
        {
            ComparisonData = outputStream.ToArray(),
            ComparedAt = DateTime.UtcNow,
            SourceVersion = version1,
            TargetVersion = version2
        };
    }
}

Windows Forms / WPF 集成

var openFileDialog = new OpenFileDialog { Filter = "Word files (*.docx)|*.docx" };
if (openFileDialog.ShowDialog() == DialogResult.OK)
{
    using var source = File.OpenRead(openFileDialog.FileName);
    // Repeat for target, then compare as shown earlier
}

using (var comparer = new Comparer(sourceStream))
{
    comparer.Add(targetStream);
    
    var compareOptions = new CompareOptions
    {
        ShowDeletedContent = true,
        ShowInsertedContent = true,
        GenerateSummaryPage = true
    };
    
    comparer.Compare(outputStream, compareOptions);
}

结论

在 .NET 中基于流的文档比较为您提供了一种 内存高效、云就绪、高性能 的 Word 文件比较方式。通过利用 GroupDocs.Comparison 的 Comparer 类，您可以直接使用 Stream 对象，避免临时文件，并实现数千个并发比较的可扩展性。遵循上述最佳实践——正确的流释放、缓冲区调优和许可证管理——以确保生产实现的稳健性。

资源

最后更新： 2026-05-31
测试环境： GroupDocs.Comparison 25.4.0 for .NET
作者： GroupDocs

public class DocumentComparisonService
{
    public async Task<ComparisonResult> CompareDocumentsAsync(Stream source, Stream target)
    {
        // Your comparison logic here
        // This is where the earlier examples would fit
    }
}

private void CompareButton_Click(object sender, EventArgs e)
{
    using (var openFileDialog = new OpenFileDialog())
    {
        if (openFileDialog.ShowDialog() == DialogResult.OK)
        {
            using (var stream = File.OpenRead(openFileDialog.FileName))
            {
                // Perform comparison
            }
        }
    }
}

相关教程