正如其他人所指出的，您需要为使用的每个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，因为您只需要发布这一个引用，所以事情会变得更加简单。

“千万不要在COM对象中使用两个点”是避免COM引用泄漏的一条很好的经验法则，但Excel PIA会导致泄漏的方式比乍一看更明显。

其中一种方法是订阅任何Excel对象模型的COM对象公开的任何事件。

例如，订阅Application类的WorkbookOpen事件。

关于COM事件的一些理论

COM类通过回调接口公开一组事件。为了订阅事件，客户端代码可以简单地注册实现回调接口的对象，COM类将调用其方法以响应特定事件。由于回调接口是一个COM接口，因此实现对象的职责是减少它为任何事件处理程序接收的任何COM对象（作为参数）的引用计数。

Excel PIA如何公开COM事件

Excel PIA将Excel应用程序类的COM事件公开为常规的.NET事件。每当客户端代码订阅.NET事件（强调“a”）时，PIA都会创建实现回调接口的类的实例，并将其注册到Excel中。

因此，为了响应来自.NET代码的不同订阅请求，许多回调对象被注册到Excel中。每个事件订阅一个回调对象。

用于事件处理的回调接口意味着，PIA必须为每个.NET事件订阅请求订阅所有接口事件。它不能挑挑拣拣。在接收到事件回调时，回调对象检查关联的.NET事件处理程序是否对当前事件感兴趣，然后调用该处理程序或无提示地忽略回调。

对COM实例引用计数的影响

所有这些回调对象都不会减少它们接收的任何COM对象（作为参数）对任何回调方法的引用计数（即使是被忽略的回调方法）。它们只依赖CLR垃圾收集器来释放COM对象。

由于GC运行是非确定性的，这可能导致Excel进程延迟的时间比预期的长，并造成“内存泄漏”的印象。

解决方案

目前唯一的解决方案是避免PIA的COM类事件提供程序，并编写自己的事件提供程序来确定是否释放COM对象。

对于Application类，这可以通过实现AppEvents接口，然后使用IConnectionPointContainer接口将实现注册到Excel来完成。Application类（以及使用回调机制公开事件的所有COM对象）实现IConnectionPointContainer接口。

实际上，您可以干净地释放Excel应用程序对象，但您必须小心。

建议为您访问的每个COM对象维护一个命名引用，然后通过Marshal.FinalReleaseComObject（）显式释放它，这在理论上是正确的，但不幸的是，在实践中很难管理。如果有人在任何地方滑动并使用“两点”，或者通过for each循环或任何其他类似类型的命令来迭代单元格，那么您将拥有未引用的COM对象并面临挂起的风险。在这种情况下，将无法在代码中找到原因；您必须仔细检查所有代码，并希望找到原因，这对于一个大型项目来说几乎是不可能的。

好消息是，实际上不必维护对所使用的每个COM对象的命名变量引用。相反，先调用GC.Collect（），然后调用GC.WaitForPendingFinalizers（），释放所有未持有引用的对象（通常是次要的），然后显式释放持有命名变量引用的对象。

您还应该按照相反的重要性顺序释放命名引用：首先是范围对象，然后是工作表、工作簿，最后是Excel应用程序对象。

例如，假设您有一个名为xlRng的Range对象变量、一个名名为xlSheet的工作表变量、名为xlBook的工作簿变量和名为xlApp的Excel应用程序变量，则清理代码可能如下所示：

// Cleanup
GC.Collect();
GC.WaitForPendingFinalizers();

Marshal.FinalReleaseComObject(xlRng);
Marshal.FinalReleaseComObject(xlSheet);

xlBook.Close(Type.Missing, Type.Missing, Type.Missing);
Marshal.FinalReleaseComObject(xlBook);

xlApp.Quit();
Marshal.FinalReleaseComObject(xlApp);

在大多数从.NET清理COM对象的代码示例中，GC.Collect（）和GC.WaitForPendingFinalizers（）调用两次，如下所示：

GC.Collect();
GC.WaitForPendingFinalizers();
GC.Collect();
GC.WaitForPendingFinalizers();

但是，除非您使用的是Visual Studio Tools for Office（VSTO），该工具使用的终结器会导致整个对象图在终结队列中升级，否则这不应该是必需的。在下一次垃圾收集之前，不会释放此类对象。但是，如果您不使用VSTO，则应该能够调用GC.Collect（）和GC.WaitForPendingFinalizers（）一次。

我知道显式调用GC.Collect（）是一个不允许的做法（当然，重复两次听起来很痛苦），但老实说，没有办法解决这个问题。通过正常操作，您将生成隐藏对象，这些对象没有引用，因此，除了调用GC.Collect（）之外，您无法通过任何其他方式释放这些对象。

这是一个复杂的主题，但这确实是它的全部内容。一旦为清理过程建立了这个模板，您就可以正常编码，而不需要包装器等：-）

我在这里有一个教程：

用VB.Net／COM Interop实现Office程序的自动化

它是为VB.NET编写的，但不要因此而延迟，其原理与使用C#时完全相同。

关于释放COM对象的一篇很棒的文章是2.5释放COM对象（MSDN）。

我建议的方法是，如果Excel.Interop引用是非本地变量，则将其置空，然后调用GC.Collect（）和GC.WaitForPendingFinalizers（）两次。将自动处理本地范围的Interop变量。

