EXCEL wirklich schliessen

Bei der Erstellung einer Applikation, die mit EXCEL arbeitet stiess ich auf das Problem, dass sich EXCEL nicht sauber schliessen lässt. Die Artikel in diesem Forum waren recht hilfreich, die endgültige Lösung habe ich aber in dem grandiosen Artikel von  Scott Rutherford gefunden. Die dort beschriebene Lösung ist in Visual Basic geschrieben und lässt sich eins zu eins auf C# übertragen:


Bei dem Versuch EXCEL wieder sauber zu schliessen tritt das Problem auf, dass man die Applikation zwar schliessen und beenden kann, der Hauptprozess aber im Hintergrund erhalten bleibt. Das frisst nicht nur Ressourcen, sondern blockiert unter Umständen auch (temporäre) Dateien, die man nicht löschen, ändern oder überschreiben kann.

Der typsiche Ausstieg sieht wohl ao aus:

C#-Code:

// --- alles ordentlich schliessen excelWorkbook.Close(false, MISSING, MISSING); excelApp.Application.Quit(); excelApp.Quit(); // --- COM Objekte wieder freigeben Marshal.ReleaseComObject(excelWorksheet); Marshal.ReleaseComObject(excelWorkbook); Marshal.ReleaseComObject(excelApp); // --- variablen nullen, damit GC eine Chance hat den Speicher zu raeumen excelWorksheet = null; excelWorkbook = null; excelApp = null; // --- evtl. GC direkt aufrufen ... muss man aber nicht //GC.Collect(); //GC.WaitForPendingFinalizers();

Das reicht aber nicht aus. Um EXCEL wirklich zu beenden, muss man den Prozess abschiessen!

Nun ist die Frage natürlich, wie kommt man den Prozess ran? Antwort: wir geben EXCEL bei der Initialisierung eine 'Markierung' mit:

C#-Code:

string GuiId  = System.Guid.NewGuid().ToString().ToUpper(); excelApp.Caption   = GuiId; // 'unser' EXCEL eindeutig markieren!

Hierüber können wir später 'unser' - und nur unser - EXCEL Fenster wiederfinden:

C#-Code:

IntPtr hWnd = FindWindow(null, GuiId);

.. und dann die Prozess-ID identifizieren:

C#-Code:

int iProcID; GetWindowThreadProcessId(hWnd, out iProcID);

Achtung:

C#-Code:

GetWindowThreadProcessId

verlangt als 2. Argument eine Zeiger-Referenz auf eine

C#-Code:

int

Variable. In C# muss daher unbedingt das

C#-Code:

out

benutzt werden!

Mit der Prozess-ID kommen wir dann wieder sehr leicht an den EXCEL Prozess ran:

C#-Code:

Process p = Process.GetProcessById((int)iProcID);

Und nun hat EXCEL endgültig verloren:

C#-Code:

p.CloseMainWindow(); p.Refresh(); p.Kill();

Dann noch ein letzter Hinweis: um die oben genannten Funktionen

C#-Code:

FindWindow

und

C#-Code:

GetWindowThreadProcessId

benutzen zu können, müssen die vorab in der Klasse sauber deklariert werden:

C#-Code:

[DllImport("user32")] private static extern IntPtr FindWindow(string lpClassName, string lpWindowName); [DllImport("user32.dll", SetLastError = true)] static extern uint GetWindowThreadProcessId(IntPtr hWnd, out int lpdwProcessId);

Ich habe ein komplettes Beispiel angehängt. Wenn man das ausführt und den Task-Manager offen hat, kann man sehen, wie der EXCEL Prozess wieder verschwindet.

Es kann nicht die Lösung sein, einfach den Prozess abzuschießen. Das ist absolut dreckig.

Wenn der Excel-Prozess sich nicht richtig beendet, stimmt was nicht. Du solltest lieber die Ursache finden und sie beheben, statt nur die Auswirkungen zu bekämpfen.

Vielleicht ist ein AddIn etc. geladen, welches Excel am beenden hindert?

Ich hatte dieses "Excel beendet sich nicht"-Problem noch nicht. Es muss also irgendwas an Deiner Umgebung nicht stimmen. Excel an sicht funktioniert und beendet auch korrekt (So meine Erfahrung!).

@Rainbird: das kann ich nicht bestätigen, da geb ich cel Recht.
selbst wenn ich excel nicht aus einer meiner applikationen öffne, sind teilweise die prozesse noch offen.
Aus c# heraus das selbe spiel. wenn (wenn nötig) alles gespeichert ist, ist es kein thema das man excel einfach abschiesst. solang man auch den richtigen prozess erwischt, daher hat er die Lösung schon gut getroffen.

