Merge pull request #3644 from MDoerner/ShutdownIssueOneMoreRound

retailcoder · web-flow · commit 088ce6ba67ac · 2017-12-25T15:30:10.000-05:00
More shutdown tweaks
diff --git a/RetailCoder.VBE/AppMenu.cs b/RetailCoder.VBE/AppMenu.cs
@@ -87,7 +87,6 @@ private void RemoveMenus()
                 //The parents further down get disposed of/released as part of the remove chain.
                 _logger.Trace($"Removing parent menu of top-level menu {menu.GetType()}.");
                 menu.Parent.Dispose();
-                menu.Parent.Release(true);  //todo: Find a way around this!!!
                 menu.Parent = null;
             }
         }
diff --git a/RetailCoder.VBE/Extension.cs b/RetailCoder.VBE/Extension.cs
@@ -16,6 +16,7 @@
 using Rubberduck.Root;
 using Rubberduck.Settings;
 using Rubberduck.SettingsProvider;
+using Rubberduck.UI.Command.MenuItems;
 using Rubberduck.VBEditor.Events;
 using Rubberduck.VBEditor.SafeComWrappers.Abstract;
 using Rubberduck.VBEditor.WindowsApi;
@@ -246,7 +247,11 @@ private void ShutdownAddIn()
                 VBENativeServices.UnhookEvents();
 
                 _logger.Log(LogLevel.Trace, "Broadcasting shutdown...");
-                User32.EnumChildWindows(_ide.MainWindow.Handle(), EnumCallback, new IntPtr(0));
+                using (var mainWindow = _ide.MainWindow)
+                {
+                    var mainWindosHndl = mainWindow.Handle();
+                    UiDispatcher.Invoke(() => User32.EnumChildWindows(mainWindosHndl, EnumCallback, new IntPtr(0)));
+                }
 
                 _logger.Log(LogLevel.Trace, "Releasing dockable hosts...");
                 Windows.ReleaseDockableHosts();