这消除了为每个COM对象保留命名引用的需要。

以下是文章中的一个示例：

public class Test {

    // These instance variables must be nulled or Excel will not quit
    private Excel.Application xl;
    private Excel.Workbook book;

    public void DoSomething()
    {
        xl = new Excel.Application();
        xl.Visible = true;
        book = xl.Workbooks.Add(Type.Missing);

        // These variables are locally scoped, so we need not worry about them.
        // Notice I don't care about using two dots.
        Excel.Range rng = book.Worksheets[1].UsedRange;
    }

    public void CleanUp()
    {
        book = null;
        xl.Quit();
        xl = null;

        GC.Collect();
        GC.WaitForPendingFinalizers();
        GC.Collect();
        GC.WaitForPendingFinalizers();
    }
}

这些话直接来自文章：

在几乎所有的情况下，取消RCW引用并强制垃圾收集将正确清理。如果同时调用GC.WaitForPendingFinalizers，垃圾收集将尽可能具有确定性。也就是说，在第二次调用WaitForPending Finalizers返回时，您将非常确定对象何时被清理。作为替代方案，您可以使用Marshal.ReleaseComObject。但是，请注意，您不太可能需要使用此方法。

我找到了一个有用的通用模板，它可以帮助实现COM对象的正确处置模式，这些对象在超出范围时需要调用Marshal.ReleaseComObject：

用法：

using (AutoReleaseComObject<Application> excelApplicationWrapper = new AutoReleaseComObject<Application>(new Application()))
{
    try
    {
        using (AutoReleaseComObject<Workbook> workbookWrapper = new AutoReleaseComObject<Workbook>(excelApplicationWrapper.ComObject.Workbooks.Open(namedRangeBase.FullName, false, false, missing, missing, missing, true, missing, missing, true, missing, missing, missing, missing, missing)))
        {
           // do something with your workbook....
        }
    }
    finally
    {
         excelApplicationWrapper.ComObject.Quit();
    } 
}

模板：

public class AutoReleaseComObject<T> : IDisposable
{
    private T m_comObject;
    private bool m_armed = true;
    private bool m_disposed = false;

    public AutoReleaseComObject(T comObject)
    {
        Debug.Assert(comObject != null);
        m_comObject = comObject;
    }

#if DEBUG
    ~AutoReleaseComObject()
    {
        // We should have been disposed using Dispose().
        Debug.WriteLine("Finalize being called, should have been disposed");

        if (this.ComObject != null)
        {
            Debug.WriteLine(string.Format("ComObject was not null:{0}, name:{1}.", this.ComObject, this.ComObjectName));
        }

        //Debug.Assert(false);
    }
#endif

    public T ComObject
    {
        get
        {
            Debug.Assert(!m_disposed);
            return m_comObject;
        }
    }

    private string ComObjectName
    {
        get
        {
            if(this.ComObject is Microsoft.Office.Interop.Excel.Workbook)
            {
                return ((Microsoft.Office.Interop.Excel.Workbook)this.ComObject).Name;
            }

            return null;
        }
    }

    public void Disarm()
    {
        Debug.Assert(!m_disposed);
        m_armed = false;
    }

    #region IDisposable Members

    public void Dispose()
    {
        Dispose(true);
#if DEBUG
        GC.SuppressFinalize(this);
#endif
    }

    #endregion

    protected virtual void Dispose(bool disposing)
    {
        if (!m_disposed)
        {
            if (m_armed)
            {
                int refcnt = 0;
                do
                {
                    refcnt = System.Runtime.InteropServices.Marshal.ReleaseComObject(m_comObject);
                } while (refcnt > 0);

                m_comObject = default(T);
            }

            m_disposed = true;
        }
    }
}

参考：

http://www.deez.info/sengelha/2005/02/11/useful-idisposable-class-3-autoreleasecomobject/

这看起来确实太复杂了。根据我的经验，要让Excel正确关闭，只有三件关键的事情：

1：确保没有对您创建的excel应用程序的剩余引用（无论如何，您应该只有一个引用；将其设置为空）

2：调用GC.Collect（）

3:必须通过用户手动关闭程序或通过对Excel对象调用“退出”来关闭Excel。（请注意，“退出”的功能与用户试图关闭程序的功能相同，如果存在未保存的更改，即使Excel不可见，也会显示一个确认对话框。用户可以按“取消”，Excel将不会关闭。）

1需要在2之前发生，但3可以随时发生。

实现这一点的一种方法是用自己的类包装interop Excel对象，在构造函数中创建interop实例，并使用Dispose实现IDisposable

这将从程序的方面清理出优秀的东西。一旦Excel关闭（由用户手动或您调用退出），该过程将消失。如果程序已经关闭，那么进程将在GC.Collect（）调用中消失。

（我不确定它有多重要，但您可能需要在GC.Collect（）调用之后调用GC.WaitForPendingFinalizers（），但这并不是完全需要摆脱Excel进程。）

多年来，这对我来说毫无问题。请记住，虽然这是有效的，但实际上您必须优雅地关闭它才能工作。如果在清理excel之前中断程序（通常在调试程序时单击“停止”），则仍会累积excel.exe进程