@cel: Hast du was dagegen wenn ich mir deinen Beitrag kopiere? ^^

ja kopieren in dem sinne das ich die lösung dazu, die sehr nützlich ist, in mein forum stelle ^^
vllt findet das ja jemand auch so hilfreich und muss nicht erst lange im internet suchen.
weil bei mir im forum treffen sich nur die selben leute, die nur programmieren (beruf ^^)

Also ich kann dieses Problem nur bestätigen. Nutze Excel 2003 und greife über PIA's auf Excel zu.

Hier mal die Code-Stelle, an der ich Excel schliesse:

C#-Code:

if (chkShowExcel.Checked)             {                 excelApp.Visible = true;             }             else             {                 //Excel schliessen                 excelWorkbook.Close(false,missing,missing);                 excelApp.Application.Quit();                 excelApp.Quit();                 //Variablen nullen                 excelApp = null;                 excelSheets = null;                 excelWorkbook = null;                 excelWorksheet = null;                 //Speicher aufräumen lassen (Muss nicht gemacht werden, aber doppelt hällt bekanntlich besser ;) )                 GC.Collect();                 GC.WaitForPendingFinalizers();             }

Auch bei mir bleibt der Prozess offen. Und ich hab keine Ahnung warum


Vielleicht könnte mir ja jemand beiläufig erklären, wofür das gemacht wird:

C#-Code:

// --- COM Objekte wieder freigeben                 Marshal.ReleaseComObject(excelWorksheet);                 Marshal.ReleaseComObject(excelWorkbook);                 Marshal.ReleaseComObject(excelApp);

Ich habe vor 2 Jahren mal ein COM-Addin für Word und Excel geschrieben und hatte nur am Anfang Probleme mit nicht wirklich geschlossenen Prozessen.

Nach ein wenig Nachforschung fand ich dann den Hinweis mit Marshal.ReleaseComObject, und seitdem hat ich das Problem nie wieder.

Auf irgendeiner Seite laß ich dann, dass man wirklich jedes Objekt was man direkt oder indirekt nutzt wieder freigeben soll... vielleicht macht ihr genau das nicht?

Direkt heißt dabei z.b.

C#-Code:

Word.Application app = new Word.Application();

Indirekt wäre bei

C#-Code:

Word.Document doc = app.Documents.Add(...);

das Documents Objekt.

Besser wäre also

C#-Code:

Word.Documents docs = app.Documents; Word.Document doc = docs.Add(...);

Dabei halt immer die Resourcen der Objekte wieder freigeben.
Ich fahr damit seht gut.

Zudem sind mir häufig schlechte Addins untergekommen die selbst wohl nicht ganz sauber programmiert sind und z.b. Word daran hintern die normal.dot am Ende ordentlich zu speichern... (gerade erst wieder durch Acrobat 7.0.0 gehabt, Update auf 7.0.5 hats behoben).

Den Prozess abzuschießen halte ich nicht für eine saubere Lösung. Aber müßt ihr selbst wissen ob ihr das verantworten könnt. Man weiß ja nie ob nicht doch mal ein wichtiges Dokument mit abgeschossen wird.

Zitat:

Vielleicht könnte mir ja jemand beiläufig erklären, wofür das gemacht wird: C#-Code: Marshal.ReleaseComObject(excelWorksheet); Marshal.ReleaseComObject(excelWorkbook); Marshal.ReleaseComObject(excelApp);

Allein durch diese Frage könnt ich dir fast sagen warum dein Programm Probleme hat Excel richtig zu schließen...

Wenn du Objekte von Excel oder Word benutzt, dann sind das COM-Objekte. Diese werden nicht durch den Garbage Collector verwaltet und müßen selbst frei gegeben werden. Das macht man mit der Methode Marshal.ReleaseComObject. Deien explizieten Aufrufe vom GC nutzen also nichts.

Gibst du die Objekte nicht frei wirst du höchstwahrscheinlich einen noch hängenden Prozess haben.

Ja das sind auch COM-Objekte. Die solltest Du auch freigeben, wenn sie klassenweit deklariert sind.

Ich bleibe dabei. Wenn sich Excel nicht richtig schließt, hat man was falsch gemacht.

Zitat:

Nun aber zum Thema, ich selbst verwende Office 2007 Beta und bei der Version wird Excel nicht korrekt geschlossen wenn vor dem Close und dem ReleaseComObject eine Exception geschmissen wird. Vielleicht ist dass ja mal ein Ansatz, ansonsten wenn der Code keine Exception auslöst, schließt sich Excel normal, das kann ich von Version 2000, 2003 und 2007 sagen.

würde ich übrigens fast auch meine hand für ins feuer legen das es hier am fehlenden Marshal.ReleaseComObject liegt...

hast du alles was du mit excel machst in einen try... catch... finally bzw try... finally ... eingebetten? im finally müßte dann das Marshall.ReleaseComObject rein...

würde also so aussehen

C#-Code:

//deklaration der variablen Word.Documents oDocs = null; Word.Document oDoc = null; try {     oDocs = oWord.Documents;     oDoc = oDocs.Add(...);     ... } catch (SomeException e) {     ... } finally {     if(oDocs!=null) {         Marshall.ReleaseComObject(oDocs);     }     if(oDoc!=null) {         Marshall.ReleaseComObject(oDoc);     } }

wobei es sich schon fast lohnt den ReleaseComObject - code in eine neue methode auszulagern, der auch auf null vorher überprüft^^

jedenfalls ne menge schreibarbeit... aber damit hab ich jedenfalls nie probleme... solange mir kein anderes addin mein word zerschießt^^

Zitat:

Muss ich vielleicht auch meine ganzen Ranges (mit denen ich die Excel Zellen anspreche) nullen oder freigeben? Sind ja an sich ganz normale Variablen oder sind es auch solche COM Objekte?

jedes objekt einer klasse aus dem word, excel oder office namespace dürfte i.d.r. ein com object sein...

wie oben schon geschrieben war ists nicht besonders gut einfach so den prozess zu killn.letzlich verdeckt man damit nur das man selbst das problem nicht anders in den griff bekommen hat.

falsl du mal ein com-addin entwickelst stehst du eh wieder vor dem selben problem. und da kannst du wirklich nicht einfach den prozess abschießen... und unsaubere addins sind oft das quell so manch einen übels^^

hi,

ich habe mich auch eine zeitlang mit diesem problem beschäftigt und bin zu dem schluss gekommen das es ein garbage-collector problem ist.

wenn man extrem sauber und garbage collector "freundlich" programmiert so das er
alle verwendeten variablen problemlos löschen kann, geht auch excel zu. vergisst man aber eine variable in der funktion auf null zu setzten oder noch schlimmer ein dipose aufruf eines erstellten objektes, geht excel erst beim beenden des programmes zu. :-(

anbei ein kleines beispiel progi was bei mir excel wieder zumacht. setzt man aber eine von den variablen am ende nicht null geht excel nicht zu.

C#-Code:

Excel.ApplicationClass app = null;             Excel.Workbook workBook = null;             Excel.Worksheet workSheet = null;             Excel.Range range = null;             app = new Excel.ApplicationClass();             // create the workbook object by opening the excel file.             workBook = app.Workbooks.Open(@"test.xls",                                                      0,                                                      true,                                                      5,                                                      "",                                                      "",                                                      true,                                                      Excel.XlPlatform.xlWindows,                                                      "\t",                                                      false,                                                      false,                                                      0,                                                      true,                                                      Missing.Value,                                                      Missing.Value                                                      );             if (null != workBook.ActiveSheet)             {                 workSheet = (Excel.Worksheet)workBook.ActiveSheet;                 range = (Excel.Range)workSheet.Cells[1, 1];             }             workBook.Close(false, Missing.Value, Missing.Value);             app.Application.Quit();             app.Quit();             Marshal.ReleaseComObject(range);             Marshal.ReleaseComObject(workSheet);             Marshal.ReleaseComObject(workBook);             Marshal.ReleaseComObject(app);             range = null;             workSheet = null;             workBook = null;             app = null;             GC.Collect();             MessageBox.Show("done");

ReleaseComObject liefert doch einen int zurück welcher anzeigt wie oft das Objekt noch referenziert ist...

Wenn ein call von ReleaseComObject einen Wert > 0 zurückliefert, dann ist eine Instanz (Com-mässig) nicht freigegeben... ergo kann Excel nicht geschlossen werden.


Nachtrag:

Seit Version 2.0 bietet sich hierführ an:

FinalReleaseComObject

Zitat:

Original von rokohl ich sehe da keine referenz ???

C#-Code:

if (null != workBook.ActiveSheet)  //das erste Marshalling             {                 workSheet = (Excel.Worksheet)workBook.ActiveSheet; //das zweite Marshalling

Somit zählt er vermutlich auf 2 rauf...

Und du releast nur 1

probier es mal so:

C#-Code:

workSheet = (Excel.Worksheet)workBook.ActiveSheet; //das zweite if (workSheet!=null) . ..

*aufweck*

Hab auch ein Problem mit dem Schließen von Excel.

Meine Methode sieht so aus (bitte nicht den Sinn hinterfragen...):

C#-Code:

private void ReSaveExcelFile(string filename)         {             Excel.Application excelApp = new Microsoft.Office.Interop.Excel.ApplicationClass();             Excel.Workbook wb = null;             try             {                 wb = excelApp.Workbooks.Open(filename, Type.Missing, Type.Missing, Type.Missing, Type.Missing,                      Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing,                      Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing);                 wb.SaveAs(filename,Excel.XlFileFormat.xlExcel7,                     Type.Missing,Type.Missing,Type.Missing,Type.Missing, Excel.XlSaveAsAccessMode.xlNoChange,                     Type.Missing,Type.Missing,Type.Missing,Type.Missing,Type.Missing);             }             catch (Exception ex)             {                 MessageBox.Show("Fehler beim Speichern der Datei '" + filename + "': " + ex.Message,                         this.messageBoxCaption, MessageBoxButtons.OK, MessageBoxIcon.Error);             }             finally             {                 wb.Close(Type.Missing, Type.Missing, Type.Missing);                 excelApp.Application.Quit();                 excelApp.Quit();                 System.Runtime.InteropServices.Marshal.ReleaseComObject(excelApp);                 System.Runtime.InteropServices.Marshal.ReleaseComObject(wb);                 wb = null;                 excelApp = null;             }         }

Obwohl ich mMn alles richtig geschlossen und freigegeben habe, bleibt der Excel-Prozess bis ich meine Anwendung geschlossen habe offen.

Warum?

thx for hints

Zitat:

Original von él toro Warum nutzt du nicht System.IO.File.Copy

Ich hab doch gesagt nicht hinterfragen ;-)
Die Funktion soll eine Excel-Datei unter einer anderen Excel-Version speichern, da ich von einer anderen Anwendung eine Datei im Excel 3.0-Format erhalte und das zur Weiterverarbeitung nicht geeignet ist...

@tipp:
funktioniert, danke!

Hallo Leute.

Jetzt muss ich einen alten Beitrag wieder aufwärmen, weils bei mir einfach nicht hinhaut.
Der Prozess "Excel.exe" wird einfach nicht beendet.

Weis jemand an was das liegen könnte? Benutze Vista Enterprise und Office 2007.

Folgend noch mein code:

C#-Code:

private void button1_Click(object sender, EventArgs e) {     object missing = Type.Missing;     string PosX, PosY;     int i;     //.xml-File mit Excel öffnen und Daten auslesen um die ovl Dateien zu erzeugen     Excel.Application excelApp = new Excel.Application();     Excel.Workbook workbook = excelApp.Workbooks.Open(Dateipfad() + @"\File.xml", missing, missing, missing, missing, missing, missing, missing, missing, missing, missing, missing, missing, missing, missing);     Excel.Worksheet worksheet = (Excel.Worksheet)workbook.Worksheets["wks-Name"];     excelApp.Visible = true;     //Anzahl der Zeilen ermitteln     string beginCell = "A" + worksheet.Rows.Count;     string endCell = "AA" + worksheet.Rows.Count;     int row = worksheet.get_Range(beginCell, endCell).get_End(Excel.XlDirection.xlUp).Row;     for (i = 2; i <= row; i++)     {         //Daten aus Excelfile ermitteln         Excel.Range Xrng = worksheet.get_Range("A"+i, "F"+i);         Excel.Range Yrng = worksheet.get_Range("P"+i, "S"+i);         PosX = (string)Xrng.get_Value(missing);         PosY = (string)Yrng.get_Value(missing);         //Textdatei erstellen, Daten eintragen und Text speichern         StreamWriter Writer = new StreamWriter(Dateipfad() + ".txt", false, Encoding.Default);         //Daten für Markierung eintragen         Writer.WriteLine("TextTextText");         Writer.Close();     }     //Excel schließen     workbook.Close(false, missing, missing);     excelApp.Application.Quit();     excelApp.Quit();     //COM Objekte freigeben um EXCEL.exe zu schließen     Marshal.FinalReleaseComObject(worksheet);     Marshal.FinalReleaseComObject(workbook);     Marshal.FinalReleaseComObject(excelApp);     //Variablen auf Null setzen     PosX = null;     PosY = null;     worksheet = null;     workbook = null;     excelApp = null; }

Gruß
Red_Dragon69

Also ich schliess mich mal Rainbird an. Hab alles sauber zugemacht und Excel wird geschlossen.

gute und hilfreiche Diskussion hier.

Egal wie alt dieser Beitrag ist. Genau das freigeben der COM Objekte hat mir bei diesem Problem geholfen. Dabei gebe ich mittlerweile alle Objekte direkt wieder frei, egal ob in For Schleifen oder sonst wo. Wenn diese nicht mehr benötigt werden werden sie freigegeben.

Vielen Dank