diff --git a/RetailCoder.VBE/Root/RubberduckIoCInstaller.cs b/RetailCoder.VBE/Root/RubberduckIoCInstaller.cs
@@ -257,9 +257,7 @@ private static void RegisterParseTreeInspections(IWindsorContainer container, As
         private void RegisterRubberduckMenu(IWindsorContainer container)
         {
             const int windowMenuId = 30009;
-            var commandBars = _vbe.CommandBars;
-            var menuBar = commandBars[MenuBar];
-            var controls = menuBar.Controls;
+            var controls = MainCommandBarControls(MenuBar);
             var beforeIndex = FindRubberduckMenuInsertionIndex(controls, windowMenuId);
             var menuItemTypes = RubberduckMenuItems();
             RegisterMenu<RubberduckParentMenu>(container, controls, beforeIndex, menuItemTypes);
@@ -296,24 +294,36 @@ private static int FindRubberduckMenuInsertionIndex(ICommandBarControls controls
         {
             for (var i = 1; i <= controls.Count; i++)
             {
-                var item = controls[i];
-                if (item.IsBuiltIn && item.Id == beforeId)
+                using (var item = controls[i])
                 {
-                    return i;
+                    if (item.IsBuiltIn && item.Id == beforeId)
+                    {
+                        return i;
+                    }
                 }
             }
 
             return controls.Count;
         }
 
+        private ICommandBarControls MainCommandBarControls(int commandBarIndex)
+        {
+            ICommandBarControls controls;
+            using (var commandBars = _vbe.CommandBars)
+            {
+                using (var menuBar = commandBars[commandBarIndex])
+                {
+                    controls = menuBar.Controls;
+                }
+            }
+            return controls;
+        }
+
         private void RegisterCodePaneContextMenu(IWindsorContainer container)
         {
             const int listMembersMenuId = 2529;
-            var commandBars = _vbe.CommandBars;
-            var menuBar = commandBars[CodeWindow];
-            var controls = menuBar.Controls;
-            var beforeControl = controls.FirstOrDefault(control => control.Id == listMembersMenuId);
-            var beforeIndex = beforeControl == null ? 1 : beforeControl.Index;
+            var controls = MainCommandBarControls(CodeWindow);
+            var beforeIndex = FindRubberduckMenuInsertionIndex(controls, listMembersMenuId);
             var menuItemTypes = CodePaneContextMenuItems();
             RegisterMenu<CodePaneContextParentMenu>(container, controls, beforeIndex, menuItemTypes);
         }
@@ -333,11 +343,8 @@ private static Type[] CodePaneContextMenuItems()
         private void RegisterFormDesignerContextMenu(IWindsorContainer container)
         {
             const int viewCodeMenuId = 2558;
-            var commandBars = _vbe.CommandBars;
-            var menuBar = commandBars[MsForms];
-            var controls = menuBar.Controls;
-            var beforeControl = controls.FirstOrDefault(control => control.Id == viewCodeMenuId);
-            var beforeIndex = beforeControl?.Index ?? 1;
+            var controls = MainCommandBarControls(MsForms);
+            var beforeIndex = FindRubberduckMenuInsertionIndex(controls, viewCodeMenuId);
             var menuItemTypes = FormDesignerContextMenuItems();
             RegisterMenu<FormDesignerContextParentMenu>(container, controls, beforeIndex, menuItemTypes);
         }
@@ -354,23 +361,17 @@ private static Type[] FormDesignerContextMenuItems()
         private void RegisterFormDesignerControlContextMenu(IWindsorContainer container)
         {
             const int viewCodeMenuId = 2558;
-            var commandBars = _vbe.CommandBars;
-            var menuBar = commandBars[MsFormsControl];
-            var controls = menuBar.Controls;
-            var beforeControl = controls.FirstOrDefault(control => control.Id == viewCodeMenuId);
-            var beforeIndex = beforeControl?.Index ?? 1;
+            var controls = MainCommandBarControls(MsFormsControl);
+            var beforeIndex = FindRubberduckMenuInsertionIndex(controls, viewCodeMenuId);
             var menuItemTypes = FormDesignerContextMenuItems();
             RegisterMenu<FormDesignerControlContextParentMenu>(container, controls, beforeIndex, menuItemTypes);
         }
 
         private void RegisterProjectExplorerContextMenu(IWindsorContainer container)
         {
             const int projectPropertiesMenuId = 2578;
-            var commandBars = _vbe.CommandBars;
-            var menuBar = commandBars[ProjectWindow];
-            var controls = menuBar.Controls;
-            var beforeControl = controls.FirstOrDefault(control => control.Id == projectPropertiesMenuId);
-            var beforeIndex = beforeControl?.Index ?? 1;
+            var controls = MainCommandBarControls(ProjectWindow);
+            var beforeIndex = FindRubberduckMenuInsertionIndex(controls, projectPropertiesMenuId);
             var menuItemTypes = ProjectWindowContextMenuItems();
             RegisterMenu<ProjectWindowContextParentMenu>(container, controls, beforeIndex, menuItemTypes);
         }
diff --git a/RetailCoder.VBE/UI/Command/MenuItems/CommandBars/AppCommandBarBase.cs b/RetailCoder.VBE/UI/Command/MenuItems/CommandBars/AppCommandBarBase.cs
@@ -114,7 +114,11 @@ private ICommandBarControl InitializeChildControl(ICommandMenuItem item)
                 return null;
             }
 
-            var child = CommandBarButtonFactory.Create(Item.Controls);
+            ICommandBarButton child;
+            using (var controls = Item.Controls)
+            {
+                child = CommandBarButtonFactory.Create(controls);
+            }
             child.Style = item.ButtonStyle;
             child.Picture = item.Image;
             child.Mask = item.Mask;
diff --git a/RetailCoder.VBE/UI/Command/MenuItems/ParentMenus/ParentMenuItemBase.cs b/RetailCoder.VBE/UI/Command/MenuItems/ParentMenus/ParentMenuItemBase.cs
@@ -101,6 +101,7 @@ private void RemoveChildren()
             foreach (var child in _items.Keys.Select(item => item as IParentMenuItem).Where(child => child != null))
             {
                 child.RemoveMenu();
+                child.Parent.Dispose();
             }
             foreach (var child in _items.Values.Select(item => item as ICommandBarButton).Where(child => child != null))
             {
@@ -155,7 +156,11 @@ private ICommandBarControl InitializeChildControl(ICommandMenuItem item)
                 return null;
             }
 
-            var child = CommandBarButtonFactory.Create(Item.Controls);
+            ICommandBarButton child;
+            using (var controls = Item.Controls)
+            {
+                child = CommandBarButtonFactory.Create(controls);
+            }
             child.Picture = item.Image;
             child.Mask = item.Mask;
             child.ApplyIcon();
diff --git a/RetailCoder.VBE/UI/Controls/SearchResultPresenterInstanceManager.cs b/RetailCoder.VBE/UI/Controls/SearchResultPresenterInstanceManager.cs
@@ -54,6 +54,8 @@ private void Dispose(bool disposing)
             {
                 _view.ViewModel.LastTabClosed -= viewModel_LastTabClosed;
             }
+            _presenter?.Dispose();
+
             _disposed = true;
         }
     }
