when is Excel shutdown completed?

oXL.Quit();
                System.Runtime.InteropServices.Marshal.ReleaseComObject(oSheet);
                oSheet = null;
                System.Runtime.InteropServices.Marshal.ReleaseComObject(oWBook);
                oWBook = null;
                System.Runtime.InteropServices.Marshal.ReleaseComObject(oXL);
                oXL = null;
                GC.Collect();
                GC.WaitForPendingFinalizers();

using System;
using System.Runtime.InteropServices;
using System.Diagnostics;
using Microsoft.Office.Interop.Excel;
namespace ExcelTools
{
    /// <summary>
    /// Helper class for automating excel
    /// </summary>
    /// <remarks>
    /// Loads of issues with COM interop and ensuring that we release all variables
    /// to ensure we don't get orphaned excel processes floating about, this class helps
    /// out with that
    /// </remarks>
    internal class ExcelWrapper : IDisposable
    {
        private class Window
        {
            [DllImport("user32.dll", SetLastError = true)]
            static extern IntPtr FindWindow(string lpClassName, string lpWindowName);
            [DllImport("user32.dll")]
            private static extern IntPtr GetWindowThreadProcessId(IntPtr hWnd, out IntPtr ProcessId);
            public static IntPtr GetWindowThreadProcessId(IntPtr hWnd)
            {
                IntPtr processId;
                IntPtr returnResult = GetWindowThreadProcessId(hWnd, out processId);
                return processId;
            }
            public static IntPtr FindExcel(string caption)
            {
                System.IntPtr hWnd = FindWindow("XLMAIN", caption);
                return hWnd;
            }
        }

        private Application excel;
        private IntPtr windowHandle;
        private IntPtr processId;
        public ExcelWrapper()
        {
            // Create the excel application
            excel = CreateExcelApplication();
            // Find the specific process we have created with the caption 'COExcel',
            // get the window handle
            windowHandle = Window.FindExcel("your instance title");
            // Now we can get the process ID from the hWnd
            processId = Window.GetWindowThreadProcessId(windowHandle);
        }
        /// <summary>
        /// Creates an EXCEL.EXE instance with some common properties set, ready for automation
        /// </summary>
        /// <returns>Excel Application object</returns>
        private Application CreateExcelApplication()
        {
            Application excel = new Application();
            excel.Caption = "your instance title";
            excel.DisplayAlerts = false;
            excel.AlertBeforeOverwriting = false;
            excel.AskToUpdateLinks = false;
            return excel;
        }
        /// <summary>
        /// Read only. Access to the application object
        /// </summary>
        public Application Excel
        {
            get { return this.excel; }
        }
        /// <summary>
        /// Read only. The process id that the automated instance of Excel is
        /// running as
        /// </summary>
        public int ProcessId
        {
            get { return this.processId.ToInt32(); }
        }
        /// <summary>
        /// Read only. The window handle of the automated Excel instance
        /// </summary>
        public int WindowHandle
        {
            get { return this.windowHandle.ToInt32(); }
        }
        #region IDisposable Members
        /// <summary>
        /// The dispose method will attempt to clean up any COM objects that we have used
        /// during automation
        /// </summary>
        public void Dispose()
        {
            if (excel != null)
            {
                excel.Workbooks.Close();
                excel.Quit();
                System.Runtime.InteropServices.Marshal.ReleaseComObject(excel);
                excel = null;
                GC.Collect();
                GC.WaitForPendingFinalizers();
                // The GC needs to be called twice in order to get the
                // Finalizers called - the first time in, it simply makes
                // a list of what is to be finalized, the second time in,
                // it actually  the finalizing.  Only then will the
                // object do its automatic ReleaseComObject.
                GC.Collect();
                GC.WaitForPendingFinalizers();
                // OK, hammer and egg time. If we've still got a process open
                // maybe due to accidentially incrementing the COM interfaces
                // without using an object reference, then we'll just kill
                // the process we have created since we know it's finished
                // now
                try
                {
                    Process process = Process.GetProcessById(this.ProcessId);
                    if (process != null)
                    {
                        process.Kill();
                    }
                }
                catch
                {
                }

            }
        }
        #endregion
    }
}

using (ExcelWrapper wrapper = new ExcelWrapper())
{
    // Do something with the wrapper.Excel object
}
// Instance should be terminate once code execution leaves using block