互操作进程后无法关闭 Excel.exe

我在使用 Excel 互操作时遇到问题。

即使我释放实例,Excel.exe 也不会关闭。

这是我的代码:

using xl = Microsoft.Office.Interop.Excel;

xl.Application excel = new xl.Application();
excel.Visible = true;
excel.ScreenUpdating = false;
if (wordFile.Contains(".csv") || wordFile.Contains(".xls"))
{
   //typeExcel become a string of the document name
   string typeExcel = wordFile.ToString();
   xl.Workbook workbook = excel.Workbooks.Open(typeExcel,
                                                oMissing,  oMissing,  oMissing,  oMissing,
                                                oMissing,  oMissing,  oMissing,  oMissing,
                                                oMissing,  oMissing,  oMissing,  oMissing,
                                                oMissing,  oMissing);
   object outputFileName = null;
   if (wordFile.Contains(".xls"))
   {
     outputFileName = wordFile.Replace(".xls", ".pdf");
   }
   else if (wordFile.Contains(".csv"))
   {
     outputFileName = wordFile.Replace(".csv", ".pdf");
   }

   workbook.ExportAsFixedFormat(XlFixedFormatType.xlTypePDF, outputFileName, 
                                 XlFixedFormatQuality.xlQualityStandard, oMissing,
                                 oMissing, oMissing, oMissing, oMissing, oMissing);

   object saveChanges = xl.XlSaveAction.xlDoNotSaveChanges;
   ((xl._Workbook)workbook).Close(saveChanges, oMissing, oMissing);

   Marshal.ReleaseComObject(workbook);
   workbook = null;
}

我看到了,使用 Marshal.RealeaseComObject 它应该可以工作,但没有。我怎样才能解决这个问题?

谢谢你。

stack overflow Cannot close Excel.exe after Interop process
原文答案
author avatar

接受的答案

简单规则:避免使用双点调用表达式,例如:

var workbook = excel.Workbooks.Open(/*params*/)

...因为通过这种方式,您不仅可以为 RCW 创建 workbook 对象,还可以为 Workbooks 创建对象,并且您也应该释放它(如果不维护对对象的引用,这是不可能的) .

所以,正确的方法是:

var workbooks = excel.Workbooks;
var workbook = workbooks.Open(/*params*/)

//business logic here

Marshal.ReleaseComObject(workbook);
Marshal.ReleaseComObject(workbooks);
Marshal.ReleaseComObject(excel);

答案:

作者头像

这是我写的一段代码,因为我和你有同样的问题。基本上,您需要关闭工作簿,退出应用程序,然后释放所有 COM 对象(不仅仅是 Excel 应用程序对象)。最后,调用垃圾收集器以获得更好的效果。

    /// <summary>
    /// Disposes the current <see cref="ExcelGraph" /> object and cleans up any resources.
    /// </summary>
    public void Dispose()
    {
        // Cleanup
        xWorkbook.Close(false);
        xApp.Quit();

        // Manual disposal because of COM
        while (Marshal.ReleaseComObject(xApp) != 0) { }
        while (Marshal.ReleaseComObject(xWorkbook) != 0) { }
        while (Marshal.ReleaseComObject(xWorksheets) != 0) { }
        while (Marshal.ReleaseComObject(xWorksheet) != 0) { }
        while (Marshal.ReleaseComObject(xCharts) != 0) { }
        while (Marshal.ReleaseComObject(xMyChart) != 0) { }
        while (Marshal.ReleaseComObject(xGraph) != 0) { }
        while (Marshal.ReleaseComObject(xSeriesColl) != 0) { }
        while (Marshal.ReleaseComObject(xSeries) != 0) { }
        xApp = null;
        xWorkbook = null;
        xWorksheets = null;
        xWorksheet = null;
        xCharts = null;
        xMyChart = null;
        xGraph = null;
        xSeriesColl = null;
        xSeries = null;

        GC.Collect();
        GC.WaitForPendingFinalizers();
    }
作者头像

规则 - 永远不要再使用一个点

——一个点

var range = ((Range)xlWorksheet.Cells[rowIndex, setColumn]);
var hyperLinks = range.Hyperlinks;
hyperLinks.Add(range, data);

-- 两个或更多点

 (Range)xlWorksheet.Cells[rowIndex, setColumn]).Hyperlinks.Add(range, data);
  • 例子

    
    using Microsoft.Office.Interop.Excel;
    
    Application xls = null;
    Workbooks workBooks = null;
    Workbook workBook = null;
    Sheets sheets = null;
    Worksheet workSheet1 = null;
    Worksheet workSheet2 = null;
    
    workBooks = xls.Workbooks;
    workBook = workBooks.Open(workSpaceFile);
    sheets = workBook.Worksheets;
    workSheet1 = (Worksheet)sheets[1];