diff --git a/RetailCoder.VBE/UI/DockableToolwindowPresenter.cs b/RetailCoder.VBE/UI/DockableToolwindowPresenter.cs
@@ -50,9 +50,12 @@ private IWindow CreateToolWindow(IDockableUserControl control)
             IWindow toolWindow;
             try
             {
-                var info = _vbe.Windows.CreateToolWindow(_addin, _DockableWindowHost.RegisteredProgId, control.Caption, control.ClassId);
-                _userControlObject = info.UserControl;
-                toolWindow = info.ToolWindow;
+                using (var windows = _vbe.Windows)
+                {
+                    var info = windows.CreateToolWindow(_addin, _DockableWindowHost.RegisteredProgId, control.Caption, control.ClassId);
+                    _userControlObject = info.UserControl;
+                    toolWindow = info.ToolWindow;
+                }
             }
             catch (COMException exception)
             {
@@ -120,7 +123,7 @@ public void Dispose()
         ~DockableToolwindowPresenter()
         {
             // destructor for tracking purposes only - do not suppress unless 
-            Debug.WriteLine("DockableToolwindowPresenter finalized.");
+            Debug.WriteLine($"DockableToolwindowPresenter of type {this.GetType()} finalized.");
         }
     }
 }
diff --git a/RetailCoder.VBE/UI/DockableWindowHost.cs b/RetailCoder.VBE/UI/DockableWindowHost.cs
@@ -142,7 +142,7 @@ protected override bool ProcessKeyPreview(ref Message m)
         protected override void DefWndProc(ref Message m)
         {
             //See the comment in the ctor for why we have to listen for this.
-            if (m.Msg == (int) WM.DESTROY)
+            if (m.Msg == (int) WM.DESTROY && !_released)
             {
                 Debug.WriteLine("DockableWindowHost received WM.DESTROY.");
                 try
@@ -162,10 +162,19 @@ protected override void DefWndProc(ref Message m)
 
         //override 
 
+        private bool _released; 
         public void Release()
         {
+            if (_released)
+            {
+                return;
+            }
+
             Debug.WriteLine("DockableWindowHost release called.");
             _subClassingWindow.Dispose();
+            _thisHandle.Free();
+
+            _released = true;
         }
 
         protected override void DestroyHandle()
@@ -218,6 +227,20 @@ public override int SubClassProc(IntPtr hWnd, IntPtr msg, IntPtr wParam, IntPtr
                 }
                 return base.SubClassProc(hWnd, msg, wParam, lParam, uIdSubclass, dwRefData);
             }
+
+            private bool _disposed;
+            protected override void Dispose(bool disposing)
+            {
+                if (!_disposed && disposing && !_closing)
+                {
+                    OnCallBackEvent(new SubClassingWindowEventArgs(IntPtr.Zero) { Closing = true });
+                    _closing = true;
+                }
+
+                _disposed = true;
+
+                base.Dispose(disposing);
+            }
         }
     }
 }
diff --git a/Rubberduck.VBEEditor/SafeComWrappers/SafeComWrapper.cs b/Rubberduck.VBEEditor/SafeComWrappers/SafeComWrapper.cs
@@ -54,8 +54,17 @@ public void Release(bool final = false)
                 else
                 {
                     _rcwReferenceCount = Marshal.ReleaseComObject(Target);
-                    _logger.Trace($"Released COM wrapper of type {this.GetType()} with remaining reference count {_rcwReferenceCount}.");
+                    if (_rcwReferenceCount >= 0)
+                    {
+                        _logger.Trace($"Released COM wrapper of type {this.GetType()} with remaining reference count {_rcwReferenceCount}.");
+                    }
+                    else
+                    {
+                        _logger.Warn($"Released COM wrapper of type {this.GetType()} whose underlying RCW has already been released from outside the SafeComWrapper.");
+                    }
                 }
+
+                
             }
             catch(COMException exception)
             {
@@ -73,7 +82,7 @@ public void Release(bool final = false)
             }
         }
 
