克隆 Office Open XML 文档的最有效方法是什么？
What is the most efficient way to clone Office Open XML documents?
在使用 Office 打开 XML 文档时，例如，自 Office 2007 发布以来由 Word、Excel 或 PowerPoint 创建的文档，您通常会希望克隆或复制现有的文档，然后对该克隆进行更改，从而创建一个新文档。
在此上下文中已经提出并回答了几个问题（有时是错误的或至少不是最佳的），表明用户确实面临问题。例如：
- Duplicating Word document using OpenXml and C#
- Word OpenXml Word Found Unreadable Content
- Open XML SDK: opening a Word template and saving to a different file-name
- docx document corrupted when copied though OpenXML C#
所以，问题是：
- 正确克隆或复制这些文档的可能方法有哪些？
- 哪种方式最有效？
以下示例 class 展示了多种正确复制几乎任何文件的方法，return 将副本复制到 MemoryStream 或 FileStream 上，然后您可以从中打开WordprocessingDocument (Word)、SpreadsheetDocument (Excel) 或 PresentationDocument (PowerPoint) 并使用 Open XML SDK and optionally the Open-XML-PowerTools.
进行任何更改
using System.IO;
namespace CodeSnippets.IO
{
/// <summary>
/// This class demonstrates multiple ways to clone files stored in the file system.
/// In all cases, the source file is stored in the file system. Where the return type
/// is a <see cref="MemoryStream"/>, the destination file will be stored only on that
/// <see cref="MemoryStream"/>. Where the return type is a <see cref="FileStream"/>,
/// the destination file will be stored in the file system and opened on that
/// <see cref="FileStream"/>.
/// </summary>
/// <remarks>
/// The contents of the <see cref="MemoryStream"/> instances returned by the sample
/// methods can be written to a file as follows:
///
/// var stream = ReadAllBytesToMemoryStream(sourcePath);
/// File.WriteAllBytes(destPath, stream.GetBuffer());
///
/// You can use <see cref="MemoryStream.GetBuffer"/> in cases where the MemoryStream
/// was created using <see cref="MemoryStream()"/> or <see cref="MemoryStream(int)"/>.
/// In other cases, you can use the <see cref="MemoryStream.ToArray"/> method, which
/// copies the internal buffer to a new byte array. Thus, GetBuffer() should be a tad
/// faster.
/// </remarks>
public static class FileCloner
{
public static MemoryStream ReadAllBytesToMemoryStream(string path)
{
byte[] buffer = File.ReadAllBytes(path);
var destStream = new MemoryStream(buffer.Length);
destStream.Write(buffer, 0, buffer.Length);
destStream.Seek(0, SeekOrigin.Begin);
return destStream;
}
public static MemoryStream CopyFileStreamToMemoryStream(string path)
{
using FileStream sourceStream = File.OpenRead(path);
var destStream = new MemoryStream((int) sourceStream.Length);
sourceStream.CopyTo(destStream);
destStream.Seek(0, SeekOrigin.Begin);
return destStream;
}
public static FileStream CopyFileStreamToFileStream(string sourcePath, string destPath)
{
using FileStream sourceStream = File.OpenRead(sourcePath);
FileStream destStream = File.Create(destPath);
sourceStream.CopyTo(destStream);
destStream.Seek(0, SeekOrigin.Begin);
return destStream;
}
public static FileStream CopyFileAndOpenFileStream(string sourcePath, string destPath)
{
File.Copy(sourcePath, destPath, true);
return new FileStream(destPath, FileMode.Open, FileAccess.ReadWrite, FileShare.None);
}
}
}
除了上述打开 XML 不可知的方法之外，您还可以使用以下方法，例如，如果您已经打开了 OpenXmlPackage，例如 WordprocessingDocument , SpreadsheetDocument, 或 PresentationDocument:
public void DoWorkCloningOpenXmlPackage()
{
using WordprocessingDocument sourceWordDocument = WordprocessingDocument.Open(SourcePath, false);
// There are multiple overloads of the Clone() method in the Open XML SDK.
// This one clones the source document to the given destination path and
// opens it in read-write mode.
using var wordDocument = (WordprocessingDocument) sourceWordDocument.Clone(DestPath, true);
ChangeWordprocessingDocument(wordDocument);
}
以上所有方法都能正确克隆或复制文档。但是什么是最有效的呢？
输入我们的基准测试，它使用 BenchmarkDotNet NuGet 包：
using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.IO;
using System.Linq;
using BenchmarkDotNet.Attributes;
using CodeSnippets.IO;
using CodeSnippets.OpenXml.Wordprocessing;
using DocumentFormat.OpenXml.Packaging;
using DocumentFormat.OpenXml.Wordprocessing;
namespace CodeSnippets.Benchmarks.IO
{
public class FileClonerBenchmark
{
#region Setup and Helpers
private const string SourcePath = "Source.docx";
private const string DestPath = "Destination.docx";
[Params(1, 10, 100, 1000)]
public static int ParagraphCount;
[GlobalSetup]
public void GlobalSetup()
{
CreateTestDocument(SourcePath);
CreateTestDocument(DestPath);
}
private static void CreateTestDocument(string path)
{
const string sentence = "The quick brown fox jumps over the lazy dog.";
string text = string.Join(" ", Enumerable.Range(0, 22).Select(i => sentence));
IEnumerable<string> texts = Enumerable.Range(0, ParagraphCount).Select(i => text);
using WordprocessingDocument unused = WordprocessingDocumentFactory.Create(path, texts);
}
private static void ChangeWordprocessingDocument(WordprocessingDocument wordDocument)
{
Body body = wordDocument.MainDocumentPart.Document.Body;
Text text = body.Descendants<Text>().First();
text.Text = DateTimeOffset.UtcNow.Ticks.ToString();
}
#endregion
#region Benchmarks
[Benchmark(Baseline = true)]
public void DoWorkUsingReadAllBytesToMemoryStream()
{
using MemoryStream destStream = FileCloner.ReadAllBytesToMemoryStream(SourcePath);
using (WordprocessingDocument wordDocument = WordprocessingDocument.Open(destStream, true))
{
ChangeWordprocessingDocument(wordDocument);
}
File.WriteAllBytes(DestPath, destStream.GetBuffer());
}
[Benchmark]
public void DoWorkUsingCopyFileStreamToMemoryStream()
{
using MemoryStream destStream = FileCloner.CopyFileStreamToMemoryStream(SourcePath);
using (WordprocessingDocument wordDocument = WordprocessingDocument.Open(destStream, true))
{
ChangeWordprocessingDocument(wordDocument);
}
File.WriteAllBytes(DestPath, destStream.GetBuffer());
}
[Benchmark]
public void DoWorkUsingCopyFileStreamToFileStream()
{
using FileStream destStream = FileCloner.CopyFileStreamToFileStream(SourcePath, DestPath);
using WordprocessingDocument wordDocument = WordprocessingDocument.Open(destStream, true);
ChangeWordprocessingDocument(wordDocument);
}
[Benchmark]
public void DoWorkUsingCopyFileAndOpenFileStream()
{
using FileStream destStream = FileCloner.CopyFileAndOpenFileStream(SourcePath, DestPath);
using WordprocessingDocument wordDocument = WordprocessingDocument.Open(destStream, true);
ChangeWordprocessingDocument(wordDocument);
}
[Benchmark]
public void DoWorkCloningOpenXmlPackage()
{
using WordprocessingDocument sourceWordDocument = WordprocessingDocument.Open(SourcePath, false);
using var wordDocument = (WordprocessingDocument) sourceWordDocument.Clone(DestPath, true);
ChangeWordprocessingDocument(wordDocument);
}
#endregion
}
}
以上基准为运行如下：
using BenchmarkDotNet.Running;
using CodeSnippets.Benchmarks.IO;
namespace CodeSnippets.Benchmarks
{
public static class Program
{
public static void Main()
{
BenchmarkRunner.Run<FileClonerBenchmark>();
}
}
}
我的机器上的结果是什么？哪种方法最快？
BenchmarkDotNet=v0.12.0, OS=Windows 10.0.18362
Intel Core i7-7500U CPU 2.70GHz (Kaby Lake), 1 CPU, 4 logical and 2 physical cores
.NET Core SDK=3.0.100
[Host] : .NET Core 3.0.0 (CoreCLR 4.700.19.46205, CoreFX 4.700.19.46214), X64 RyuJIT
DefaultJob : .NET Core 3.0.0 (CoreCLR 4.700.19.46205, CoreFX 4.700.19.46214), X64 RyuJIT
| Method | ParaCount | Mean | Error | StdDev | Median | Ratio |
| --------------------------------------- | --------- | --------: | --------: | --------: | --------: | ----: |
| DoWorkUsingReadAllBytesToMemoryStream | 1 | 1.548 ms | 0.0298 ms | 0.0279 ms | 1.540 ms | 1.00 |
| DoWorkUsingCopyFileStreamToMemoryStream | 1 | 1.561 ms | 0.0305 ms | 0.0271 ms | 1.556 ms | 1.01 |
| DoWorkUsingCopyFileStreamToFileStream | 1 | 2.394 ms | 0.0601 ms | 0.1100 ms | 2.354 ms | 1.55 |
| DoWorkUsingCopyFileAndOpenFileStream | 1 | 3.302 ms | 0.0657 ms | 0.0855 ms | 3.312 ms | 2.12 |
| DoWorkCloningOpenXmlPackage | 1 | 4.567 ms | 0.1218 ms | 0.3591 ms | 4.557 ms | 3.13 |
| | | | | | | |
| DoWorkUsingReadAllBytesToMemoryStream | 10 | 1.737 ms | 0.0337 ms | 0.0361 ms | 1.742 ms | 1.00 |
| DoWorkUsingCopyFileStreamToMemoryStream | 10 | 1.752 ms | 0.0347 ms | 0.0571 ms | 1.739 ms | 1.01 |
| DoWorkUsingCopyFileStreamToFileStream | 10 | 2.505 ms | 0.0390 ms | 0.0326 ms | 2.500 ms | 1.44 |
| DoWorkUsingCopyFileAndOpenFileStream | 10 | 3.532 ms | 0.0731 ms | 0.1860 ms | 3.455 ms | 2.05 |
| DoWorkCloningOpenXmlPackage | 10 | 4.446 ms | 0.0880 ms | 0.1470 ms | 4.424 ms | 2.56 |
| | | | | | | |
| DoWorkUsingReadAllBytesToMemoryStream | 100 | 2.847 ms | 0.0563 ms | 0.0553 ms | 2.857 ms | 1.00 |
| DoWorkUsingCopyFileStreamToMemoryStream | 100 | 2.865 ms | 0.0561 ms | 0.0786 ms | 2.868 ms | 1.02 |
| DoWorkUsingCopyFileStreamToFileStream | 100 | 3.550 ms | 0.0697 ms | 0.0881 ms | 3.570 ms | 1.25 |
| DoWorkUsingCopyFileAndOpenFileStream | 100 | 4.456 ms | 0.0877 ms | 0.0861 ms | 4.458 ms | 1.57 |
| DoWorkCloningOpenXmlPackage | 100 | 5.958 ms | 0.1242 ms | 0.2727 ms | 5.908 ms | 2.10 |
| | | | | | | |
| DoWorkUsingReadAllBytesToMemoryStream | 1000 | 12.378 ms | 0.2453 ms | 0.2519 ms | 12.442 ms | 1.00 |
| DoWorkUsingCopyFileStreamToMemoryStream | 1000 | 12.538 ms | 0.2070 ms | 0.1835 ms | 12.559 ms | 1.02 |
| DoWorkUsingCopyFileStreamToFileStream | 1000 | 12.919 ms | 0.2457 ms | 0.2298 ms | 12.939 ms | 1.05 |
| DoWorkUsingCopyFileAndOpenFileStream | 1000 | 13.728 ms | 0.2803 ms | 0.5196 ms | 13.652 ms | 1.11 |
| DoWorkCloningOpenXmlPackage | 1000 | 16.868 ms | 0.2174 ms | 0.1927 ms | 16.801 ms | 1.37 |
事实证明，DoWorkUsingReadAllBytesToMemoryStream() 始终是最快的方法。但是，DoWorkUsingCopyFileStreamToMemoryStream() 的余量很容易出现误差。这意味着您应尽可能在 MemoryStream 上打开您的 Open XML 文档以进行处理。如果您不必将生成的文档存储在文件系统中，这甚至比不必要地使用 FileStream.
快得多
无论在何处涉及输出 FileStream，您都会看到更大的 "significant" 差异（请注意，如果您处理大量文档，毫秒可能会有所不同）。你应该注意到使用 File.Copy() 实际上并不是一个好的方法。
最后，使用 OpenXmlPackage.Clone() 方法或其覆盖之一被证明是最慢的方法。这是因为它涉及比复制字节更复杂的逻辑。但是，如果您得到的只是对 OpenXmlPackage（或其子 class 之一的有效引用），则 Clone() 方法及其覆盖是您的最佳选择。
您可以在我的 CodeSnippets GitHub repository. Look at the CodeSnippets.Benchmark project and FileCloner class.
中找到完整的源代码
在使用 Office 打开 XML 文档时，例如，自 Office 2007 发布以来由 Word、Excel 或 PowerPoint 创建的文档，您通常会希望克隆或复制现有的文档，然后对该克隆进行更改，从而创建一个新文档。
在此上下文中已经提出并回答了几个问题（有时是错误的或至少不是最佳的），表明用户确实面临问题。例如：
- Duplicating Word document using OpenXml and C#
- Word OpenXml Word Found Unreadable Content
- Open XML SDK: opening a Word template and saving to a different file-name
- docx document corrupted when copied though OpenXML C#
所以，问题是：
- 正确克隆或复制这些文档的可能方法有哪些？
- 哪种方式最有效？
以下示例 class 展示了多种正确复制几乎任何文件的方法，return 将副本复制到 MemoryStream 或 FileStream 上，然后您可以从中打开WordprocessingDocument (Word)、SpreadsheetDocument (Excel) 或 PresentationDocument (PowerPoint) 并使用 Open XML SDK and optionally the Open-XML-PowerTools.
using System.IO;
namespace CodeSnippets.IO
{
/// <summary>
/// This class demonstrates multiple ways to clone files stored in the file system.
/// In all cases, the source file is stored in the file system. Where the return type
/// is a <see cref="MemoryStream"/>, the destination file will be stored only on that
/// <see cref="MemoryStream"/>. Where the return type is a <see cref="FileStream"/>,
/// the destination file will be stored in the file system and opened on that
/// <see cref="FileStream"/>.
/// </summary>
/// <remarks>
/// The contents of the <see cref="MemoryStream"/> instances returned by the sample
/// methods can be written to a file as follows:
///
/// var stream = ReadAllBytesToMemoryStream(sourcePath);
/// File.WriteAllBytes(destPath, stream.GetBuffer());
///
/// You can use <see cref="MemoryStream.GetBuffer"/> in cases where the MemoryStream
/// was created using <see cref="MemoryStream()"/> or <see cref="MemoryStream(int)"/>.
/// In other cases, you can use the <see cref="MemoryStream.ToArray"/> method, which
/// copies the internal buffer to a new byte array. Thus, GetBuffer() should be a tad
/// faster.
/// </remarks>
public static class FileCloner
{
public static MemoryStream ReadAllBytesToMemoryStream(string path)
{
byte[] buffer = File.ReadAllBytes(path);
var destStream = new MemoryStream(buffer.Length);
destStream.Write(buffer, 0, buffer.Length);
destStream.Seek(0, SeekOrigin.Begin);
return destStream;
}
public static MemoryStream CopyFileStreamToMemoryStream(string path)
{
using FileStream sourceStream = File.OpenRead(path);
var destStream = new MemoryStream((int) sourceStream.Length);
sourceStream.CopyTo(destStream);
destStream.Seek(0, SeekOrigin.Begin);
return destStream;
}
public static FileStream CopyFileStreamToFileStream(string sourcePath, string destPath)
{
using FileStream sourceStream = File.OpenRead(sourcePath);
FileStream destStream = File.Create(destPath);
sourceStream.CopyTo(destStream);
destStream.Seek(0, SeekOrigin.Begin);
return destStream;
}
public static FileStream CopyFileAndOpenFileStream(string sourcePath, string destPath)
{
File.Copy(sourcePath, destPath, true);
return new FileStream(destPath, FileMode.Open, FileAccess.ReadWrite, FileShare.None);
}
}
}
除了上述打开 XML 不可知的方法之外，您还可以使用以下方法，例如，如果您已经打开了 OpenXmlPackage，例如 WordprocessingDocument , SpreadsheetDocument, 或 PresentationDocument:
public void DoWorkCloningOpenXmlPackage()
{
using WordprocessingDocument sourceWordDocument = WordprocessingDocument.Open(SourcePath, false);
// There are multiple overloads of the Clone() method in the Open XML SDK.
// This one clones the source document to the given destination path and
// opens it in read-write mode.
using var wordDocument = (WordprocessingDocument) sourceWordDocument.Clone(DestPath, true);
ChangeWordprocessingDocument(wordDocument);
}
以上所有方法都能正确克隆或复制文档。但是什么是最有效的呢？
输入我们的基准测试，它使用 BenchmarkDotNet NuGet 包：
using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.IO;
using System.Linq;
using BenchmarkDotNet.Attributes;
using CodeSnippets.IO;
using CodeSnippets.OpenXml.Wordprocessing;
using DocumentFormat.OpenXml.Packaging;
using DocumentFormat.OpenXml.Wordprocessing;
namespace CodeSnippets.Benchmarks.IO
{
public class FileClonerBenchmark
{
#region Setup and Helpers
private const string SourcePath = "Source.docx";
private const string DestPath = "Destination.docx";
[Params(1, 10, 100, 1000)]
public static int ParagraphCount;
[GlobalSetup]
public void GlobalSetup()
{
CreateTestDocument(SourcePath);
CreateTestDocument(DestPath);
}
private static void CreateTestDocument(string path)
{
const string sentence = "The quick brown fox jumps over the lazy dog.";
string text = string.Join(" ", Enumerable.Range(0, 22).Select(i => sentence));
IEnumerable<string> texts = Enumerable.Range(0, ParagraphCount).Select(i => text);
using WordprocessingDocument unused = WordprocessingDocumentFactory.Create(path, texts);
}
private static void ChangeWordprocessingDocument(WordprocessingDocument wordDocument)
{
Body body = wordDocument.MainDocumentPart.Document.Body;
Text text = body.Descendants<Text>().First();
text.Text = DateTimeOffset.UtcNow.Ticks.ToString();
}
#endregion
#region Benchmarks
[Benchmark(Baseline = true)]
public void DoWorkUsingReadAllBytesToMemoryStream()
{
using MemoryStream destStream = FileCloner.ReadAllBytesToMemoryStream(SourcePath);
using (WordprocessingDocument wordDocument = WordprocessingDocument.Open(destStream, true))
{
ChangeWordprocessingDocument(wordDocument);
}
File.WriteAllBytes(DestPath, destStream.GetBuffer());
}
[Benchmark]
public void DoWorkUsingCopyFileStreamToMemoryStream()
{
using MemoryStream destStream = FileCloner.CopyFileStreamToMemoryStream(SourcePath);
using (WordprocessingDocument wordDocument = WordprocessingDocument.Open(destStream, true))
{
ChangeWordprocessingDocument(wordDocument);
}
File.WriteAllBytes(DestPath, destStream.GetBuffer());
}
[Benchmark]
public void DoWorkUsingCopyFileStreamToFileStream()
{
using FileStream destStream = FileCloner.CopyFileStreamToFileStream(SourcePath, DestPath);
using WordprocessingDocument wordDocument = WordprocessingDocument.Open(destStream, true);
ChangeWordprocessingDocument(wordDocument);
}
[Benchmark]
public void DoWorkUsingCopyFileAndOpenFileStream()
{
using FileStream destStream = FileCloner.CopyFileAndOpenFileStream(SourcePath, DestPath);
using WordprocessingDocument wordDocument = WordprocessingDocument.Open(destStream, true);
ChangeWordprocessingDocument(wordDocument);
}
[Benchmark]
public void DoWorkCloningOpenXmlPackage()
{
using WordprocessingDocument sourceWordDocument = WordprocessingDocument.Open(SourcePath, false);
using var wordDocument = (WordprocessingDocument) sourceWordDocument.Clone(DestPath, true);
ChangeWordprocessingDocument(wordDocument);
}
#endregion
}
}
以上基准为运行如下：
using BenchmarkDotNet.Running;
using CodeSnippets.Benchmarks.IO;
namespace CodeSnippets.Benchmarks
{
public static class Program
{
public static void Main()
{
BenchmarkRunner.Run<FileClonerBenchmark>();
}
}
}
我的机器上的结果是什么？哪种方法最快？
BenchmarkDotNet=v0.12.0, OS=Windows 10.0.18362
Intel Core i7-7500U CPU 2.70GHz (Kaby Lake), 1 CPU, 4 logical and 2 physical cores
.NET Core SDK=3.0.100
[Host] : .NET Core 3.0.0 (CoreCLR 4.700.19.46205, CoreFX 4.700.19.46214), X64 RyuJIT
DefaultJob : .NET Core 3.0.0 (CoreCLR 4.700.19.46205, CoreFX 4.700.19.46214), X64 RyuJIT
| Method | ParaCount | Mean | Error | StdDev | Median | Ratio |
| --------------------------------------- | --------- | --------: | --------: | --------: | --------: | ----: |
| DoWorkUsingReadAllBytesToMemoryStream | 1 | 1.548 ms | 0.0298 ms | 0.0279 ms | 1.540 ms | 1.00 |
| DoWorkUsingCopyFileStreamToMemoryStream | 1 | 1.561 ms | 0.0305 ms | 0.0271 ms | 1.556 ms | 1.01 |
| DoWorkUsingCopyFileStreamToFileStream | 1 | 2.394 ms | 0.0601 ms | 0.1100 ms | 2.354 ms | 1.55 |
| DoWorkUsingCopyFileAndOpenFileStream | 1 | 3.302 ms | 0.0657 ms | 0.0855 ms | 3.312 ms | 2.12 |
| DoWorkCloningOpenXmlPackage | 1 | 4.567 ms | 0.1218 ms | 0.3591 ms | 4.557 ms | 3.13 |
| | | | | | | |
| DoWorkUsingReadAllBytesToMemoryStream | 10 | 1.737 ms | 0.0337 ms | 0.0361 ms | 1.742 ms | 1.00 |
| DoWorkUsingCopyFileStreamToMemoryStream | 10 | 1.752 ms | 0.0347 ms | 0.0571 ms | 1.739 ms | 1.01 |
| DoWorkUsingCopyFileStreamToFileStream | 10 | 2.505 ms | 0.0390 ms | 0.0326 ms | 2.500 ms | 1.44 |
| DoWorkUsingCopyFileAndOpenFileStream | 10 | 3.532 ms | 0.0731 ms | 0.1860 ms | 3.455 ms | 2.05 |
| DoWorkCloningOpenXmlPackage | 10 | 4.446 ms | 0.0880 ms | 0.1470 ms | 4.424 ms | 2.56 |
| | | | | | | |
| DoWorkUsingReadAllBytesToMemoryStream | 100 | 2.847 ms | 0.0563 ms | 0.0553 ms | 2.857 ms | 1.00 |
| DoWorkUsingCopyFileStreamToMemoryStream | 100 | 2.865 ms | 0.0561 ms | 0.0786 ms | 2.868 ms | 1.02 |
| DoWorkUsingCopyFileStreamToFileStream | 100 | 3.550 ms | 0.0697 ms | 0.0881 ms | 3.570 ms | 1.25 |
| DoWorkUsingCopyFileAndOpenFileStream | 100 | 4.456 ms | 0.0877 ms | 0.0861 ms | 4.458 ms | 1.57 |
| DoWorkCloningOpenXmlPackage | 100 | 5.958 ms | 0.1242 ms | 0.2727 ms | 5.908 ms | 2.10 |
| | | | | | | |
| DoWorkUsingReadAllBytesToMemoryStream | 1000 | 12.378 ms | 0.2453 ms | 0.2519 ms | 12.442 ms | 1.00 |
| DoWorkUsingCopyFileStreamToMemoryStream | 1000 | 12.538 ms | 0.2070 ms | 0.1835 ms | 12.559 ms | 1.02 |
| DoWorkUsingCopyFileStreamToFileStream | 1000 | 12.919 ms | 0.2457 ms | 0.2298 ms | 12.939 ms | 1.05 |
| DoWorkUsingCopyFileAndOpenFileStream | 1000 | 13.728 ms | 0.2803 ms | 0.5196 ms | 13.652 ms | 1.11 |
| DoWorkCloningOpenXmlPackage | 1000 | 16.868 ms | 0.2174 ms | 0.1927 ms | 16.801 ms | 1.37 |
事实证明，DoWorkUsingReadAllBytesToMemoryStream() 始终是最快的方法。但是，DoWorkUsingCopyFileStreamToMemoryStream() 的余量很容易出现误差。这意味着您应尽可能在 MemoryStream 上打开您的 Open XML 文档以进行处理。如果您不必将生成的文档存储在文件系统中，这甚至比不必要地使用 FileStream.
无论在何处涉及输出 FileStream，您都会看到更大的 "significant" 差异（请注意，如果您处理大量文档，毫秒可能会有所不同）。你应该注意到使用 File.Copy() 实际上并不是一个好的方法。
最后，使用 OpenXmlPackage.Clone() 方法或其覆盖之一被证明是最慢的方法。这是因为它涉及比复制字节更复杂的逻辑。但是，如果您得到的只是对 OpenXmlPackage（或其子 class 之一的有效引用），则 Clone() 方法及其覆盖是您的最佳选择。
您可以在我的 CodeSnippets GitHub repository. Look at the CodeSnippets.Benchmark project and FileCloner class.
中找到完整的源代码