// removing from Memory
if (xls != null)
{
foreach (Microsoft.Office.Interop.Excel.Worksheet sheet in sheets)
{
ReleaseObject(sheet);
}

ReleaseObject(sheets);
workBook.Close();
ReleaseObject(workBook);
ReleaseObject(workBooks);

xls.Application.Quit(); // THIS IS WHAT IS CAUSES EXCEL TO CLOSE
xls.Quit();
ReleaseObject(xls);

sheets = null;
workBook = null;
workBooks = null;
xls = null;

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

作者头像

摆脱所有引用很棘手,因为您必须猜测调用是否像:

var workbook = excel.Workbooks.Open("")

创建一个您没有引用的 Workbooks 实例。

甚至参考如下:

targetRange.Columns.AutoFit()

将在您不知情且未正确发布的情况下创建 .Columns() 的实例。

我最终编写了一个类,其中包含一个对象引用列表,可以以相反的顺序处理所有对象。

当您使用返回对象本身的 Excel 互操作时,该类有一个对象列表和 Add() 函数用于您引用的任何内容:

    public List<Object> _interopObjectList = new List<Object>();

    public Excel.Application add(Excel.Application obj)
    {
        _interopObjectList.Add(obj);
        return obj;
    }

    public Excel.Range add(Excel.Range obj)
    {
        _interopObjectList.Add(obj);
        return obj;
    }

    public Excel.Workbook add(Excel.Workbook obj)
    {
        _interopObjectList.Add(obj);
        return obj;
    }

    public Excel.Worksheet add(Excel.Worksheet obj)
    {
        _interopObjectList.Add(obj);
        return obj;
    }

    public Excel.Worksheets add(Excel.Worksheets obj)
    {
        _interopObjectList.Add(obj);
        return obj;
    }

    public Excel.Sheets add(Excel.Sheets obj)
    {
        _interopObjectList.Add(obj);
        return obj;
    }

    public Excel.Workbooks add(Excel.Workbooks obj)
    {
        _interopObjectList.Add(obj);
        return obj;
    }

然后为了注销对象,我使用了以下代码:

    //Release all registered interop objects in reverse order
    public void unregister()
    {
        //Loop object list in reverse order and release Office object
        for (int i=_interopObjectList.Count-1; i>=0 ; i -= 1)
        { ReleaseComObject(_interopObjectList[i]); }

        //Clear object list
        _interopObjectList.Clear();
    }

    /// <summary>
    /// Release a com interop object 
    /// </summary>
    /// <param name="obj"></param>
     public static void ReleaseComObject(object obj)
     {
         if (obj != null && InteropServices.Marshal.IsComObject(obj))
             try
             {
                 InteropServices.Marshal.FinalReleaseComObject(obj);
             }
             catch { }
             finally
             {
                 obj = null;
             }

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

然后原则是创建类并捕获这样的引用:

//Create helper class
xlsHandler xlObj = new xlsHandler();

..

//Sample - Capture reference to excel application
Excel.Application _excelApp = xlObj.add(new Excel.Application());

..
//Sample - Call .Autofit() on a cell range and capture reference to .Columns() 
xlObj.add(_targetCell.Columns).AutoFit();

..

//Release all objects collected by helper class
xlObj.unregister();

也许不是伟大的美丽代码,但可能会激发一些有用的东西。

作者头像

在您的代码中,您有:

excel.Workbooks.Open(...)

excel.Workbooks 正在创建一个 COM 对象。然后,您将从该 COM 对象调用 Open 函数。但是,当您完成后,您不会释放 COM 对象。

这是处理 COM 对象时的常见问题。基本上,您的表达式中不应包含多个点,因为您需要在完成后清理 COM 对象。

该主题太大而无法在答案中完全探索,但我认为您会发现 Jake Ginnivan 关于该主题的文章非常有帮助: VSTO and COM Interop

如果您厌倦了所有这些 ReleaseComObject 调用,您可能会发现这个问题很有帮助:
How to properly clean up Excel interop object in C#, 2012 edition

作者头像

如其他答案所述,使用两个点将创建无法被 Marshal.FinalReleaseComObject 关闭的隐藏引用。我只是想分享我的解决方案,这样就不需要记住 Marshal.FinalReleaseComObject - 它真的很容易错过,而且很难找到罪魁祸首。

我使用可用于任何 COM 对象的通用 IDisposable 包装类。它就像一个魅力,它保持一切美好和干净。我什至可以重用私有字段(例如 this.worksheet )。由于 IDisposable 的性质(Dispose 方法作为 finally 运行),它还会在引发错误时自动释放对象。

using Microsoft.Office.Interop.Excel;

public class ExcelService
{
    private _Worksheet worksheet;

    private class ComObject<TType> : IDisposable
    {
        public TType Instance { get; set; }

        public ComObject(TType instance)
        {
            this.Instance = instance;
        }

        public void Dispose()
        {
            System.Runtime.InteropServices.Marshal.FinalReleaseComObject(this.Instance);
        }
    }

    public void CreateExcelFile(string fullFilePath)
    {
        using (var comApplication = new ComObject<Application>(new Application()))
        {
            var excelInstance = comApplication.Instance;
            excelInstance.Visible = false;
            excelInstance.DisplayAlerts = false;

            try
            {
                using (var workbooks = new ComObject<Workbooks>(excelInstance.Workbooks))
                using (var workbook = new ComObject<_Workbook>(workbooks.Instance.Add()))
                using (var comSheets = new ComObject<Sheets>(workbook.Instance.Sheets))
                {
                    using (var comSheet = new ComObject<_Worksheet>(comSheets.Instance["Sheet1"]))
                    {
                        this.worksheet = comSheet.Instance;
                        this.worksheet.Name = "Action";
                        this.worksheet.Visible = XlSheetVisibility.xlSheetHidden;
                    }

                    using (var comSheet = new ComObject<_Worksheet>(comSheets.Instance["Sheet2"]))
                    {
                        this.worksheet = comSheet.Instance;
                        this.worksheet.Name = "Status";
                        this.worksheet.Visible = XlSheetVisibility.xlSheetHidden;
                    }

                    using (var comSheet = new ComObject<_Worksheet>(comSheets.Instance["Sheet3"]))
                    {
                        this.worksheet = comSheet.Instance;
                        this.worksheet.Name = "ItemPrices";
                        this.worksheet.Activate();

                        using (var comRange = new ComObject<Range>(this.worksheet.Range["A4"]))
                        using (var comWindow = new ComObject<Window>(excelInstance.ActiveWindow))
                        {
                            comRange.Instance.Select();
                            comWindow.Instance.FreezePanes = true;
                        }
                    }

                    if (this.fullFilePath != null)
                    {
                        var currentWorkbook = (workbook.Instance as _Workbook);
                        currentWorkbook.SaveAs(this.fullFilePath, XlFileFormat.xlWorkbookNormal);
                        currentWorkbook.Close(false);
                    }
                }
            }
            catch (Exception ex)
            {
                System.Diagnostics.Trace.WriteLine(ex.Message);
                throw;
            }
            finally
            {
                // Close Excel instance
                excelInstance.Quit();
            }
        }
    }
}
作者头像

万一你绝望Do not use this approach unless you understand what it does

foreach (Process proc in System.Diagnostics.Process.GetProcessesByName("EXCEL"))
{
  proc.Kill();
}

注意:这会杀死每个名为“EXCEL”的进程。

我必须这样做,因为即使我已经关闭了代码中的每个 COM 对象,我仍然有顽固的 Excel.exe 进程挂在那里。当然,这绝不是最好的解决方案。

作者头像

互操作进程后无法关闭 Excel.exe

不要把这个弄得太复杂!!只需创建一个简单的方法并按如下方式调用该方法:

// to kill the EXCELsheet file process from process Bar
private void KillSpecificExcelFileProcess() {
  foreach (Process clsProcess in Process.GetProcesses())
    if (clsProcess.ProcessName.Equals("EXCEL"))  //Process Excel?
      clsProcess.Kill();
    }
作者头像

或者,您可以按照 here 的说明终止 Excel 进程。

首先,导入SendMessage函数:

[DllImport("user32.dll", CharSet = CharSet.Auto)]
private static extern IntPtr SendMessage(IntPtr hWnd, int msg, IntPtr wParam, IntPtr lParam);

然后,将 WM_CLOSE 消息发送到主窗口:

SendMessage((IntPtr)excel.Hwnd, 0x10, IntPtr.Zero, IntPtr.Zero);
作者头像

@Denis Molodtsov 为了提供帮助,建议杀死所有名为“EXCEL”的进程。这似乎是在自找麻烦。已经有很多答案描述了在调用 excel.quit() 后通过与 COM 互操作玩得好来停止进程的方法。如果你能让它工作,这是最好的。

@Kevin Vuilleumier 有一个很好的建议,将 WM_CLOSE 发送到 Excel 窗口。我计划对此进行测试。

如果由于某种原因您需要终止 Excel 应用程序对象的 Excel 进程,则可以使用以下内容专门针对它:

  using System.Diagnostics;
  using System.Runtime.InteropServices;

// . . .

    [DllImport("user32.dll", SetLastError=true)]
    public static extern uint GetWindowThreadProcessId(IntPtr hWnd, out uint processId);

// . . .

    uint excelAppPid;
    uint tid = GetWindowThreadProcessId(excel.Hwnd, out excelAppPid);

    if (tid)
    {
      Process excelAppProc = Process.GetProcessById($excelPid)
      if (excelAppProc)
      {
        excelAppProc.Kill()
      }
    }

我没有时间在 C# 中进行全面测试,但我在 Powershell 中进行了快速测试,但遇到 Excel 无法终止的问题,这种方法有效。

这很简单。 Excel App 对象的 Hwnd 属性是 Excel 进程的隐藏窗口句柄。将 excel.Hwnd 传递给 GetWindowThreadProcessId 以获取进程 ID。使用它来打开进程,最后调用 Kill()。

至少我们确定我们正在杀死正确的进程。嗯,很确定。如果 Excel 进程已经正常终止,则它的进程 ID 可以被新进程重用。为了限制这种可能性,重要的是不要在调用 excel.quit() 和尝试杀死之间等待。