-        public bool HasBeenReleased => _rcwReferenceCount == 0;
+        public bool HasBeenReleased => _rcwReferenceCount <= 0;
 
         public bool IsWrappingNullReference => Target == null;
         object INullObjectWrapper.Target => Target;
diff --git a/Rubberduck.VBEEditor/SafeComWrappers/VBA/Windows.cs b/Rubberduck.VBEEditor/SafeComWrappers/VBA/Windows.cs
@@ -1,5 +1,8 @@
 using System.Collections;
 using System.Collections.Generic;
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+using Microsoft.Office.Interop.Outlook;
 using Rubberduck.VBEditor.SafeComWrappers.Abstract;
 using VB = Microsoft.Vbe.Interop;
 
@@ -40,6 +43,7 @@ public static void ReleaseDockableHosts()
                 dynamic host = item.Value;
                 host.Release();
             }
+            _dockableHosts.Clear();
         }
 
         IEnumerator IEnumerable.GetEnumerator()
diff --git a/Rubberduck.VBEEditor/WindowsApi/SubclassingWindow.cs b/Rubberduck.VBEEditor/WindowsApi/SubclassingWindow.cs
@@ -13,14 +13,16 @@ public abstract class SubclassingWindow : IDisposable
 
         private readonly object _subclassLock = new object();
 
-        public delegate int SubClassCallback(IntPtr hWnd, IntPtr msg, IntPtr wParam, IntPtr lParam, IntPtr uIdSubclass, IntPtr dwRefData);
+        public delegate int SubClassCallback(IntPtr hWnd, IntPtr msg, IntPtr wParam, IntPtr lParam, IntPtr uIdSubclass,
+            IntPtr dwRefData);
 
         [DllImport("user32.dll")]
         [return: MarshalAs(UnmanagedType.Bool)]
         private static extern bool IsWindow(IntPtr hWnd);
 
         [DllImport("ComCtl32.dll", CharSet = CharSet.Auto)]
-        private static extern int SetWindowSubclass(IntPtr hWnd, SubClassCallback newProc, IntPtr uIdSubclass, IntPtr dwRefData);
+        private static extern int SetWindowSubclass(IntPtr hWnd, SubClassCallback newProc, IntPtr uIdSubclass,
+            IntPtr dwRefData);
 
         [DllImport("ComCtl32.dll", CharSet = CharSet.Auto)]
         private static extern int RemoveWindowSubclass(IntPtr hWnd, SubClassCallback newProc, IntPtr uIdSubclass);
@@ -38,18 +40,10 @@ protected SubclassingWindow(IntPtr subclassId, IntPtr hWnd)
             AssignHandle();
         }
 
-        private bool _disposed;
         public void Dispose()
         {
-            if (_disposed)
-            {
-                return;
-            }
-
-            ReleaseHandle();
-            _thisHandle.Free();
-
-            _disposed = true;
+            Dispose(true);
+            GC.SuppressFinalize(this);
         }
 
         private void AssignHandle()
@@ -89,19 +83,38 @@ private void ReleaseHandle()
             }
         }
 
