我在C#（ApplicationClass）中使用Excel互操作，并在finally子句中放置了以下代码：
while (System.Runtime.InteropServices.Marshal.ReleaseComObject(excelSheet) != 0) { }
excelSheet = null;
GC.Collect();
GC.WaitForPendingFinalizers();
尽管这种方法有效，但即使在我关闭Excel之后，Excel.exe进程仍处于后台。它只在我的应用程序被手动关闭后发布。
我做错了什么，或者是否有其他方法可以确保正确处理互操作对象？
当前回答
我目前正在研究Office自动化，并偶然发现了一个每次都适用于我的解决方案。它很简单，不涉及杀死任何进程。
似乎只要在当前的活动进程中循环，并以任何方式“访问”一个开放的Excel进程，Excel的任何游离挂起实例都将被删除。下面的代码只是检查名称为“Excel”的进程，然后将进程的MainWindowTitle属性写入字符串。与进程的这种“交互”似乎使Windows赶上并中止了冻结的Excel实例。
我在开发退出的加载项之前运行下面的方法，因为它会触发卸载事件。它每次都会删除所有挂起的Excel实例。老实说，我不完全确定为什么这样做，但它对我来说很好，可以放在任何Excel应用程序的末尾，而不必担心双点、Marshal.ReleaseComObject或杀死进程。我很想知道为什么这是有效的。
public static void SweepExcelProcesses()
{
if (Process.GetProcessesByName("EXCEL").Length != 0)
{
Process[] processes = Process.GetProcesses();
foreach (Process process in processes)
{
if (process.ProcessName.ToString() == "excel")
{
string title = process.MainWindowTitle;
}
}
}
}
其他回答
到目前为止，似乎所有的答案都涉及其中一些：
终止进程使用GC.Collect（）跟踪每个COM对象并正确释放它。
这让我意识到这个问题有多么困难：）
我一直在开发一个库来简化对Excel的访问，我正在努力确保使用它的人不会留下一片混乱（手指交叉）。
我没有直接在Interop提供的接口上进行编写，而是使用扩展方法来简化工作。类似于ApplicationHelpers.CreateExcel（）或工作簿.CreateWorksheet（“mySheetNameThatWillBeValidated”）。自然，任何创建的东西都可能会在以后的清理中导致问题，所以我实际上更倾向于在最后的手段中终止这个过程。然而，正确清理（第三种选择）可能是破坏性最小、控制性最强的。
因此，在这种情况下，我想知道这样做是否不是最好的：
public abstract class ReleaseContainer<T>
{
private readonly Action<T> actionOnT;
protected ReleaseContainer(T releasible, Action<T> actionOnT)
{
this.actionOnT = actionOnT;
this.Releasible = releasible;
}
~ReleaseContainer()
{
Release();
}
public T Releasible { get; private set; }
private void Release()
{
actionOnT(Releasible);
Releasible = default(T);
}
}
我用“不可行”来避免与一次性使用混淆。但将其扩展到IDisposable应该很容易。
这样的实现：
public class ApplicationContainer : ReleaseContainer<Application>
{
public ApplicationContainer()
: base(new Application(), ActionOnExcel)
{
}
private static void ActionOnExcel(Application application)
{
application.Show(); // extension method. want to make sure the app is visible.
application.Quit();
Marshal.FinalReleaseComObject(application);
}
}
可以对所有类型的COM对象执行类似的操作。
在工厂方法中：
public static Application CreateExcelApplication(bool hidden = false)
{
var excel = new ApplicationContainer().Releasible;
excel.Visible = !hidden;
return excel;
}
我希望每个容器都会被GC正确地销毁，因此会自动调用Quit和Marshal.FinalReleaseComObject。
评论？或者这是对第三类问题的回答？
尝试之后
按相反顺序释放COM对象在末尾添加两次GC.Collect（）和GC.WaitForPendingFinalizers（）不超过两个点关闭工作簿并退出应用程序以释放模式运行
对我有效的最终解决方案是移动一组
GC.Collect();
GC.WaitForPendingFinalizers();
我们将其添加到包装器的函数末尾，如下所示：
private void FunctionWrapper(string sourcePath, string targetPath)
{
try
{
FunctionThatCallsExcel(sourcePath, targetPath);
}
finally
{
GC.Collect();
GC.WaitForPendingFinalizers();
}
}
更新：添加了C#代码，并链接到Windows作业
我花了一些时间试图解决这个问题，当时XtremeVBTalk是最活跃和响应最快的。这里有一个链接到我的原始文章，“即使应用程序崩溃，也要干净地关闭Excel互操作过程”。下面是文章的摘要，以及复制到本文的代码。
使用Application.Quit（）和process.Kill（）关闭Interop进程在很大程度上是有效的，但如果应用程序发生灾难性崩溃，则会失败。也就是说，如果应用程序崩溃，Excel进程仍将运行松散。解决方案是让操作系统使用Win32调用通过Windows作业对象处理进程的清理。当主应用程序失效时，相关的进程（即Excel）也将终止。
我发现这是一个干净的解决方案，因为操作系统正在进行真正的清理工作。您所要做的就是注册Excel进程。
Windows作业代码
包装Win32 API调用以注册互操作进程。
public enum JobObjectInfoType
{
AssociateCompletionPortInformation = 7,
BasicLimitInformation = 2,
BasicUIRestrictions = 4,
EndOfJobTimeInformation = 6,
ExtendedLimitInformation = 9,
SecurityLimitInformation = 5,
GroupInformation = 11
}
[StructLayout(LayoutKind.Sequential)]
public struct SECURITY_ATTRIBUTES
{
public int nLength;
public IntPtr lpSecurityDescriptor;
public int bInheritHandle;
}
[StructLayout(LayoutKind.Sequential)]
struct JOBOBJECT_BASIC_LIMIT_INFORMATION
{
public Int64 PerProcessUserTimeLimit;
public Int64 PerJobUserTimeLimit;
public Int16 LimitFlags;
public UInt32 MinimumWorkingSetSize;
public UInt32 MaximumWorkingSetSize;
public Int16 ActiveProcessLimit;
public Int64 Affinity;
public Int16 PriorityClass;
public Int16 SchedulingClass;
}
[StructLayout(LayoutKind.Sequential)]
struct IO_COUNTERS
{
public UInt64 ReadOperationCount;
public UInt64 WriteOperationCount;
public UInt64 OtherOperationCount;
public UInt64 ReadTransferCount;
public UInt64 WriteTransferCount;
public UInt64 OtherTransferCount;
}
[StructLayout(LayoutKind.Sequential)]
struct JOBOBJECT_EXTENDED_LIMIT_INFORMATION
{
public JOBOBJECT_BASIC_LIMIT_INFORMATION BasicLimitInformation;
public IO_COUNTERS IoInfo;
public UInt32 ProcessMemoryLimit;
public UInt32 JobMemoryLimit;
public UInt32 PeakProcessMemoryUsed;
public UInt32 PeakJobMemoryUsed;
}
public class Job : IDisposable
{
[DllImport("kernel32.dll", CharSet = CharSet.Unicode)]
static extern IntPtr CreateJobObject(object a, string lpName);
[DllImport("kernel32.dll")]
static extern bool SetInformationJobObject(IntPtr hJob, JobObjectInfoType infoType, IntPtr lpJobObjectInfo, uint cbJobObjectInfoLength);
[DllImport("kernel32.dll", SetLastError = true)]
static extern bool AssignProcessToJobObject(IntPtr job, IntPtr process);
private IntPtr m_handle;
private bool m_disposed = false;
public Job()
{
m_handle = CreateJobObject(null, null);
JOBOBJECT_BASIC_LIMIT_INFORMATION info = new JOBOBJECT_BASIC_LIMIT_INFORMATION();
info.LimitFlags = 0x2000;
JOBOBJECT_EXTENDED_LIMIT_INFORMATION extendedInfo = new JOBOBJECT_EXTENDED_LIMIT_INFORMATION();
extendedInfo.BasicLimitInformation = info;
int length = Marshal.SizeOf(typeof(JOBOBJECT_EXTENDED_LIMIT_INFORMATION));
IntPtr extendedInfoPtr = Marshal.AllocHGlobal(length);
Marshal.StructureToPtr(extendedInfo, extendedInfoPtr, false);
if (!SetInformationJobObject(m_handle, JobObjectInfoType.ExtendedLimitInformation, extendedInfoPtr, (uint)length))
throw new Exception(string.Format("Unable to set information. Error: {0}", Marshal.GetLastWin32Error()));
}
#region IDisposable Members
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
#endregion
private void Dispose(bool disposing)
{
if (m_disposed)
return;
if (disposing) {}
Close();
m_disposed = true;
}
public void Close()
{
Win32.CloseHandle(m_handle);
m_handle = IntPtr.Zero;
}
public bool AddProcess(IntPtr handle)
{
return AssignProcessToJobObject(m_handle, handle);
}
}
关于构造函数代码的注释
在构造函数中，info.LimitFlags=0x2000；被调用。0x2000是JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE枚举值，MSDN将此值定义为：
当作业的最后一个句柄关闭。
获取进程ID（PID）的额外Win32 API调用
[DllImport("user32.dll", SetLastError = true)]
public static extern uint GetWindowThreadProcessId(IntPtr hWnd, out uint lpdwProcessId);
使用代码
Excel.Application app = new Excel.ApplicationClass();
Job job = new Job();
uint pid = 0;
Win32.GetWindowThreadProcessId(new IntPtr(app.Hwnd), out pid);
job.AddProcess(Process.GetProcessById((int)pid).Handle);
在其他答案中考虑的三种一般策略中，杀死excel进程显然是一种黑客行为，而调用垃圾收集器是一种野蛮的猎枪方法，旨在补偿COM对象的错误释放。经过大量的实验，并在我的版本不可知和后期绑定包装器中重写COM对象的管理，我得出结论，准确和及时地调用Marshal.ReleaseComObject（）是最有效和优雅的策略。不，您永远不需要FinalReleaseComObject（），因为在一个编写良好的程序中，每个COM只获取一次，因此需要减少一次引用计数器。
应确保释放每个COM对象，最好是在不再需要时释放。但是，在退出Excel应用程序后立即释放所有内容是完全可能的，唯一的代价是更高的内存使用率。只要不松开或忘记释放COM对象，Excel将按预期关闭。
该过程中最简单、最明显的帮助是将每个互操作对象包装到实现IDisposable的.NET类中，其中Dispose（）方法在其互操作对象上调用ReleaseComObject（）。在析构函数中这样做，正如这里所建议的，没有意义，因为析构函数是非确定性的。
下面显示的是我们的包装器方法，它绕过中间Cells成员从WorkSheet中获取单元格。请注意使用后它处理中间对象的方式：
public ExcelRange XCell( int row, int col)
{ ExcelRange anchor, res;
using( anchor = Range( "A1") )
{ res = anchor.Offset( row - 1, col - 1 ); }
return res;
}
下一步可能是一个简单的内存管理器，它将跟踪获得的每个COM对象，并确保在Excel退出后释放它，如果用户希望用一些RAM来换取更简单的代码。
进一步阅读
如何正确释放Excel COM对象，释放COM对象：垃圾收集器与Marshal.RelseaseComObject。
正如其他人所指出的，您需要为使用的每个Excel对象创建一个显式引用，并对该引用调用Marshal.ReleaseComObject，如本知识库文章所述。您还需要使用try/finally来确保始终调用ReleaseComObject，即使抛出异常也是如此。即，代替：
Worksheet sheet = excelApp.Worksheets(1)
... do something with sheet
你需要做一些事情，比如：
Worksheets sheets = null;
Worksheet sheet = null
try
{
sheets = excelApp.Worksheets;
sheet = sheets(1);
...
}
finally
{
if (sheets != null) Marshal.ReleaseComObject(sheets);
if (sheet != null) Marshal.ReleaseComObject(sheet);
}
如果要关闭Excel，还需要在释放Application对象之前调用Application.Quit。
正如您所看到的，只要您尝试做任何稍微复杂的事情，这很快就会变得非常笨拙。我用一个简单的包装类成功地开发了.NET应用程序，该类包装了Excel对象模型的一些简单操作（打开工作簿、写入范围、保存/关闭工作簿等）。包装器类实现IDisposable，在它使用的每个对象上仔细地实现Marshal.ReleaseComObject，并且不向应用程序的其他部分公开任何Excel对象。
但这种方法不能很好地适应更复杂的需求。
这是.NETCOM互操作的一大缺陷。对于更复杂的场景，我会认真考虑用VB6或其他非托管语言编写ActiveX DLL，您可以将与进程外COM对象（如Office）的所有交互委托给它。然后，您可以从.NET应用程序中引用此ActiveX DLL，因为您只需要发布这一个引用，所以事情会变得更加简单。
