我真的很喜欢事情自己清理的时候......所以我做了一些包装类来为我做所有的清理工作!这些记录在下面。
最终代码非常易读且易于访问。我还没有发现Close()
在工作簿和Quit()
应用程序之后运行的任何 Excel 幻象实例(除了我调试和关闭应用程序中间进程的地方)。
function void OpenCopyClose() {
var excel = new ExcelApplication();
var workbook1 = excel.OpenWorkbook("C:\Temp\file1.xslx", readOnly: true);
var readOnlysheet = workbook1.Worksheet("sheet1");
var workbook2 = excel.OpenWorkbook("C:\Temp\file2.xslx");
var writeSheet = workbook.Worksheet("sheet1");
// do all the excel manipulation
// read from the first workbook, write to the second workbook.
var a1 = workbook1.Cells[1, 1];
workbook2.Cells[1, 1] = a1
// explicit clean-up
workbook1.Close(false);
workbook2 .Close(true);
excel.Quit();
}
注意:您可以跳过Close()
andQuit()
调用,但如果您正在写入 Excel 文档,您至少需要Save()
. 当对象超出范围(方法返回)时,类终结器将自动启动并进行任何清理。只要您注意变量的范围,工作表 COM 对象对 COM 对象的任何引用都将被自动管理和清理,例如,仅在存储对 COM 对象的引用时才将变量保持在当前范围内。如果需要,您可以轻松地将所需的值复制到 POCO,或者创建其他包装类,如下所述。
为了管理这一切,我创建了一个类,DisposableComObject
它充当任何 COM 对象的包装器。它实现了IDisposable
接口,还包含一个终结器,用于那些不喜欢using
.
该Dispose()
方法调用Marshal.ReleaseComObject(ComObject)
然后将ComObjectRef
属性设置为 null。
ComObjectRef
当私有属性为空时,对象处于已释放状态。
如果在ComObject
释放后访问该属性,ComObjectAccessedAfterDisposeException
则会引发异常。
该Dispose()
方法可以手动调用。它也被终结器调用,在using
块结束时,以及using var
在该变量的范围结束时。
Microsoft.Office.Interop.Excel
, Application
,Workbook
和中的顶级类Worksheet
有自己的包装类,其中每个都是DisposableComObject
这是代码:
/// <summary>
/// References to COM objects must be explicitly released when done.
/// Failure to do so can result in odd behavior and processes remaining running after the application has stopped.
/// This class helps to automate the process of disposing the references to COM objects.
/// </summary>
public abstract class DisposableComObject : IDisposable
{
public class ComObjectAccessedAfterDisposeException : Exception
{
public ComObjectAccessedAfterDisposeException() : base("COM object has been accessed after being disposed") { }
}
/// <summary>The actual COM object</summary>
private object ComObjectRef { get; set; }
/// <summary>The COM object to be used by subclasses</summary>
/// <exception cref="ComObjectAccessedAfterDisposeException">When the COM object has been disposed</exception>
protected object ComObject => ComObjectRef ?? throw new ComObjectAccessedAfterDisposeException();
public DisposableComObject(object comObject) => ComObjectRef = comObject;
/// <summary>
/// True, if the COM object has been disposed.
/// </summary>
protected bool IsDisposed() => ComObjectRef is null;
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this); // in case a subclass implements a finalizer
}
/// <summary>
/// This method releases the COM object and removes the reference.
/// This allows the garbage collector to clean up any remaining instance.
/// </summary>
/// <param name="disposing">Set to true</param>
protected virtual void Dispose(bool disposing)
{
if (!disposing || IsDisposed()) return;
Marshal.ReleaseComObject(ComObject);
ComObjectRef = null;
}
~DisposableComObject()
{
Dispose(true);
}
}
还有一个方便的通用子类,它使使用稍微容易一些。
public abstract class DisposableComObject<T> : DisposableComObject
{
protected new T ComObject => (T)base.ComObject;
public DisposableComObject(T comObject) : base(comObject) { }
}
最后,我们可以使用DisposableComObject<T>
为 Excel 互操作类创建包装类。
该ExcelApplication
子类引用了一个新的 Excel 应用程序实例并用于打开工作簿。
OpenWorkbook()
返回一个ExcelWorkbook
也是 DisposableComObject 的子类。
Dispose()
已被覆盖以在调用基本Dispose()
方法之前退出 Excel 应用程序。 Quit()
是 的别名Dispose()
。
public class ExcelApplication : DisposableComObject<Application>
{
public class OpenWorkbookActionCancelledException : Exception
{
public string Filename { get; }
public OpenWorkbookActionCancelledException(string filename, COMException ex) : base($"The workbook open action was cancelled. {ex.Message}", ex) => Filename = filename;
}
/// <summary>The actual Application from Interop.Excel</summary>
Application App => ComObject;
public ExcelApplication() : base(new Application()) { }
/// <summary>Open a workbook.</summary>
public ExcelWorkbook OpenWorkbook(string filename, bool readOnly = false, string password = null, string writeResPassword = null)
{
try
{
var workbook = App.Workbooks.Open(Filename: filename, UpdateLinks: (XlUpdateLinks)0, ReadOnly: readOnly, Password: password, WriteResPassword: writeResPassword, );
return new ExcelWorkbook(workbook);
}
catch (COMException ex)
{
// If the workbook is already open and the request mode is not read-only, the user will be presented
// with a prompt from the Excel application asking if the workbook should be opened in read-only mode.
// This exception is raised when when the user clicks the Cancel button in that prompt.
throw new OpenWorkbookActionCancelledException(filename, ex);
}
}
/// <summary>Quit the running application.</summary>
public void Quit() => Dispose(true);
/// <inheritdoc/>
protected override void Dispose(bool disposing)
{
if (!disposing || IsDisposed()) return;
App.Quit();
base.Dispose(disposing);
}
}
ExcelWorkbook
也是子类DisposableComObject<Workbook>
并用于打开工作表。
Worksheet()
方法返回,你猜对ExcelWorksheet
了,它也是DisposableComObject<Workbook>
.
该Dispose()
方法被覆盖,并在调用 base 之前先关闭工作表Dispose()
。
注意:我添加了一些用于迭代的扩展方法Workbook.Worksheets
。如果你得到编译错误,这就是原因。最后添加扩展方法。
public class ExcelWorkbook : DisposableComObject<Workbook>
{
public class WorksheetNotFoundException : Exception
{
public WorksheetNotFoundException(string message) : base(message) { }
}
/// <summary>The actual Workbook from Interop.Excel</summary>
Workbook Workbook => ComObject;
/// <summary>The worksheets within the workbook</summary>
public IEnumerable<ExcelWorksheet> Worksheets => worksheets ?? (worksheets = Workbook.Worksheets.AsEnumerable<Worksheet>().Select(w => new ExcelWorksheet(w)).ToList());
private IEnumerable<ExcelWorksheet> worksheets;
public ExcelWorkbook(Workbook workbook) : base(workbook) { }
/// <summary>
/// Get the worksheet matching the <paramref name="sheetName"/>
/// </summary>
/// <param name="sheetName">The name of the Worksheet</param>
public ExcelWorksheet Worksheet(string sheetName) => Worksheet(s => s.Name == sheetName, () => $"Worksheet not found: {sheetName}");
/// <summary>
/// Get the worksheet matching the <paramref name="predicate"/>
/// </summary>
/// <param name="predicate">A function to test each Worksheet for a macth</param>
public ExcelWorksheet Worksheet(Func<ExcelWorksheet, bool> predicate, Func<string> errorMessageAction) => Worksheets.FirstOrDefault(predicate) ?? throw new WorksheetNotFoundException(errorMessageAction.Invoke());
/// <summary>
/// Returns true of the workbook is read-only
/// </summary>
public bool IsReadOnly() => Workbook.ReadOnly;
/// <summary>
/// Save changes made to the workbook
/// </summary>
public void Save()
{
Workbook.Save();
}
/// <summary>
/// Close the workbook and optionally save changes
/// </summary>
/// <param name="saveChanges">True is save before close</param>
public void Close(bool saveChanges)
{
if (saveChanges) Save();
Dispose(true);
}
/// <inheritdoc/>
protected override void Dispose(bool disposing)
{
if (!disposing || IsDisposed()) return;
Workbook.Close();
base.Dispose(disposing);
}
}
最后,ExcelWorksheet
.
UsedRows()
简单地返回一个可枚举的未包装Microsoft.Office.Interop.Excel.Range
对象。我还没有遇到过从对象的属性访问的 COMMicrosoft.Office.Interop.Excel.Worksheet
对象需要手动包装的情况,就像使用Application
、Workbook
和Worksheet
. 这些似乎都可以自动清理它们。大多数情况下,我只是迭代 Ranges 并获取或设置值,因此我的特定用例不如可用功能先进。
在这种情况下没有覆盖,Dispose()
因为不需要对工作表执行特殊操作。
public class ExcelWorksheet : DisposableComObject<Worksheet>
{
/// <summary>The actual Worksheet from Interop.Excel</summary>
Worksheet Worksheet => ComObject;
/// <summary>The worksheet name</summary>
public string Name => Worksheet.Name;
// <summary>The worksheets cells (Unwrapped COM object)</summary>
public Range Cells => Worksheet.Cells;
public ExcelWorksheet(Worksheet worksheet) : base(worksheet) { }
/// <inheritdoc cref="WorksheetExtensions.UsedRows(Worksheet)"/>
public IEnumerable<Range> UsedRows() => Worksheet.UsedRows().ToList();
}
可以添加更多的包装类。只需ExcelWorksheet
根据需要添加其他方法并在包装类中返回 COM 对象。只需复制我们在通过ExcelApplication.OpenWorkbook()
和包装工作簿时所做的事情ExcelWorkbook.WorkSheets
。
一些有用的扩展方法:
public static class EnumeratorExtensions
{
/// <summary>
/// Converts the <paramref name="enumerator"/> to an IEnumerable of type <typeparamref name="T"/>
/// </summary>
public static IEnumerable<T> AsEnumerable<T>(this IEnumerable enumerator)
{
return enumerator.GetEnumerator().AsEnumerable<T>();
}
/// <summary>
/// Converts the <paramref name="enumerator"/> to an IEnumerable of type <typeparamref name="T"/>
/// </summary>
public static IEnumerable<T> AsEnumerable<T>(this IEnumerator enumerator)
{
while (enumerator.MoveNext()) yield return (T)enumerator.Current;
}
/// <summary>
/// Converts the <paramref name="enumerator"/> to an IEnumerable of type <typeparamref name="T"/>
/// </summary>
public static IEnumerable<T> AsEnumerable<T>(this IEnumerator<T> enumerator)
{
while (enumerator.MoveNext()) yield return enumerator.Current;
}
}
public static class WorksheetExtensions
{
/// <summary>
/// Returns the rows within the used range of this <paramref name="worksheet"/>
/// </summary>
/// <param name="worksheet">The worksheet</param>
public static IEnumerable<Range> UsedRows(this Worksheet worksheet) =>
worksheet.UsedRange.Rows.AsEnumerable<Range>();
}