-        public virtual int SubClassProc(IntPtr hWnd, IntPtr msg, IntPtr wParam, IntPtr lParam, IntPtr uIdSubclass, IntPtr dwRefData)
+        public virtual int SubClassProc(IntPtr hWnd, IntPtr msg, IntPtr wParam, IntPtr lParam, IntPtr uIdSubclass,
+            IntPtr dwRefData)
         {
             if (!_listening)
             {
                 Debug.WriteLine("State corrupted. Received window message while not listening.");
                 return DefSubclassProc(hWnd, msg, wParam, lParam);
             }
 
-            if ((uint)msg == (uint)WM.RUBBERDUCK_SINKING || (uint)msg == (uint)WM.DESTROY)
-            {               
-                ReleaseHandle();                
+            if ((uint) msg == (uint) WM.RUBBERDUCK_SINKING || (uint) msg == (uint) WM.DESTROY)
+            {
+                ReleaseHandle();
             }
             return DefSubclassProc(hWnd, msg, wParam, lParam);
         }
+
+        private bool _disposed;
+        protected virtual void Dispose(bool disposing)
+        {
+            if (_disposed)
+            {
+                return;
+            }
+
+            if (disposing)
+            {
+                ReleaseHandle();
+            }
+
+            _thisHandle.Free();
+
+            _disposed = true;
+        }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -87,7 +87,6 @@ private void RemoveMenus()`
`87`	`87`	`//The parents further down get disposed of/released as part of the remove chain.`
`88`	`88`	`_logger.Trace($"Removing parent menu of top-level menu {menu.GetType()}.");`
`89`	`89`	`menu.Parent.Dispose();`
`90`		`- menu.Parent.Release(true); //todo: Find a way around this!!!`
`91`	`90`	`menu.Parent = null;`
`92`	`91`	`}`
`93`	`92`	`}`
Original file line number	Diff line number	Diff line change
`@@ -101,6 +101,7 @@ private void RemoveChildren()`
`101`	`101`	`foreach (var child in _items.Keys.Select(item => item as IParentMenuItem).Where(child => child != null))`
`102`	`102`	`{`
`103`	`103`	`child.RemoveMenu();`
	`104`	`+ child.Parent.Dispose();`
`104`	`105`	`}`
`105`	`106`	`foreach (var child in _items.Values.Select(item => item as ICommandBarButton).Where(child => child != null))`
`106`	`107`	`{`
`@@ -155,7 +156,11 @@ private ICommandBarControl InitializeChildControl(ICommandMenuItem item)`
`155`	`156`	`return null;`
`156`	`157`	`}`
`157`	`158`
`158`		`- var child = CommandBarButtonFactory.Create(Item.Controls);`
	`159`	`+ ICommandBarButton child;`
	`160`	`+ using (var controls = Item.Controls)`
	`161`	`+ {`
	`162`	`+ child = CommandBarButtonFactory.Create(controls);`
	`163`	`+ }`
`159`	`164`	`child.Picture = item.Image;`
`160`	`165`	`child.Mask = item.Mask;`
`161`	`166`	`child.ApplyIcon();`
Original file line number	Diff line number	Diff line change
`@@ -54,6 +54,8 @@ private void Dispose(bool disposing)`
`54`	`54`	`{`
`55`	`55`	`_view.ViewModel.LastTabClosed -= viewModel_LastTabClosed;`
`56`	`56`	`}`
	`57`	`+ _presenter?.Dispose();`
	`58`	`+`
`57`	`59`	`_disposed = true;`
`58`	`60`	`}`
`59`	`61`	`}`
Original file line number	Diff line number	Diff line change
`@@ -50,9 +50,12 @@ private IWindow CreateToolWindow(IDockableUserControl control)`
`50`	`50`	`IWindow toolWindow;`
`51`	`51`	`try`
`52`	`52`	`{`
`53`		`- var info = _vbe.Windows.CreateToolWindow(_addin, _DockableWindowHost.RegisteredProgId, control.Caption, control.ClassId);`
`54`		`- _userControlObject = info.UserControl;`
`55`		`- toolWindow = info.ToolWindow;`
	`53`	`+ using (var windows = _vbe.Windows)`
	`54`	`+ {`
	`55`	`+ var info = windows.CreateToolWindow(_addin, _DockableWindowHost.RegisteredProgId, control.Caption, control.ClassId);`
	`56`	`+ _userControlObject = info.UserControl;`
	`57`	`+ toolWindow = info.ToolWindow;`
	`58`	`+ }`
`56`	`59`	`}`
`57`	`60`	`catch (COMException exception)`
`58`	`61`	`{`
`@@ -120,7 +123,7 @@ public void Dispose()`
`120`	`123`	`~DockableToolwindowPresenter()`
`121`	`124`	`{`
`122`	`125`	`// destructor for tracking purposes only - do not suppress unless`
`123`		`- Debug.WriteLine("DockableToolwindowPresenter finalized.");`
	`126`	`+ Debug.WriteLine($"DockableToolwindowPresenter of type {this.GetType()} finalized.");`
`124`	`127`	`}`
`125`	`128`	`}`
`126`	`129`	`}`
Original file line number	Diff line number	Diff line change
`@@ -142,7 +142,7 @@ protected override bool ProcessKeyPreview(ref Message m)`
`142`	`142`	`protected override void DefWndProc(ref Message m)`
`143`	`143`	`{`
`144`	`144`	`//See the comment in the ctor for why we have to listen for this.`
`145`		`- if (m.Msg == (int) WM.DESTROY)`
	`145`	`+ if (m.Msg == (int) WM.DESTROY && !_released)`
`146`	`146`	`{`
`147`	`147`	`Debug.WriteLine("DockableWindowHost received WM.DESTROY.");`
`148`	`148`	`try`
`@@ -162,10 +162,19 @@ protected override void DefWndProc(ref Message m)`
`162`	`162`
`163`	`163`	`//override`
`164`	`164`
	`165`	`+ private bool _released;`
`165`	`166`	`public void Release()`
`166`	`167`	`{`
	`168`	`+ if (_released)`
	`169`	`+ {`
	`170`	`+ return;`
	`171`	`+ }`
	`172`	`+`
`167`	`173`	`Debug.WriteLine("DockableWindowHost release called.");`
`168`	`174`	`_subClassingWindow.Dispose();`
	`175`	`+ _thisHandle.Free();`
	`176`	`+`
	`177`	`+ _released = true;`
`169`	`178`	`}`
`170`	`179`
`171`	`180`	`protected override void DestroyHandle()`
`@@ -218,6 +227,20 @@ public override int SubClassProc(IntPtr hWnd, IntPtr msg, IntPtr wParam, IntPtr`
`218`	`227`	`}`
`219`	`228`	`return base.SubClassProc(hWnd, msg, wParam, lParam, uIdSubclass, dwRefData);`
`220`	`229`	`}`
	`230`	`+`
	`231`	`+ private bool _disposed;`
	`232`	`+ protected override void Dispose(bool disposing)`
	`233`	`+ {`
	`234`	`+ if (!_disposed && disposing && !_closing)`
	`235`	`+ {`
	`236`	`+ OnCallBackEvent(new SubClassingWindowEventArgs(IntPtr.Zero) { Closing = true });`
	`237`	`+ _closing = true;`
	`238`	`+ }`
	`239`	`+`
	`240`	`+ _disposed = true;`
	`241`	`+`
	`242`	`+ base.Dispose(disposing);`
	`243`	`+ }`
`221`	`244`	`}`
`222`	`245`	`}`
`223`	`246`	`}`
Original file line number	Diff line number	Diff line change
`@@ -54,8 +54,17 @@ public void Release(bool final = false)`
`54`	`54`	`else`
`55`	`55`	`{`
`56`	`56`	`_rcwReferenceCount = Marshal.ReleaseComObject(Target);`
`57`		`- _logger.Trace($"Released COM wrapper of type {this.GetType()} with remaining reference count {_rcwReferenceCount}.");`
	`57`	`+ if (_rcwReferenceCount >= 0)`
	`58`	`+ {`
	`59`	`+ _logger.Trace($"Released COM wrapper of type {this.GetType()} with remaining reference count {_rcwReferenceCount}.");`
	`60`	`+ }`
	`61`	`+ else`
	`62`	`+ {`
	`63`	`+ _logger.Warn($"Released COM wrapper of type {this.GetType()} whose underlying RCW has already been released from outside the SafeComWrapper.");`
	`64`	`+ }`
`58`	`65`	`}`
	`66`	`+`
	`67`	`+`
`59`	`68`	`}`
`60`	`69`	`catch(COMException exception)`
`61`	`70`	`{`
`@@ -73,7 +82,7 @@ public void Release(bool final = false)`
`73`	`82`	`}`
`74`	`83`	`}`
`75`	`84`
`76`		`- public bool HasBeenReleased => _rcwReferenceCount == 0;`
	`85`	`+ public bool HasBeenReleased => _rcwReferenceCount <= 0;`
`77`	`86`
`78`	`87`	`public bool IsWrappingNullReference => Target == null;`
`79`	`88`	`object INullObjectWrapper.Target => Target;`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,8 @@`
`1`	`1`	`using System.Collections;`
`2`	`2`	`using System.Collections.Generic;`
	`3`	`+using System.Diagnostics;`
	`4`	`+using System.Runtime.InteropServices;`
	`5`	`+using Microsoft.Office.Interop.Outlook;`
`3`	`6`	`using Rubberduck.VBEditor.SafeComWrappers.Abstract;`
`4`	`7`	`using VB = Microsoft.Vbe.Interop;`
`5`	`8`
`@@ -40,6 +43,7 @@ public static void ReleaseDockableHosts()`
`40`	`43`	`dynamic host = item.Value;`
`41`	`44`	`host.Release();`
`42`	`45`	`}`
	`46`	`+ _dockableHosts.Clear();`
`43`	`47`	`}`
`44`	`48`
`45`	`49`	`IEnumerator IEnumerable.GetEnumerator()`