From 8c02761bc6631f15d23ab3fcb7fcfb1b97419dfa Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=88=98=E6=99=93=E9=9D=92?= <569132102@qq.com>
Date: Fri, 3 Jul 2020 08:37:15 +0800
Subject: [PATCH 01/10] Fix #100 error 'System.NullReferenceException'

---
 source/Components/AvalonDock/Layout/LayoutContent.cs | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/source/Components/AvalonDock/Layout/LayoutContent.cs b/source/Components/AvalonDock/Layout/LayoutContent.cs
index 18898f5e..dedce6a2 100644
--- a/source/Components/AvalonDock/Layout/LayoutContent.cs
+++ b/source/Components/AvalonDock/Layout/LayoutContent.cs
@@ -179,9 +179,12 @@ public bool IsActive
 				RaisePropertyChanging(nameof(IsActive));
 				var oldValue = _isActive;
 				_isActive = value;
-				if (Root.ActiveContent != this && value) Root.ActiveContent = this;
 				var root = Root;
-				if (root != null && _isActive && root.ActiveContent != this) root.ActiveContent = this;
+				if (root != null)
+				{
+					if (root.ActiveContent != this && value) Root.ActiveContent = this;
+					if (_isActive && root.ActiveContent != this) root.ActiveContent = this;
+				}
 				if (_isActive) IsSelected = true;
 				OnIsActiveChanged(oldValue, value);
 				RaisePropertyChanged(nameof(IsActive));

From 77f60bdced5d8c8df8f3e9ee92eb7de346f0bbbc Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=88=98=E6=99=93=E9=9D=92?= <569132102@qq.com>
Date: Fri, 3 Jul 2020 08:39:47 +0800
Subject: [PATCH 02/10] Delete Surpresse Message in Chinese in
 DockingManager.cs

---
 source/Components/AvalonDock/DockingManager.cs | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/source/Components/AvalonDock/DockingManager.cs b/source/Components/AvalonDock/DockingManager.cs
index 599b655b..4a72db1c 100644
--- a/source/Components/AvalonDock/DockingManager.cs
+++ b/source/Components/AvalonDock/DockingManager.cs
@@ -1723,7 +1723,6 @@ internal void ExecuteCloseAllButThisCommand(LayoutContent contentSelected)
                 Close(contentToClose);
         }
 
-        [SuppressMessage("Style", "IDE0060:删除未使用的参数", Justification = "<挂起>")]
         internal void ExecuteCloseAllCommand(LayoutContent contentSelected)
         {
             foreach (var contentToClose in Layout.Descendents().OfType<LayoutContent>().Where(d => (d.Parent is LayoutDocumentPane || d.Parent is LayoutDocumentFloatingWindow)).ToArray())
@@ -1842,8 +1841,6 @@ private void OnLayoutRootPropertyChanged(object sender, PropertyChangedEventArgs
 
         private static void OnLayoutRootUpdated(object sender, EventArgs e) => CommandManager.InvalidateRequerySuggested();
 
-
-        [SuppressMessage("Style", "IDE0060:删除未使用的参数", Justification = "<挂起>")]
         private void OnLayoutChanging(LayoutRoot newLayout) => LayoutChanging?.Invoke(this, EventArgs.Empty);
 
         private void DockingManager_Loaded(object sender, RoutedEventArgs e)
@@ -2480,7 +2477,6 @@ private void ShowNavigatorWindow()
             _navigatorWindow = null;
         }
 
-        [SuppressMessage("Style", "IDE0056:使用索引运算符", Justification = "<挂起>")]
         private LayoutFloatingWindowControl CreateFloatingWindowForLayoutAnchorableWithoutParent(LayoutAnchorablePane paneModel, bool isContentImmutable)
         {
             if (paneModel.Children.Any(c => !c.CanFloat))

From 827827fe9dcb15c6408d8d2b8c9ce2188d256ea6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=88=98=E6=99=93=E9=9D=92?= <569132102@qq.com>
Date: Fri, 3 Jul 2020 10:18:52 +0800
Subject: [PATCH 03/10] Fix document header text color

---
 .../Components/AvalonDock.Themes.VS2013/Themes/Generic.xaml   | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/source/Components/AvalonDock.Themes.VS2013/Themes/Generic.xaml b/source/Components/AvalonDock.Themes.VS2013/Themes/Generic.xaml
index 8fb1ed23..8d2ea0af 100644
--- a/source/Components/AvalonDock.Themes.VS2013/Themes/Generic.xaml
+++ b/source/Components/AvalonDock.Themes.VS2013/Themes/Generic.xaml
@@ -1348,7 +1348,6 @@
     </Style>
 
     <Style TargetType="{x:Type avalonDockControls:LayoutDocumentTabItem}">
-        <Setter Property="Foreground" Value="{DynamicResource {x:Static reskeys:ResourceKeys.ToolWindowCaptionActiveText}}" />
         <Setter Property="Template">
             <Setter.Value>
                 <ControlTemplate TargetType="{x:Type avalonDockControls:LayoutDocumentTabItem}">
@@ -1371,7 +1370,8 @@
                                     Margin="4,0"
                                     Content="{Binding Model, RelativeSource={RelativeSource TemplatedParent}}"
                                     ContentTemplate="{Binding DocumentHeaderTemplate, Mode=OneWay, RelativeSource={RelativeSource AncestorType={x:Type avalonDock:DockingManager}, Mode=FindAncestor}}"
-                                    ContentTemplateSelector="{Binding DocumentHeaderTemplateSelector, Mode=OneWay, RelativeSource={RelativeSource AncestorType={x:Type avalonDock:DockingManager}, Mode=FindAncestor}}" />
+                                    ContentTemplateSelector="{Binding DocumentHeaderTemplateSelector, Mode=OneWay, RelativeSource={RelativeSource AncestorType={x:Type avalonDock:DockingManager}, Mode=FindAncestor}}"
+                                    TextBlock.Foreground="{Binding Foreground, RelativeSource={RelativeSource Mode=FindAncestor, AncestorType=TabItem}}" />
                                 <!--  Close button should be moved out to the container style  -->
                                 <Button
                                     x:Name="DocumentCloseButton"

From 4b5634d26ce8290e9b82cccf4bdc77172c889495 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=88=98=E6=99=93=E9=9D=92?= <569132102@qq.com>
Date: Fri, 3 Jul 2020 10:43:39 +0800
Subject: [PATCH 04/10] Replace RelayCommand to a WeakReference,Fix some memory
 leaks,but this commit can not fix this Error #171

---
 .../AvalonDock/Commands/IExecuteWithObject.cs |  38 +++
 .../Commands/IExecuteWithObjectAndResult.cs   |  20 ++
 .../AvalonDock/Commands/RelayCommand.cs       | 252 ++++++++++++----
 .../AvalonDock/Commands/WeakAction.cs         | 284 ++++++++++++++++++
 .../AvalonDock/Commands/WeakActionGeneric.cs  | 177 +++++++++++
 .../AvalonDock/Commands/WeakFunc.cs           | 258 ++++++++++++++++
 .../AvalonDock/Commands/WeakFuncGeneric.cs    | 189 ++++++++++++
 .../LayoutAnchorableFloatingWindowControl.cs  |   4 +-
 .../Controls/LayoutAnchorableItem.cs          |   6 +-
 .../LayoutDocumentFloatingWindowControl.cs    |   4 +-
 .../AvalonDock/Controls/LayoutItem.cs         |  20 +-
 11 files changed, 1175 insertions(+), 77 deletions(-)
 create mode 100644 source/Components/AvalonDock/Commands/IExecuteWithObject.cs
 create mode 100644 source/Components/AvalonDock/Commands/IExecuteWithObjectAndResult.cs
 create mode 100644 source/Components/AvalonDock/Commands/WeakAction.cs
 create mode 100644 source/Components/AvalonDock/Commands/WeakActionGeneric.cs
 create mode 100644 source/Components/AvalonDock/Commands/WeakFunc.cs
 create mode 100644 source/Components/AvalonDock/Commands/WeakFuncGeneric.cs

diff --git a/source/Components/AvalonDock/Commands/IExecuteWithObject.cs b/source/Components/AvalonDock/Commands/IExecuteWithObject.cs
new file mode 100644
index 00000000..3a081906
--- /dev/null
+++ b/source/Components/AvalonDock/Commands/IExecuteWithObject.cs
@@ -0,0 +1,38 @@
+namespace AvalonDock.Commands
+{
+    /// <summary>
+    /// Interface IExecuteWithObject
+    /// </summary>
+    internal interface IExecuteWithObject
+    {
+        #region Public Properties
+
+        /// <summary>
+        /// The target of the WeakAction.
+        /// </summary>
+        /// <value>The target.</value>
+        object Target
+        {
+            get;
+        }
+
+        #endregion Public Properties
+
+        #region Public Methods
+
+        /// <summary>
+        /// Executes an action.
+        /// </summary>
+        /// <param name="parameter">A parameter passed as an object,
+        /// to be casted to the appropriate type.</param>
+        void ExecuteWithObject(object parameter);
+
+        /// <summary>
+        /// Deletes all references, which notifies the cleanup method
+        /// that this entry must be deleted.
+        /// </summary>
+        void MarkForDeletion();
+
+        #endregion Public Methods
+    }
+}
\ No newline at end of file
diff --git a/source/Components/AvalonDock/Commands/IExecuteWithObjectAndResult.cs b/source/Components/AvalonDock/Commands/IExecuteWithObjectAndResult.cs
new file mode 100644
index 00000000..5590b270
--- /dev/null
+++ b/source/Components/AvalonDock/Commands/IExecuteWithObjectAndResult.cs
@@ -0,0 +1,20 @@
+namespace AvalonDock.Commands
+{
+    /// <summary>
+    /// Interface IExecuteWithObjectAndResult
+    /// </summary>
+    internal interface IExecuteWithObjectAndResult
+    {
+        #region Public Methods
+
+        /// <summary>
+        /// Executes a Func and returns the result.
+        /// </summary>
+        /// <param name="parameter">A parameter passed as an object,
+        /// to be casted to the appropriate type.</param>
+        /// <returns>The result of the operation.</returns>
+        object ExecuteWithObject(object parameter);
+
+        #endregion Public Methods
+    }
+}
\ No newline at end of file
diff --git a/source/Components/AvalonDock/Commands/RelayCommand.cs b/source/Components/AvalonDock/Commands/RelayCommand.cs
index f63c59c9..78a64e55 100644
--- a/source/Components/AvalonDock/Commands/RelayCommand.cs
+++ b/source/Components/AvalonDock/Commands/RelayCommand.cs
@@ -8,67 +8,199 @@ This program is provided to you under the terms of the Microsoft Public
  ************************************************************************/
 
 using System;
+using System.Diagnostics.CodeAnalysis;
 using System.Windows.Input;
 
 namespace AvalonDock.Commands
 {
-	/// <inheritdoc />
-	/// <summary>
-	/// A command whose sole purpose is to  relay its functionality to other
-	/// objects by invoking delegates.
-	/// The default return value for the <see cref="ICommand.CanExecute"/> method is <c>true</c>.
-	/// 
-	/// Source: <see href="http://www.codeproject.com/Articles/31837/Creating-an-Internationalized-Wizard-in-WPF"/>
-	/// </summary>
-	/// <seealso cref="ICommand"/>
-	internal class RelayCommand : ICommand
-	{
-		#region fields
-		private readonly Action<object> _execute;
-		private readonly Predicate<object> _canExecute;
-		#endregion fields
-
-		#region Constructors
-		
-		/// <summary>
-		/// Class constructor from <see cref="Action{T}"/> parameter.
-		/// </summary>
-		/// <param name="execute">The action to execute when the command is activated.</param>
-		public RelayCommand(Action<object> execute) : this(execute, null)
-		{
-		}
-
-		/// <summary>
-		/// Class constructor from <see cref="Action{T}"/> parameter plus
-		/// canExecute predicate to decide whether command should currently
-		/// be available or not.
-		/// </summary>
-		/// <param name="execute">The action to execute when the command is activated.</param>
-		/// <param name="canExecute">The predicate to determine if this command can be executed.</param>
-		public RelayCommand(Action<object> execute, Predicate<object> canExecute)
-		{
-			_execute = execute ?? throw new ArgumentNullException(nameof(execute));
-			_canExecute = canExecute;
-		}
-
-		#endregion Constructors
-
-		#region ICommand Members
-		
-		/// <inheritdoc />
-		public event EventHandler CanExecuteChanged
-		{
-			add => CommandManager.RequerySuggested += value;
-			remove => CommandManager.RequerySuggested -= value;
-		}
-
-		/// <inheritdoc />
-		/// <remarks>Returns <c>true</c>, if no predicate is set for the check.</remarks>
-		public bool CanExecute(object parameter) => _canExecute?.Invoke(parameter) ?? true;
-
-		/// <inheritdoc />
-		public void Execute(object parameter) => _execute(parameter);
-
-		#endregion ICommand Members
-	}
-}
+    /// <inheritdoc />
+    /// <summary>
+    /// A command whose sole purpose is to  relay its functionality to other
+    /// objects by invoking delegates.
+    /// The default return value for the <see cref="ICommand.CanExecute"/> method is <c>true</c>.
+    ///
+    /// Source: <see href="http://www.codeproject.com/Articles/31837/Creating-an-Internationalized-Wizard-in-WPF"/>
+    /// </summary>
+    /// <seealso cref="ICommand"/>
+    /// <summary>
+    /// Class RelayCommand.
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    /// <seealso cref="System.Windows.Input.ICommand" />
+    internal class RelayCommand<T> : ICommand
+    {
+        #region Private Fields
+
+        /// <summary>
+        /// The can execute
+        /// </summary>
+        private readonly WeakFunc<T, bool> _canExecute;
+
+        /// <summary>
+        /// The execute
+        /// </summary>
+        private readonly WeakAction<T> _execute;
+
+        #endregion Private Fields
+
+        #region Public Constructors
+
+        /// <summary>
+        /// Initializes a new instance of the RelayCommand class that
+        /// can always execute.
+        /// </summary>
+        /// <param name="execute">The execution logic. IMPORTANT: Note that closures are not supported at the moment
+        /// due to the use of WeakActions (see http://stackoverflow.com/questions/25730530/).</param>
+        /// <exception cref="ArgumentNullException">If the execute argument is null.</exception>
+        public RelayCommand(Action<T> execute)
+            : this(execute, null)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the RelayCommand class.
+        /// </summary>
+        /// <param name="execute">The execution logic. IMPORTANT: Note that closures are not supported at the moment
+        /// due to the use of WeakActions (see http://stackoverflow.com/questions/25730530/).</param>
+        /// <param name="canExecute">The execution status logic. IMPORTANT: Note that closures are not supported at the moment
+        /// due to the use of WeakActions (see http://stackoverflow.com/questions/25730530/).</param>
+        /// <exception cref="ArgumentNullException">If the execute argument is null.</exception>
+        public RelayCommand(Action<T> execute, Func<T, bool> canExecute)
+        {
+            if (execute == null)
+            {
+                throw new ArgumentNullException("execute");
+            }
+
+            _execute = new WeakAction<T>(execute);
+
+            if (canExecute != null)
+            {
+                _canExecute = new WeakFunc<T, bool>(canExecute);
+            }
+        }
+
+        #endregion Public Constructors
+
+        #region Public Events
+
+        /// <summary>
+        /// Occurs when changes occur that affect whether the command should execute.
+        /// </summary>
+        public event EventHandler CanExecuteChanged
+        {
+            add
+            {
+                if (_canExecute != null)
+                {
+                    CommandManager.RequerySuggested += value;
+                }
+            }
+
+            remove
+            {
+                if (_canExecute != null)
+                {
+                    CommandManager.RequerySuggested -= value;
+                }
+            }
+        }
+
+        #endregion Public Events
+
+        #region Public Methods
+
+        /// <summary>
+        /// Defines the method that determines whether the command can execute in its current state.
+        /// </summary>
+        /// <param name="parameter">Data used by the command. If the command does not require data
+        /// to be passed, this object can be set to a null reference</param>
+        /// <returns>true if this command can be executed; otherwise, false.</returns>
+        public bool CanExecute(object parameter)
+        {
+            if (_canExecute == null)
+            {
+                return true;
+            }
+
+            if (_canExecute.IsStatic || _canExecute.IsAlive)
+            {
+                if (parameter == null && typeof(T).IsValueType)
+                {
+                    return _canExecute.Execute(default);
+                }
+
+                if (parameter == null || parameter is T)
+                {
+                    return (_canExecute.Execute((T)parameter));
+                }
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Defines the method to be called when the command is invoked.
+        /// </summary>
+        /// <param name="parameter">Data used by the command. If the command does not require data
+        /// to be passed, this object can be set to a null reference</param>
+        public virtual void Execute(object parameter)
+        {
+            var val = parameter;
+
+            if (parameter != null
+                && parameter.GetType() != typeof(T))
+            {
+                if (typeof(T).IsEnum)
+                {
+                    val = Enum.Parse(typeof(T), parameter.ToString());
+                }
+                else if (parameter is IConvertible)
+                {
+                    val = Convert.ChangeType(parameter, typeof(T), null);
+                }
+            }
+
+            if (CanExecute(val)
+                && _execute != null
+                && (_execute.IsStatic || _execute.IsAlive))
+            {
+                if (val == null)
+                {
+                    if (typeof(T).IsValueType)
+                    {
+                        _execute.Execute(default);
+                    }
+                    else
+                    {
+                        // ReSharper disable ExpressionIsAlwaysNull
+                        _execute.Execute((T)val);
+                        // ReSharper restore ExpressionIsAlwaysNull
+                    }
+                }
+                else
+                {
+                    _execute.Execute((T)val);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Raises the <see cref="CanExecuteChanged" /> event.
+        /// </summary>
+        [SuppressMessage(
+            "Microsoft.Performance",
+            "CA1822:MarkMembersAsStatic",
+            Justification = "The this keyword is used in the Silverlight version")]
+        [SuppressMessage(
+            "Microsoft.Design",
+            "CA1030:UseEventsWhereAppropriate",
+            Justification = "This cannot be an event")]
+        public void RaiseCanExecuteChanged()
+        {
+            CommandManager.InvalidateRequerySuggested();
+        }
+
+        #endregion Public Methods
+    }
+}
\ No newline at end of file
diff --git a/source/Components/AvalonDock/Commands/WeakAction.cs b/source/Components/AvalonDock/Commands/WeakAction.cs
new file mode 100644
index 00000000..de8ccca7
--- /dev/null
+++ b/source/Components/AvalonDock/Commands/WeakAction.cs
@@ -0,0 +1,284 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using System.Reflection;
+
+namespace AvalonDock.Commands
+{
+    /// <summary>
+    /// Class WeakAction.
+    /// </summary>
+    internal class WeakAction
+    {
+        #region Private Fields
+
+        /// <summary>
+        /// The static action
+        /// </summary>
+        private Action _staticAction;
+
+        #endregion Private Fields
+
+        #region Public Constructors
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="WeakAction" /> class.
+        /// </summary>
+        /// <param name="action">The action that will be associated to this instance.</param>
+        public WeakAction(Action action)
+            : this(action?.Target, action)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="WeakAction" /> class.
+        /// </summary>
+        /// <param name="target">The action's owner.</param>
+        /// <param name="action">The action that will be associated to this instance.</param>
+        [SuppressMessage(
+            "Microsoft.Design",
+            "CA1062:Validate arguments of public methods",
+            MessageId = "1",
+            Justification = "Method should fail with an exception if action is null.")]
+        public WeakAction(object target, Action action)
+        {
+            if (action.Method.IsStatic)
+            {
+                _staticAction = action;
+
+                if (target != null)
+                {
+                    // Keep a reference to the target to control the
+                    // WeakAction's lifetime.
+                    Reference = new WeakReference(target);
+                }
+
+                return;
+            }
+            Method = action.Method;
+            ActionReference = new WeakReference(action.Target);
+            Reference = new WeakReference(target);
+        }
+
+        #endregion Public Constructors
+
+        #region Protected Constructors
+
+        /// <summary>
+        /// Initializes an empty instance of the <see cref="WeakAction" /> class.
+        /// </summary>
+        protected WeakAction()
+        {
+        }
+
+        #endregion Protected Constructors
+
+        #region Public Properties
+
+        /// <summary>
+        /// Gets a value indicating whether the Action's owner is still alive, or if it was collected
+        /// by the Garbage Collector already.
+        /// </summary>
+        /// <value><c>true</c> 如果 this instance is alive; 否则, <c>false</c>.</value>
+        public virtual bool IsAlive
+        {
+            get
+            {
+                if (_staticAction == null
+                    && Reference == null)
+                {
+                    return false;
+                }
+
+                if (_staticAction != null)
+                {
+                    if (Reference != null)
+                    {
+                        return Reference.IsAlive;
+                    }
+
+                    return true;
+                }
+
+                return Reference.IsAlive;
+            }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether the WeakAction is static or not.
+        /// </summary>
+        /// <value><c>true</c> 如果 this instance is static; 否则, <c>false</c>.</value>
+        public bool IsStatic
+        {
+            get
+            {
+#if SILVERLIGHT
+                return (_action != null && _action.Target == null)
+                    || _staticAction != null;
+#else
+                return _staticAction != null;
+#endif
+            }
+        }
+
+        /// <summary>
+        /// Gets the name of the method that this WeakAction represents.
+        /// </summary>
+        /// <value>The name of the method.</value>
+        public virtual string MethodName
+        {
+            get
+            {
+                if (_staticAction != null)
+                {
+                    return _staticAction.Method.Name;
+                }
+                return Method.Name;
+            }
+        }
+
+        /// <summary>
+        /// Gets the Action's owner. This object is stored as a
+        /// <see cref="WeakReference" />.
+        /// </summary>
+        /// <value>The target.</value>
+        public object Target
+        {
+            get
+            {
+                if (Reference == null)
+                {
+                    return null;
+                }
+
+                return Reference.Target;
+            }
+        }
+
+        #endregion Public Properties
+
+        #region Protected Properties
+
+        /// <summary>
+        /// Gets or sets a WeakReference to this WeakAction's action's target.
+        /// This is not necessarily the same as
+        /// <see cref="Reference" />, for example if the
+        /// method is anonymous.
+        /// </summary>
+        /// <value>The action reference.</value>
+        protected WeakReference ActionReference
+        {
+            get;
+            set;
+        }
+
+        /// <summary>
+        /// The target of the weak reference.
+        /// </summary>
+        /// <value>The action target.</value>
+        protected object ActionTarget
+        {
+            get
+            {
+                if (ActionReference == null)
+                {
+                    return null;
+                }
+
+                return ActionReference.Target;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the <see cref="MethodInfo" /> corresponding to this WeakAction's
+        /// method passed in the constructor.
+        /// </summary>
+        /// <value>The method.</value>
+        protected MethodInfo Method
+        {
+            get;
+            set;
+        }
+
+        /// <summary>
+        /// Gets or sets a WeakReference to the target passed when constructing
+        /// the WeakAction. This is not necessarily the same as
+        /// <see cref="ActionReference" />, for example if the
+        /// method is anonymous.
+        /// </summary>
+        /// <value>The reference.</value>
+        protected WeakReference Reference
+        {
+            get;
+            set;
+        }
+
+        #endregion Protected Properties
+
+        #region Public Methods
+
+        /// <summary>
+        /// Executes the action. This only happens if the action's owner
+        /// is still alive.
+        /// </summary>
+        public void Execute(object param = null)
+        {
+            if (_staticAction != null)
+            {
+                _staticAction();
+                return;
+            }
+
+            var actionTarget = ActionTarget;
+
+            if (IsAlive)
+            {
+                if (Method != null
+                    && ActionReference != null
+                    && actionTarget != null)
+                {
+                    var paras = Method.GetParameters().Count();
+                    try
+                    {
+                        if (paras > 0)
+                        {
+                            Method.Invoke(actionTarget, new object[] { param });
+                        }
+                        else
+                        {
+                            Method.Invoke(actionTarget, null);
+                        }
+                    }
+                    catch { }
+                    // ReSharper disable RedundantJumpStatement
+                    return;
+                    // ReSharper restore RedundantJumpStatement
+                }
+
+#if SILVERLIGHT
+                if (_action != null)
+                {
+                    _action();
+                }
+#endif
+            }
+        }
+
+        /// <summary>
+        /// Sets the reference that this instance stores to null.
+        /// </summary>
+        public void MarkForDeletion()
+        {
+            Reference = null;
+            ActionReference = null;
+            Method = null;
+            _staticAction = null;
+
+#if SILVERLIGHT
+            _action = null;
+#endif
+        }
+
+        #endregion Public Methods
+    }
+}
\ No newline at end of file
diff --git a/source/Components/AvalonDock/Commands/WeakActionGeneric.cs b/source/Components/AvalonDock/Commands/WeakActionGeneric.cs
new file mode 100644
index 00000000..f80574d8
--- /dev/null
+++ b/source/Components/AvalonDock/Commands/WeakActionGeneric.cs
@@ -0,0 +1,177 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+
+namespace AvalonDock.Commands
+{
+    internal class WeakAction<T> : WeakAction, IExecuteWithObject
+    {
+        #region Private Fields
+
+        private Action<T> _staticAction;
+
+        #endregion Private Fields
+
+        #region Public Constructors
+
+        /// <summary>
+        /// Initializes a new instance of the WeakAction class.
+        /// </summary>
+        /// <param name="action">The action that will be associated to this instance.</param>
+        public WeakAction(Action<T> action)
+            : this(action?.Target, action)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the WeakAction class.
+        /// </summary>
+        /// <param name="target">The action's owner.</param>
+        /// <param name="action">The action that will be associated to this instance.</param>
+        [SuppressMessage(
+            "Microsoft.Design",
+            "CA1062:Validate arguments of public methods",
+            MessageId = "1",
+            Justification = "Method should fail with an exception if action is null.")]
+        public WeakAction(object target, Action<T> action)
+        {
+            if (action.Method.IsStatic)
+            {
+                _staticAction = action;
+
+                if (target != null)
+                {
+                    // Keep a reference to the target to control the
+                    // WeakAction's lifetime.
+                    Reference = new WeakReference(target);
+                }
+
+                return;
+            }
+            Method = action.Method;
+            ActionReference = new WeakReference(action.Target);
+            Reference = new WeakReference(target);
+        }
+
+        #endregion Public Constructors
+
+        #region Public Properties
+
+        /// <summary>
+        /// Gets a value indicating whether the Action's owner is still alive, or if it was collected
+        /// by the Garbage Collector already.
+        /// </summary>
+        public override bool IsAlive
+        {
+            get
+            {
+                if (_staticAction == null
+                    && Reference == null)
+                {
+                    return false;
+                }
+
+                if (_staticAction != null)
+                {
+                    if (Reference != null)
+                    {
+                        return Reference.IsAlive;
+                    }
+
+                    return true;
+                }
+
+                return Reference.IsAlive;
+            }
+        }
+
+        /// <summary>
+        /// Gets the name of the method that this WeakAction represents.
+        /// </summary>
+        public override string MethodName
+        {
+            get
+            {
+                if (_staticAction != null)
+                {
+                    return _staticAction.Method.Name;
+                }
+                return Method.Name;
+            }
+        }
+
+        #endregion Public Properties
+
+        #region Public Methods
+
+        /// <summary>
+        /// Executes the action. This only happens if the action's owner
+        /// is still alive. The action's parameter is set to default(T).
+        /// </summary>
+        public void Execute()
+        {
+            Execute(default);
+        }
+
+        /// <summary>
+        /// Executes the action. This only happens if the action's owner
+        /// is still alive.
+        /// </summary>
+        /// <param name="parameter">A parameter to be passed to the action.</param>
+        public void Execute(T parameter)
+        {
+            if (_staticAction != null)
+            {
+                _staticAction(parameter);
+                return;
+            }
+
+            var actionTarget = ActionTarget;
+
+            if (IsAlive)
+            {
+                if (Method != null
+                    && ActionReference != null
+                    && actionTarget != null)
+                {
+                    try
+                    {
+                        Method.Invoke(
+                        actionTarget,
+                        new object[]
+                        {
+                            parameter
+                        });
+                    }
+                    catch { }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Executes the action with a parameter of type object. This parameter
+        /// will be casted to T. This method implements <see cref="IExecuteWithObject.ExecuteWithObject" />
+        /// and can be useful if you store multiple WeakAction{T} instances but don't know in advance
+        /// what type T represents.
+        /// </summary>
+        /// <param name="parameter">The parameter that will be passed to the action after
+        /// being casted to T.</param>
+        public void ExecuteWithObject(object parameter)
+        {
+            var parameterCasted = (T)parameter;
+            Execute(parameterCasted);
+        }
+
+        /// <summary>
+        /// Sets all the actions that this WeakAction contains to null,
+        /// which is a signal for containing objects that this WeakAction
+        /// should be deleted.
+        /// </summary>
+        public new void MarkForDeletion()
+        {
+            _staticAction = null;
+            base.MarkForDeletion();
+        }
+
+        #endregion Public Methods
+    }
+}
\ No newline at end of file
diff --git a/source/Components/AvalonDock/Commands/WeakFunc.cs b/source/Components/AvalonDock/Commands/WeakFunc.cs
new file mode 100644
index 00000000..188b09ef
--- /dev/null
+++ b/source/Components/AvalonDock/Commands/WeakFunc.cs
@@ -0,0 +1,258 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Reflection;
+
+namespace AvalonDock.Commands
+{
+    /// <summary>
+    /// Class WeakFunc.
+    /// </summary>
+    /// <typeparam name="TResult">The type of the t result.</typeparam>
+    internal class WeakFunc<TResult>
+    {
+        #region Private Fields
+
+        /// <summary>
+        /// The static function
+        /// </summary>
+        private Func<TResult> _staticFunc;
+
+        #endregion Private Fields
+
+        #region Public Constructors
+
+        /// <summary>
+        /// Initializes a new instance of the WeakFunc class.
+        /// </summary>
+        /// <param name="func">The Func that will be associated to this instance.</param>
+        public WeakFunc(Func<TResult> func)
+            : this(func?.Target, func)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the WeakFunc class.
+        /// </summary>
+        /// <param name="target">The Func's owner.</param>
+        /// <param name="func">The Func that will be associated to this instance.</param>
+        [SuppressMessage(
+            "Microsoft.Design",
+            "CA1062:Validate arguments of public methods",
+            MessageId = "1",
+            Justification = "Method should fail with an exception if func is null.")]
+        public WeakFunc(object target, Func<TResult> func)
+        {
+            if (func.Method.IsStatic)
+            {
+                _staticFunc = func;
+
+                if (target != null)
+                {
+                    // Keep a reference to the target to control the
+                    // WeakAction's lifetime.
+                    Reference = new WeakReference(target);
+                }
+
+                return;
+            }
+            Method = func.Method;
+            FuncReference = new WeakReference(func.Target);
+            Reference = new WeakReference(target);
+        }
+
+        #endregion Public Constructors
+
+        #region Protected Constructors
+
+        /// <summary>
+        /// Initializes an empty instance of the WeakFunc class.
+        /// </summary>
+        protected WeakFunc()
+        {
+        }
+
+        #endregion Protected Constructors
+
+        #region Public Properties
+
+        /// <summary>
+        /// Gets a value indicating whether the Func's owner is still alive, or if it was collected
+        /// by the Garbage Collector already.
+        /// </summary>
+        /// <value><c>true</c> 如果 this instance is alive; 否则, <c>false</c>.</value>
+        public virtual bool IsAlive
+        {
+            get
+            {
+                if (_staticFunc == null
+                    && Reference == null)
+                {
+                    return false;
+                }
+
+                if (_staticFunc != null)
+                {
+                    if (Reference != null)
+                    {
+                        return Reference.IsAlive;
+                    }
+
+                    return true;
+                }
+
+                return Reference.IsAlive;
+            }
+        }
+
+        /// <summary>
+        /// Get a value indicating whether the WeakFunc is static or not.
+        /// </summary>
+        /// <value><c>true</c> 如果 this instance is static; 否则, <c>false</c>.</value>
+        public bool IsStatic
+        {
+            get
+            {
+                return _staticFunc != null;
+            }
+        }
+
+        /// <summary>
+        /// Gets the name of the method that this WeakFunc represents.
+        /// </summary>
+        /// <value>The name of the method.</value>
+        public virtual string MethodName
+        {
+            get
+            {
+                if (_staticFunc != null)
+                {
+                    return _staticFunc.Method.Name;
+                }
+                return Method.Name;
+            }
+        }
+
+        /// <summary>
+        /// Gets the Func's owner. This object is stored as a
+        /// <see cref="WeakReference" />.
+        /// </summary>
+        /// <value>The target.</value>
+        public object Target
+        {
+            get
+            {
+                if (Reference == null)
+                {
+                    return null;
+                }
+
+                return Reference.Target;
+            }
+        }
+
+        #endregion Public Properties
+
+        #region Protected Properties
+
+        /// <summary>
+        /// Gets or sets a WeakReference to this WeakFunc's action's target.
+        /// This is not necessarily the same as
+        /// <see cref="Reference" />, for example if the
+        /// method is anonymous.
+        /// </summary>
+        /// <value>The function reference.</value>
+        protected WeakReference FuncReference
+        {
+            get;
+            set;
+        }
+
+        /// <summary>
+        /// Gets the owner of the Func that was passed as parameter.
+        /// This is not necessarily the same as
+        /// <see cref="Target" />, for example if the
+        /// method is anonymous.
+        /// </summary>
+        /// <value>The function target.</value>
+        protected object FuncTarget
+        {
+            get
+            {
+                if (FuncReference == null)
+                {
+                    return null;
+                }
+
+                return FuncReference.Target;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the <see cref="MethodInfo" /> corresponding to this WeakFunc's
+        /// method passed in the constructor.
+        /// </summary>
+        /// <value>The method.</value>
+        protected MethodInfo Method
+        {
+            get;
+            set;
+        }
+
+        /// <summary>
+        /// Gets or sets a WeakReference to the target passed when constructing
+        /// the WeakFunc. This is not necessarily the same as
+        /// <see cref="FuncReference" />, for example if the
+        /// method is anonymous.
+        /// </summary>
+        /// <value>The reference.</value>
+        protected WeakReference Reference
+        {
+            get;
+            set;
+        }
+
+        #endregion Protected Properties
+
+        #region Public Methods
+
+        /// <summary>
+        /// Executes the action. This only happens if the Func's owner
+        /// is still alive.
+        /// </summary>
+        /// <returns>The result of the Func stored as reference.</returns>
+        public TResult Execute()
+        {
+            if (_staticFunc != null)
+            {
+                return _staticFunc();
+            }
+
+            var funcTarget = FuncTarget;
+
+            if (IsAlive)
+            {
+                if (Method != null
+                    && FuncReference != null
+                    && funcTarget != null)
+                {
+                    return (TResult)Method.Invoke(funcTarget, null);
+                }
+            }
+
+            return default;
+        }
+
+        /// <summary>
+        /// Sets the reference that this instance stores to null.
+        /// </summary>
+        public void MarkForDeletion()
+        {
+            Reference = null;
+            FuncReference = null;
+            Method = null;
+            _staticFunc = null;
+        }
+
+        #endregion Public Methods
+    }
+}
\ No newline at end of file
diff --git a/source/Components/AvalonDock/Commands/WeakFuncGeneric.cs b/source/Components/AvalonDock/Commands/WeakFuncGeneric.cs
new file mode 100644
index 00000000..0bc9e055
--- /dev/null
+++ b/source/Components/AvalonDock/Commands/WeakFuncGeneric.cs
@@ -0,0 +1,189 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+
+namespace AvalonDock.Commands
+{
+    /// <summary>
+    /// Class WeakFunc.
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    /// <typeparam name="TResult">The type of the t result.</typeparam>
+    /// <seealso cref="AvalonDock.Commands.WeakFunc{TResult}" />
+    /// <seealso cref="AvalonDock.Commands.IExecuteWithObjectAndResult" />
+    internal class WeakFunc<T, TResult> : WeakFunc<TResult>, IExecuteWithObjectAndResult
+    {
+        #region Private Fields
+
+        /// <summary>
+        /// The static function
+        /// </summary>
+        private Func<T, TResult> _staticFunc;
+
+        #endregion Private Fields
+
+        #region Public Constructors
+
+        /// <summary>
+        /// Initializes a new instance of the WeakFunc class.
+        /// </summary>
+        /// <param name="func">The Func that will be associated to this instance.</param>
+        public WeakFunc(Func<T, TResult> func)
+            : this(func?.Target, func)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the WeakFunc class.
+        /// </summary>
+        /// <param name="target">The Func's owner.</param>
+        /// <param name="func">The Func that will be associated to this instance.</param>
+        [SuppressMessage(
+            "Microsoft.Design",
+            "CA1062:Validate arguments of public methods",
+            MessageId = "1",
+            Justification = "Method should fail with an exception if func is null.")]
+        public WeakFunc(object target, Func<T, TResult> func)
+        {
+            if (func.Method.IsStatic)
+            {
+                _staticFunc = func;
+
+                if (target != null)
+                {
+                    // Keep a reference to the target to control the
+                    // WeakAction's lifetime.
+                    Reference = new WeakReference(target);
+                }
+
+                return;
+            }
+            Method = func.Method;
+            FuncReference = new WeakReference(func.Target);
+            Reference = new WeakReference(target);
+        }
+
+        #endregion Public Constructors
+
+        #region Public Properties
+
+        /// <summary>
+        /// Gets a value indicating whether the Func's owner is still alive, or if it was collected
+        /// by the Garbage Collector already.
+        /// </summary>
+        /// <value><c>true</c> 如果 this instance is alive; 否则, <c>false</c>.</value>
+        public override bool IsAlive
+        {
+            get
+            {
+                if (_staticFunc == null
+                    && Reference == null)
+                {
+                    return false;
+                }
+
+                if (_staticFunc != null)
+                {
+                    if (Reference != null)
+                    {
+                        return Reference.IsAlive;
+                    }
+
+                    return true;
+                }
+
+                return Reference.IsAlive;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the name of the method that this WeakFunc represents.
+        /// </summary>
+        /// <value>The name of the method.</value>
+        public override string MethodName
+        {
+            get
+            {
+                if (_staticFunc != null)
+                {
+                    return _staticFunc.Method.Name;
+                }
+                return Method.Name;
+            }
+        }
+
+        #endregion Public Properties
+
+        #region Public Methods
+
+        /// <summary>
+        /// Executes the Func. This only happens if the Func's owner
+        /// is still alive. The Func's parameter is set to default(T).
+        /// </summary>
+        /// <returns>The result of the Func stored as reference.</returns>
+        public new TResult Execute()
+        {
+            return Execute(default);
+        }
+
+        /// <summary>
+        /// Executes the Func. This only happens if the Func's owner
+        /// is still alive.
+        /// </summary>
+        /// <param name="parameter">A parameter to be passed to the action.</param>
+        /// <returns>The result of the Func stored as reference.</returns>
+        public TResult Execute(T parameter)
+        {
+            if (_staticFunc != null)
+            {
+                return _staticFunc(parameter);
+            }
+
+            var funcTarget = FuncTarget;
+
+            if (IsAlive)
+            {
+                if (Method != null
+                    && FuncReference != null
+                    && funcTarget != null)
+                {
+                    return (TResult)Method.Invoke(
+                        funcTarget,
+                        new object[]
+                        {
+                            parameter
+                        });
+                }
+            }
+
+            return default;
+        }
+
+        /// <summary>
+        /// Executes the Func with a parameter of type object. This parameter
+        /// will be casted to T. This method implements <see cref="IExecuteWithObject.ExecuteWithObject" />
+        /// and can be useful if you store multiple WeakFunc{T} instances but don't know in advance
+        /// what type T represents.
+        /// </summary>
+        /// <param name="parameter">The parameter that will be passed to the Func after
+        /// being casted to T.</param>
+        /// <returns>The result of the execution as object, to be casted to T.</returns>
+        public object ExecuteWithObject(object parameter)
+        {
+            var parameterCasted = (T)parameter;
+            return Execute(parameterCasted);
+        }
+
+        /// <summary>
+        /// Sets all the funcs that this WeakFunc contains to null,
+        /// which is a signal for containing objects that this WeakFunc
+        /// should be deleted.
+        /// </summary>
+        public new void MarkForDeletion()
+        {
+            _staticFunc = null;
+            base.MarkForDeletion();
+        }
+
+        #endregion Public Methods
+    }
+}
\ No newline at end of file
diff --git a/source/Components/AvalonDock/Controls/LayoutAnchorableFloatingWindowControl.cs b/source/Components/AvalonDock/Controls/LayoutAnchorableFloatingWindowControl.cs
index 5c6947b9..e8235e13 100644
--- a/source/Components/AvalonDock/Controls/LayoutAnchorableFloatingWindowControl.cs
+++ b/source/Components/AvalonDock/Controls/LayoutAnchorableFloatingWindowControl.cs
@@ -47,8 +47,8 @@ internal LayoutAnchorableFloatingWindowControl(LayoutAnchorableFloatingWindow mo
 		   : base(model, isContentImmutable)
 		{
 			_model = model;
-			HideWindowCommand = new RelayCommand((p) => OnExecuteHideWindowCommand(p), (p) => CanExecuteHideWindowCommand(p));
-			CloseWindowCommand = new RelayCommand((p) => OnExecuteCloseWindowCommand(p), (p) => CanExecuteCloseWindowCommand(p));
+			HideWindowCommand = new RelayCommand<object>((p) => OnExecuteHideWindowCommand(p), (p) => CanExecuteHideWindowCommand(p));
+			CloseWindowCommand = new RelayCommand<object>((p) => OnExecuteCloseWindowCommand(p), (p) => CanExecuteCloseWindowCommand(p));
 			Activated += LayoutAnchorableFloatingWindowControl_Activated;
 			UpdateThemeResources();
 			MinWidth = _model.RootPanel.CalculatedDockMinWidth();
diff --git a/source/Components/AvalonDock/Controls/LayoutAnchorableItem.cs b/source/Components/AvalonDock/Controls/LayoutAnchorableItem.cs
index e281aba9..d1a1c8d3 100644
--- a/source/Components/AvalonDock/Controls/LayoutAnchorableItem.cs
+++ b/source/Components/AvalonDock/Controls/LayoutAnchorableItem.cs
@@ -242,9 +242,9 @@ protected override void Close()
         /// <inheritdoc />
         protected override void InitDefaultCommands()
         {
-            _defaultHideCommand = new RelayCommand(ExecuteHideCommand, CanExecuteHideCommand);
-            _defaultAutoHideCommand = new RelayCommand(ExecuteAutoHideCommand, CanExecuteAutoHideCommand);
-            _defaultDockCommand = new RelayCommand(ExecuteDockCommand, CanExecuteDockCommand);
+            _defaultHideCommand = new RelayCommand<object>(ExecuteHideCommand, CanExecuteHideCommand);
+            _defaultAutoHideCommand = new RelayCommand<object>(ExecuteAutoHideCommand, CanExecuteAutoHideCommand);
+            _defaultDockCommand = new RelayCommand<object>(ExecuteDockCommand, CanExecuteDockCommand);
             base.InitDefaultCommands();
         }
 
diff --git a/source/Components/AvalonDock/Controls/LayoutDocumentFloatingWindowControl.cs b/source/Components/AvalonDock/Controls/LayoutDocumentFloatingWindowControl.cs
index 40b488e6..faebff5f 100644
--- a/source/Components/AvalonDock/Controls/LayoutDocumentFloatingWindowControl.cs
+++ b/source/Components/AvalonDock/Controls/LayoutDocumentFloatingWindowControl.cs
@@ -47,8 +47,8 @@ internal LayoutDocumentFloatingWindowControl(LayoutDocumentFloatingWindow model,
 			: base(model, isContentImmutable)
 		{
 			_model = model;
-			HideWindowCommand = new RelayCommand(OnExecuteHideWindowCommand, CanExecuteHideWindowCommand);
-			CloseWindowCommand = new RelayCommand(OnExecuteCloseWindowCommand, CanExecuteCloseWindowCommand);
+			HideWindowCommand = new RelayCommand<object>(OnExecuteHideWindowCommand, CanExecuteHideWindowCommand);
+			CloseWindowCommand = new RelayCommand<object>(OnExecuteCloseWindowCommand, CanExecuteCloseWindowCommand);
 			Closed += (sender, args) => { Owner?.Focus(); };
 			UpdateThemeResources();
 		}
diff --git a/source/Components/AvalonDock/Controls/LayoutItem.cs b/source/Components/AvalonDock/Controls/LayoutItem.cs
index 608fea73..513c8e93 100644
--- a/source/Components/AvalonDock/Controls/LayoutItem.cs
+++ b/source/Components/AvalonDock/Controls/LayoutItem.cs
@@ -718,16 +718,16 @@ private void ExecuteMoveToPreviousTabGroupCommand(object parameter)
 
 		protected virtual void InitDefaultCommands()
 		{
-			_defaultCloseCommand = new RelayCommand(ExecuteCloseCommand, CanExecuteCloseCommand);
-			_defaultFloatCommand = new RelayCommand(ExecuteFloatCommand, CanExecuteFloatCommand);
-			_defaultDockAsDocumentCommand = new RelayCommand(ExecuteDockAsDocumentCommand, CanExecuteDockAsDocumentCommand);
-			_defaultCloseAllButThisCommand = new RelayCommand(ExecuteCloseAllButThisCommand, CanExecuteCloseAllButThisCommand);
-			_defaultCloseAllCommand = new RelayCommand(ExecuteCloseAllCommand, CanExecuteCloseAllCommand);
-			_defaultActivateCommand = new RelayCommand(ExecuteActivateCommand, CanExecuteActivateCommand);
-			_defaultNewVerticalTabGroupCommand = new RelayCommand(ExecuteNewVerticalTabGroupCommand, CanExecuteNewVerticalTabGroupCommand);
-			_defaultNewHorizontalTabGroupCommand = new RelayCommand(ExecuteNewHorizontalTabGroupCommand, CanExecuteNewHorizontalTabGroupCommand);
-			_defaultMoveToNextTabGroupCommand = new RelayCommand(ExecuteMoveToNextTabGroupCommand, CanExecuteMoveToNextTabGroupCommand);
-			_defaultMoveToPreviousTabGroupCommand = new RelayCommand(ExecuteMoveToPreviousTabGroupCommand, CanExecuteMoveToPreviousTabGroupCommand);
+			_defaultCloseCommand = new RelayCommand<object>(ExecuteCloseCommand, CanExecuteCloseCommand);
+			_defaultFloatCommand = new RelayCommand<object>(ExecuteFloatCommand, CanExecuteFloatCommand);
+			_defaultDockAsDocumentCommand = new RelayCommand<object>(ExecuteDockAsDocumentCommand, CanExecuteDockAsDocumentCommand);
+			_defaultCloseAllButThisCommand = new RelayCommand<object>(ExecuteCloseAllButThisCommand, CanExecuteCloseAllButThisCommand);
+			_defaultCloseAllCommand = new RelayCommand<object>(ExecuteCloseAllCommand, CanExecuteCloseAllCommand);
+			_defaultActivateCommand = new RelayCommand<object>(ExecuteActivateCommand, CanExecuteActivateCommand);
+			_defaultNewVerticalTabGroupCommand = new RelayCommand<object>(ExecuteNewVerticalTabGroupCommand, CanExecuteNewVerticalTabGroupCommand);
+			_defaultNewHorizontalTabGroupCommand = new RelayCommand<object>(ExecuteNewHorizontalTabGroupCommand, CanExecuteNewHorizontalTabGroupCommand);
+			_defaultMoveToNextTabGroupCommand = new RelayCommand<object>(ExecuteMoveToNextTabGroupCommand, CanExecuteMoveToNextTabGroupCommand);
+			_defaultMoveToPreviousTabGroupCommand = new RelayCommand<object>(ExecuteMoveToPreviousTabGroupCommand, CanExecuteMoveToPreviousTabGroupCommand);
 		}
 
 		protected virtual void ClearDefaultBindings()

From 72996958cd5f1c6ef22f95b2c2a3d1777069186e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=88=98=E6=99=93=E9=9D=92?= <569132102@qq.com>
Date: Fri, 3 Jul 2020 11:18:21 +0800
Subject: [PATCH 05/10] Add a project about #171

---
 source/AvalonDocPanelMemoryLeaks/App.config   |   6 +
 source/AvalonDocPanelMemoryLeaks/App.xaml     |   9 ++
 source/AvalonDocPanelMemoryLeaks/App.xaml.cs  |  17 +++
 .../AvalonDocPanelMemoryLeaks.csproj          | 106 ++++++++++++++++
 .../AvalonDocPanelMemoryLeaks/MainWindow.xaml |  28 +++++
 .../MainWindow.xaml.cs                        |  54 ++++++++
 .../Properties/AssemblyInfo.cs                |  55 ++++++++
 .../Properties/Resources.Designer.cs          |  63 ++++++++++
 .../Properties/Resources.resx                 | 117 ++++++++++++++++++
 .../Properties/Settings.Designer.cs           |  26 ++++
 .../Properties/Settings.settings              |   7 ++
 .../AvalonDocPanelMemoryLeaks/packages.config |   4 +
 source/AvalonDock.sln                         |  15 +++
 .../AvalonDock.Themes.VS2013/DarkBrushs.xaml  |   2 +-
 14 files changed, 508 insertions(+), 1 deletion(-)
 create mode 100644 source/AvalonDocPanelMemoryLeaks/App.config
 create mode 100644 source/AvalonDocPanelMemoryLeaks/App.xaml
 create mode 100644 source/AvalonDocPanelMemoryLeaks/App.xaml.cs
 create mode 100644 source/AvalonDocPanelMemoryLeaks/AvalonDocPanelMemoryLeaks.csproj
 create mode 100644 source/AvalonDocPanelMemoryLeaks/MainWindow.xaml
 create mode 100644 source/AvalonDocPanelMemoryLeaks/MainWindow.xaml.cs
 create mode 100644 source/AvalonDocPanelMemoryLeaks/Properties/AssemblyInfo.cs
 create mode 100644 source/AvalonDocPanelMemoryLeaks/Properties/Resources.Designer.cs
 create mode 100644 source/AvalonDocPanelMemoryLeaks/Properties/Resources.resx
 create mode 100644 source/AvalonDocPanelMemoryLeaks/Properties/Settings.Designer.cs
 create mode 100644 source/AvalonDocPanelMemoryLeaks/Properties/Settings.settings
 create mode 100644 source/AvalonDocPanelMemoryLeaks/packages.config

diff --git a/source/AvalonDocPanelMemoryLeaks/App.config b/source/AvalonDocPanelMemoryLeaks/App.config
new file mode 100644
index 00000000..bae5d6d8
--- /dev/null
+++ b/source/AvalonDocPanelMemoryLeaks/App.config
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+    <startup> 
+        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.6.1"/>
+    </startup>
+</configuration>
diff --git a/source/AvalonDocPanelMemoryLeaks/App.xaml b/source/AvalonDocPanelMemoryLeaks/App.xaml
new file mode 100644
index 00000000..54158670
--- /dev/null
+++ b/source/AvalonDocPanelMemoryLeaks/App.xaml
@@ -0,0 +1,9 @@
+<Application x:Class="AvalonDocPanelMemoryLeaks.App"
+             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:local="clr-namespace:AvalonDocPanelMemoryLeaks"
+             StartupUri="MainWindow.xaml">
+    <Application.Resources>
+         
+    </Application.Resources>
+</Application>
diff --git a/source/AvalonDocPanelMemoryLeaks/App.xaml.cs b/source/AvalonDocPanelMemoryLeaks/App.xaml.cs
new file mode 100644
index 00000000..92f8302e
--- /dev/null
+++ b/source/AvalonDocPanelMemoryLeaks/App.xaml.cs
@@ -0,0 +1,17 @@
+using System;
+using System.Collections.Generic;
+using System.Configuration;
+using System.Data;
+using System.Linq;
+using System.Threading.Tasks;
+using System.Windows;
+
+namespace AvalonDocPanelMemoryLeaks
+{
+    /// <summary>
+    /// Interaktionslogik für "App.xaml"
+    /// </summary>
+    public partial class App : Application
+    {
+    }
+}
diff --git a/source/AvalonDocPanelMemoryLeaks/AvalonDocPanelMemoryLeaks.csproj b/source/AvalonDocPanelMemoryLeaks/AvalonDocPanelMemoryLeaks.csproj
new file mode 100644
index 00000000..ef63da8d
--- /dev/null
+++ b/source/AvalonDocPanelMemoryLeaks/AvalonDocPanelMemoryLeaks.csproj
@@ -0,0 +1,106 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{5543BFED-827A-4404-8066-3FFDB201DDF0}</ProjectGuid>
+    <OutputType>WinExe</OutputType>
+    <RootNamespace>AvalonDocPanelMemoryLeaks</RootNamespace>
+    <AssemblyName>AvalonDocPanelMemoryLeaks</AssemblyName>
+    <TargetFrameworkVersion>v4.6.1</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <ProjectTypeGuids>{60dc8134-eba5-43b8-bcc9-bb4bc16c2548};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
+    <WarningLevel>4</WarningLevel>
+    <AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
+    <Deterministic>true</Deterministic>
+    <TargetFrameworkProfile />
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <PlatformTarget>AnyCPU</PlatformTarget>
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <PlatformTarget>AnyCPU</PlatformTarget>
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="System.Net.Http" />
+    <Reference Include="System.Xaml">
+      <RequiredTargetFramework>4.0</RequiredTargetFramework>
+    </Reference>
+    <Reference Include="WindowsBase" />
+    <Reference Include="PresentationCore" />
+    <Reference Include="PresentationFramework" />
+  </ItemGroup>
+  <ItemGroup>
+    <ApplicationDefinition Include="App.xaml">
+      <Generator>MSBuild:Compile</Generator>
+      <SubType>Designer</SubType>
+    </ApplicationDefinition>
+    <Page Include="MainWindow.xaml">
+      <Generator>MSBuild:Compile</Generator>
+      <SubType>Designer</SubType>
+    </Page>
+    <Compile Include="App.xaml.cs">
+      <DependentUpon>App.xaml</DependentUpon>
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="MainWindow.xaml.cs">
+      <DependentUpon>MainWindow.xaml</DependentUpon>
+      <SubType>Code</SubType>
+    </Compile>
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Properties\AssemblyInfo.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="Properties\Resources.Designer.cs">
+      <AutoGen>True</AutoGen>
+      <DesignTime>True</DesignTime>
+      <DependentUpon>Resources.resx</DependentUpon>
+    </Compile>
+    <Compile Include="Properties\Settings.Designer.cs">
+      <AutoGen>True</AutoGen>
+      <DependentUpon>Settings.settings</DependentUpon>
+      <DesignTimeSharedInput>True</DesignTimeSharedInput>
+    </Compile>
+    <EmbeddedResource Include="Properties\Resources.resx">
+      <Generator>ResXFileCodeGenerator</Generator>
+      <LastGenOutput>Resources.Designer.cs</LastGenOutput>
+    </EmbeddedResource>
+    <None Include="packages.config" />
+    <None Include="Properties\Settings.settings">
+      <Generator>SettingsSingleFileGenerator</Generator>
+      <LastGenOutput>Settings.Designer.cs</LastGenOutput>
+    </None>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="App.config" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\Components\AvalonDock\AvalonDock.csproj">
+      <Project>{db81988f-e0f2-45a0-a1fd-8c37f3d35244}</Project>
+      <Name>AvalonDock</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+</Project>
\ No newline at end of file
diff --git a/source/AvalonDocPanelMemoryLeaks/MainWindow.xaml b/source/AvalonDocPanelMemoryLeaks/MainWindow.xaml
new file mode 100644
index 00000000..579883ff
--- /dev/null
+++ b/source/AvalonDocPanelMemoryLeaks/MainWindow.xaml
@@ -0,0 +1,28 @@
+<Window x:Class="AvalonDocPanelMemoryLeaks.MainWindow"
+        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+        xmlns:local="clr-namespace:AvalonDocPanelMemoryLeaks"
+        mc:Ignorable="d"
+        xmlns:xcad="https://github.com/Dirkster99/AvalonDock"
+        Title="MainWindow" Height="450" Width="800">
+    <Grid>
+        <Grid.RowDefinitions>
+            <RowDefinition Height="auto"/>
+            <RowDefinition Height="*"/>
+        </Grid.RowDefinitions>
+        <Button Grid.Row="0" Content="Add" Click="Button_Click"/>
+        <xcad:DockingManager Name="dockM" Grid.Row="1">
+            <xcad:LayoutRoot >
+                <xcad:LayoutPanel>
+                    <xcad:LayoutDocumentPaneGroup  >
+                        <xcad:LayoutDocumentPane x:Name="docGrup" >
+
+                        </xcad:LayoutDocumentPane>
+                    </xcad:LayoutDocumentPaneGroup>
+                </xcad:LayoutPanel>
+            </xcad:LayoutRoot>
+        </xcad:DockingManager>
+    </Grid>
+</Window>
diff --git a/source/AvalonDocPanelMemoryLeaks/MainWindow.xaml.cs b/source/AvalonDocPanelMemoryLeaks/MainWindow.xaml.cs
new file mode 100644
index 00000000..e83424d5
--- /dev/null
+++ b/source/AvalonDocPanelMemoryLeaks/MainWindow.xaml.cs
@@ -0,0 +1,54 @@
+using AvalonDock.Layout;
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Data;
+using System.Windows.Documents;
+using System.Windows.Input;
+using System.Windows.Media;
+using System.Windows.Media.Imaging;
+using System.Windows.Navigation;
+using System.Windows.Shapes;
+
+namespace AvalonDocPanelMemoryLeaks
+{
+    /// <summary>
+    /// Interaktionslogik für MainWindow.xaml
+    /// </summary>
+    public partial class MainWindow : Window
+    {
+        public MainWindow()
+        {
+            InitializeComponent();
+        }
+
+        private void Button_Click(object sender, RoutedEventArgs e)
+        {
+            UserControl content = new UserControl();
+            content.DataContext = new HeavyLoad();
+            LayoutDocument docDocument = new LayoutDocument();
+            docDocument.Content = content;
+            docGrup.Children.Add(docDocument);
+            docDocument.Closed += DocClosed;
+        }
+
+        private void DocClosed(object sender, EventArgs e)
+        {
+            GC.Collect();
+        }
+    }
+    public class HeavyLoad:INotifyPropertyChanged
+    {
+
+        public event PropertyChangedEventHandler PropertyChanged;
+
+        public byte[] Load { get; set; } = new byte[100000000];//100MB
+
+       
+    }
+}
diff --git a/source/AvalonDocPanelMemoryLeaks/Properties/AssemblyInfo.cs b/source/AvalonDocPanelMemoryLeaks/Properties/AssemblyInfo.cs
new file mode 100644
index 00000000..9b359400
--- /dev/null
+++ b/source/AvalonDocPanelMemoryLeaks/Properties/AssemblyInfo.cs
@@ -0,0 +1,55 @@
+using System.Reflection;
+using System.Resources;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Windows;
+
+// Allgemeine Informationen über eine Assembly werden über die folgenden
+// Attribute gesteuert. Ändern Sie diese Attributwerte, um die Informationen zu ändern,
+// die einer Assembly zugeordnet sind.
+[assembly: AssemblyTitle("AvalonDocPanelMemoryLeaks")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("AvalonDocPanelMemoryLeaks")]
+[assembly: AssemblyCopyright("Copyright ©  2020")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Durch Festlegen von ComVisible auf FALSE werden die Typen in dieser Assembly
+// für COM-Komponenten unsichtbar.  Wenn Sie auf einen Typ in dieser Assembly von
+// COM aus zugreifen müssen, sollten Sie das ComVisible-Attribut für diesen Typ auf "True" festlegen.
+[assembly: ComVisible(false)]
+
+//Um mit dem Erstellen lokalisierbarer Anwendungen zu beginnen, legen Sie
+//<UICulture>ImCodeVerwendeteKultur</UICulture> in der .csproj-Datei
+//in einer <PropertyGroup> fest.  Wenn Sie in den Quelldateien beispielsweise Deutsch
+//(Deutschland) verwenden, legen Sie <UICulture> auf \"de-DE\" fest.  Heben Sie dann die Auskommentierung
+//des nachstehenden NeutralResourceLanguage-Attributs auf.  Aktualisieren Sie "en-US" in der nachstehenden Zeile,
+//sodass es mit der UICulture-Einstellung in der Projektdatei übereinstimmt.
+
+//[assembly: NeutralResourcesLanguage("en-US", UltimateResourceFallbackLocation.Satellite)]
+
+
+[assembly: ThemeInfo(
+    ResourceDictionaryLocation.None, //Speicherort der designspezifischen Ressourcenwörterbücher
+                                     //(wird verwendet, wenn eine Ressource auf der Seite nicht gefunden wird,
+                                     // oder in den Anwendungsressourcen-Wörterbüchern nicht gefunden werden kann.)
+    ResourceDictionaryLocation.SourceAssembly //Speicherort des generischen Ressourcenwörterbuchs
+                                              //(wird verwendet, wenn eine Ressource auf der Seite nicht gefunden wird,
+                                              // designspezifischen Ressourcenwörterbuch nicht gefunden werden kann.)
+)]
+
+
+// Versionsinformationen für eine Assembly bestehen aus den folgenden vier Werten:
+//
+//      Hauptversion
+//      Nebenversion
+//      Buildnummer
+//      Revision
+//
+// Sie können alle Werte angeben oder Standardwerte für die Build- und Revisionsnummern verwenden,
+// indem Sie "*" wie unten gezeigt eingeben:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]
diff --git a/source/AvalonDocPanelMemoryLeaks/Properties/Resources.Designer.cs b/source/AvalonDocPanelMemoryLeaks/Properties/Resources.Designer.cs
new file mode 100644
index 00000000..1a4e9df1
--- /dev/null
+++ b/source/AvalonDocPanelMemoryLeaks/Properties/Resources.Designer.cs
@@ -0,0 +1,63 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     此代码由工具生成。
+//     运行时版本:4.0.30319.42000
+//
+//     对此文件的更改可能会导致不正确的行为，并且如果
+//     重新生成代码，这些更改将会丢失。
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+namespace AvalonDocPanelMemoryLeaks.Properties {
+    using System;
+    
+    
+    /// <summary>
+    ///   一个强类型的资源类，用于查找本地化的字符串等。
+    /// </summary>
+    // 此类是由 StronglyTypedResourceBuilder
+    // 类通过类似于 ResGen 或 Visual Studio 的工具自动生成的。
+    // 若要添加或移除成员，请编辑 .ResX 文件，然后重新运行 ResGen
+    // (以 /str 作为命令选项)，或重新生成 VS 项目。
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "16.0.0.0")]
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+    internal class Resources {
+        
+        private static global::System.Resources.ResourceManager resourceMan;
+        
+        private static global::System.Globalization.CultureInfo resourceCulture;
+        
+        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
+        internal Resources() {
+        }
+        
+        /// <summary>
+        ///   返回此类使用的缓存的 ResourceManager 实例。
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Resources.ResourceManager ResourceManager {
+            get {
+                if (object.ReferenceEquals(resourceMan, null)) {
+                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("AvalonDocPanelMemoryLeaks.Properties.Resources", typeof(Resources).Assembly);
+                    resourceMan = temp;
+                }
+                return resourceMan;
+            }
+        }
+        
+        /// <summary>
+        ///   重写当前线程的 CurrentUICulture 属性
+        ///   重写当前线程的 CurrentUICulture 属性。
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Globalization.CultureInfo Culture {
+            get {
+                return resourceCulture;
+            }
+            set {
+                resourceCulture = value;
+            }
+        }
+    }
+}
diff --git a/source/AvalonDocPanelMemoryLeaks/Properties/Resources.resx b/source/AvalonDocPanelMemoryLeaks/Properties/Resources.resx
new file mode 100644
index 00000000..af7dbebb
--- /dev/null
+++ b/source/AvalonDocPanelMemoryLeaks/Properties/Resources.resx
@@ -0,0 +1,117 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+</root>
\ No newline at end of file
diff --git a/source/AvalonDocPanelMemoryLeaks/Properties/Settings.Designer.cs b/source/AvalonDocPanelMemoryLeaks/Properties/Settings.Designer.cs
new file mode 100644
index 00000000..c1905c36
--- /dev/null
+++ b/source/AvalonDocPanelMemoryLeaks/Properties/Settings.Designer.cs
@@ -0,0 +1,26 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     此代码由工具生成。
+//     运行时版本:4.0.30319.42000
+//
+//     对此文件的更改可能会导致不正确的行为，并且如果
+//     重新生成代码，这些更改将会丢失。
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+namespace AvalonDocPanelMemoryLeaks.Properties {
+    
+    
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "16.6.0.0")]
+    internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase {
+        
+        private static Settings defaultInstance = ((Settings)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Settings())));
+        
+        public static Settings Default {
+            get {
+                return defaultInstance;
+            }
+        }
+    }
+}
diff --git a/source/AvalonDocPanelMemoryLeaks/Properties/Settings.settings b/source/AvalonDocPanelMemoryLeaks/Properties/Settings.settings
new file mode 100644
index 00000000..033d7a5e
--- /dev/null
+++ b/source/AvalonDocPanelMemoryLeaks/Properties/Settings.settings
@@ -0,0 +1,7 @@
+<?xml version='1.0' encoding='utf-8'?>
+<SettingsFile xmlns="uri:settings" CurrentProfile="(Default)">
+  <Profiles>
+    <Profile Name="(Default)" />
+  </Profiles>
+  <Settings />
+</SettingsFile>
\ No newline at end of file
diff --git a/source/AvalonDocPanelMemoryLeaks/packages.config b/source/AvalonDocPanelMemoryLeaks/packages.config
new file mode 100644
index 00000000..bbd03518
--- /dev/null
+++ b/source/AvalonDocPanelMemoryLeaks/packages.config
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<packages>
+  <package id="Dirkster.AvalonDock" version="4.20.0" targetFramework="net48" />
+</packages>
\ No newline at end of file
diff --git a/source/AvalonDock.sln b/source/AvalonDock.sln
index b1f1d0cf..d5ce0ac9 100644
--- a/source/AvalonDock.sln
+++ b/source/AvalonDock.sln
@@ -38,6 +38,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "MVVMTestApp", "MVVMTestApp\
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "WinFormsTestApp", "WinFormsTestApp\WinFormsTestApp.csproj", "{2433B8AF-0788-4C86-8FDD-E3BCB62E2157}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AvalonDocPanelMemoryLeaks", "AvalonDocPanelMemoryLeaks\AvalonDocPanelMemoryLeaks.csproj", "{5543BFED-827A-4404-8066-3FFDB201DDF0}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -216,6 +218,18 @@ Global
 		{2433B8AF-0788-4C86-8FDD-E3BCB62E2157}.Release|x64.Build.0 = Release|Any CPU
 		{2433B8AF-0788-4C86-8FDD-E3BCB62E2157}.Release|x86.ActiveCfg = Release|Any CPU
 		{2433B8AF-0788-4C86-8FDD-E3BCB62E2157}.Release|x86.Build.0 = Release|Any CPU
+		{5543BFED-827A-4404-8066-3FFDB201DDF0}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{5543BFED-827A-4404-8066-3FFDB201DDF0}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{5543BFED-827A-4404-8066-3FFDB201DDF0}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{5543BFED-827A-4404-8066-3FFDB201DDF0}.Debug|x64.Build.0 = Debug|Any CPU
+		{5543BFED-827A-4404-8066-3FFDB201DDF0}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{5543BFED-827A-4404-8066-3FFDB201DDF0}.Debug|x86.Build.0 = Debug|Any CPU
+		{5543BFED-827A-4404-8066-3FFDB201DDF0}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{5543BFED-827A-4404-8066-3FFDB201DDF0}.Release|Any CPU.Build.0 = Release|Any CPU
+		{5543BFED-827A-4404-8066-3FFDB201DDF0}.Release|x64.ActiveCfg = Release|Any CPU
+		{5543BFED-827A-4404-8066-3FFDB201DDF0}.Release|x64.Build.0 = Release|Any CPU
+		{5543BFED-827A-4404-8066-3FFDB201DDF0}.Release|x86.ActiveCfg = Release|Any CPU
+		{5543BFED-827A-4404-8066-3FFDB201DDF0}.Release|x86.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -237,6 +251,7 @@ Global
 		{DB5F3CB8-214B-4EAB-83D2-2AF4EF3D60AD} = {1D267DDB-F2DE-4B70-87C1-E93A0C2D73F4}
 		{3B75DEA1-F1B2-403C-AB74-C108EDB45EF2} = {1D267DDB-F2DE-4B70-87C1-E93A0C2D73F4}
 		{2433B8AF-0788-4C86-8FDD-E3BCB62E2157} = {1D267DDB-F2DE-4B70-87C1-E93A0C2D73F4}
+		{5543BFED-827A-4404-8066-3FFDB201DDF0} = {1D267DDB-F2DE-4B70-87C1-E93A0C2D73F4}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {459B8289-CF04-4E70-AEC9-23DC3A6E66F6}
diff --git a/source/Components/AvalonDock.Themes.VS2013/DarkBrushs.xaml b/source/Components/AvalonDock.Themes.VS2013/DarkBrushs.xaml
index 383f246a..877d129d 100644
--- a/source/Components/AvalonDock.Themes.VS2013/DarkBrushs.xaml
+++ b/source/Components/AvalonDock.Themes.VS2013/DarkBrushs.xaml
@@ -99,7 +99,7 @@
     <SolidColorBrush
         x:Key="{x:Static reskeys:ResourceKeys.DocumentWellTabSelectedActiveText}"
         options:Freeze="true"
-        Color="#FF000000" />
+        Color="#F1F1F1" />
     <SolidColorBrush
         x:Key="{x:Static reskeys:ResourceKeys.DocumentWellTabSelectedInactiveBackground}"
         options:Freeze="true"

From 381c2e10acfd9786f6d4c2d94bb13e48de05a8ad Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=88=98=E6=99=93=E9=9D=92?= <569132102@qq.com>
Date: Fri, 3 Jul 2020 11:29:24 +0800
Subject: [PATCH 06/10] Fix LayoutRoot references to deleted objects #171

---
 source/Components/AvalonDock/Layout/LayoutGroup.cs | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/source/Components/AvalonDock/Layout/LayoutGroup.cs b/source/Components/AvalonDock/Layout/LayoutGroup.cs
index 29e1222d..62e8951a 100644
--- a/source/Components/AvalonDock/Layout/LayoutGroup.cs
+++ b/source/Components/AvalonDock/Layout/LayoutGroup.cs
@@ -12,6 +12,7 @@ This program is provided to you under the terms of the Microsoft Public
 using System.Linq;
 using System.Collections.ObjectModel;
 using System.Xml.Serialization;
+using System.Collections.Specialized;
 
 namespace AvalonDock.Layout
 {
@@ -212,17 +213,17 @@ protected override void OnParentChanged(ILayoutContainer oldValue, ILayoutContai
 
 		#region Private Methods
 
-		private void _children_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
+		private void _children_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
 		{
-			if (e.Action == System.Collections.Specialized.NotifyCollectionChangedAction.Remove || e.Action == System.Collections.Specialized.NotifyCollectionChangedAction.Replace)
+			if (e.Action == NotifyCollectionChangedAction.Remove || e.Action == NotifyCollectionChangedAction.Replace)
 			{
 				if (e.OldItems != null)
 				{
 					foreach (LayoutElement element in e.OldItems)
-						if (element.Parent == this) element.Parent = null;
+						if (element.Parent == this || e.Action == NotifyCollectionChangedAction.Remove) element.Parent = null;
 				}
 			}
-			if (e.Action == System.Collections.Specialized.NotifyCollectionChangedAction.Add || e.Action == System.Collections.Specialized.NotifyCollectionChangedAction.Replace)
+			if (e.Action == NotifyCollectionChangedAction.Add || e.Action == NotifyCollectionChangedAction.Replace)
 			{
 				if (e.NewItems != null)
 				{
@@ -238,7 +239,7 @@ private void _children_CollectionChanged(object sender, System.Collections.Speci
 			ComputeVisibility();
 			OnChildrenCollectionChanged();
 
-			if (e.Action == System.Collections.Specialized.NotifyCollectionChangedAction.Add)
+			if (e.Action == NotifyCollectionChangedAction.Add)
 				// #81 - Make parents update their children up the tree. Otherwise, they will not be redrawn.
 				RaiseChildrenTreeChanged();
 			else

From 6ec1e3043f4d393d2e559135fc75608b24bf87d4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=88=98=E6=99=93=E9=9D=92?= <569132102@qq.com>
Date: Fri, 3 Jul 2020 13:27:16 +0800
Subject: [PATCH 07/10] Fix leaks on close #171

---
 .../MainWindow.xaml.cs                        |  6 +++-
 .../AvalonDock.Themes.Aero/Theme.xaml         |  7 ++---
 .../AvalonDock.Themes.Expression/Theme.xaml   |  7 ++---
 .../AvalonDock.Themes.Metro/Theme.xaml        |  7 ++---
 .../AvalonDock.Themes.VS2010/Theme.xaml       |  7 ++---
 .../Themes/Generic.xaml                       |  9 ++----
 .../Controls/LayoutAutoHideWindowControl.cs   |  4 +--
 .../Controls/LayoutDocumentPaneControl.cs     | 28 +++++++++++++++++--
 .../Controls/LayoutDocumentTabItem.cs         |  8 ++++--
 .../Components/AvalonDock/DockingManager.cs   |  2 ++
 .../AvalonDock/Layout/LayoutContent.cs        |  6 ++++
 .../Components/AvalonDock/Themes/generic.xaml |  8 ++----
 12 files changed, 63 insertions(+), 36 deletions(-)

diff --git a/source/AvalonDocPanelMemoryLeaks/MainWindow.xaml.cs b/source/AvalonDocPanelMemoryLeaks/MainWindow.xaml.cs
index e83424d5..2689d8b8 100644
--- a/source/AvalonDocPanelMemoryLeaks/MainWindow.xaml.cs
+++ b/source/AvalonDocPanelMemoryLeaks/MainWindow.xaml.cs
@@ -27,10 +27,13 @@ public MainWindow()
             InitializeComponent();
         }
 
+        public HeavyLoad HeavyLoad { get; private set; }
+
         private void Button_Click(object sender, RoutedEventArgs e)
         {
             UserControl content = new UserControl();
-            content.DataContext = new HeavyLoad();
+            HeavyLoad = new HeavyLoad();
+            content.DataContext = HeavyLoad;
             LayoutDocument docDocument = new LayoutDocument();
             docDocument.Content = content;
             docGrup.Children.Add(docDocument);
@@ -39,6 +42,7 @@ private void Button_Click(object sender, RoutedEventArgs e)
 
         private void DocClosed(object sender, EventArgs e)
         {
+            HeavyLoad.Load = null;
             GC.Collect();
         }
     }
diff --git a/source/Components/AvalonDock.Themes.Aero/Theme.xaml b/source/Components/AvalonDock.Themes.Aero/Theme.xaml
index da765898..11455974 100644
--- a/source/Components/AvalonDock.Themes.Aero/Theme.xaml
+++ b/source/Components/AvalonDock.Themes.Aero/Theme.xaml
@@ -1008,6 +1008,8 @@
     </Style>
 
     <Style TargetType="{x:Type avalonDockControls:LayoutDocumentTabItem}">
+        <Setter Property="ContentTemplate" Value="{Binding DocumentHeaderTemplate, Mode=OneWay, RelativeSource={RelativeSource AncestorType={x:Type avalonDock:DockingManager}, Mode=FindAncestor}}" />
+        <Setter Property="ContentTemplateSelector" Value="{Binding DocumentHeaderTemplateSelector, Mode=OneWay, RelativeSource={RelativeSource AncestorType={x:Type avalonDock:DockingManager}, Mode=FindAncestor}}" />
         <Setter Property="Template">
             <Setter.Value>
                 <ControlTemplate TargetType="{x:Type avalonDockControls:LayoutDocumentTabItem}">
@@ -1023,10 +1025,7 @@
                                     <ColumnDefinition Width="Auto" />
                                 </Grid.ColumnDefinitions>
                                 <Border Grid.ColumnSpan="3" Background="Transparent" />
-                                <ContentPresenter
-                                    Content="{Binding Model, RelativeSource={RelativeSource TemplatedParent}}"
-                                    ContentTemplate="{Binding DocumentHeaderTemplate, Mode=OneWay, RelativeSource={RelativeSource AncestorType={x:Type avalonDock:DockingManager}, Mode=FindAncestor}}"
-                                    ContentTemplateSelector="{Binding DocumentHeaderTemplateSelector, Mode=OneWay, RelativeSource={RelativeSource AncestorType={x:Type avalonDock:DockingManager}, Mode=FindAncestor}}" />
+                                <ContentPresenter />
                                 <!--  Close button should be moved out to the container style  -->
                                 <Button
                                     x:Name="DocumentCloseButton"
diff --git a/source/Components/AvalonDock.Themes.Expression/Theme.xaml b/source/Components/AvalonDock.Themes.Expression/Theme.xaml
index 35d9ea8d..bb09e7cb 100644
--- a/source/Components/AvalonDock.Themes.Expression/Theme.xaml
+++ b/source/Components/AvalonDock.Themes.Expression/Theme.xaml
@@ -880,6 +880,8 @@
     </Style>
 
     <Style TargetType="{x:Type avalonDockControls:LayoutDocumentTabItem}">
+        <Setter Property="ContentTemplate" Value="{Binding DocumentHeaderTemplate, Mode=OneWay, RelativeSource={RelativeSource AncestorType={x:Type avalonDock:DockingManager}, Mode=FindAncestor}}" />
+        <Setter Property="ContentTemplateSelector" Value="{Binding DocumentHeaderTemplateSelector, Mode=OneWay, RelativeSource={RelativeSource AncestorType={x:Type avalonDock:DockingManager}, Mode=FindAncestor}}" />
         <Setter Property="Template">
             <Setter.Value>
                 <ControlTemplate TargetType="{x:Type avalonDockControls:LayoutDocumentTabItem}">
@@ -895,10 +897,7 @@
                                     <ColumnDefinition Width="Auto" />
                                 </Grid.ColumnDefinitions>
                                 <Border Grid.ColumnSpan="2" Background="Transparent" />
-                                <ContentPresenter
-                                    Content="{Binding Model, RelativeSource={RelativeSource TemplatedParent}}"
-                                    ContentTemplate="{Binding DocumentHeaderTemplate, Mode=OneWay, RelativeSource={RelativeSource AncestorType={x:Type avalonDock:DockingManager}, Mode=FindAncestor}}"
-                                    ContentTemplateSelector="{Binding DocumentHeaderTemplateSelector, Mode=OneWay, RelativeSource={RelativeSource AncestorType={x:Type avalonDock:DockingManager}, Mode=FindAncestor}}" />
+                                <ContentPresenter />
                                 <!--  Close button should be moved out to the container style  -->
                                 <Button
                                     x:Name="DocumentCloseButton"
diff --git a/source/Components/AvalonDock.Themes.Metro/Theme.xaml b/source/Components/AvalonDock.Themes.Metro/Theme.xaml
index e2055c5e..89d14bc1 100644
--- a/source/Components/AvalonDock.Themes.Metro/Theme.xaml
+++ b/source/Components/AvalonDock.Themes.Metro/Theme.xaml
@@ -1029,6 +1029,8 @@
     </Style>
 
     <Style TargetType="{x:Type avalonDockControls:LayoutDocumentTabItem}">
+        <Setter Property="ContentTemplate" Value="{Binding DocumentHeaderTemplate, Mode=OneWay, RelativeSource={RelativeSource AncestorType={x:Type avalonDock:DockingManager}, Mode=FindAncestor}}" />
+        <Setter Property="ContentTemplateSelector" Value="{Binding DocumentHeaderTemplateSelector, Mode=OneWay, RelativeSource={RelativeSource AncestorType={x:Type avalonDock:DockingManager}, Mode=FindAncestor}}" />
         <Setter Property="Template">
             <Setter.Value>
                 <ControlTemplate TargetType="{x:Type avalonDockControls:LayoutDocumentTabItem}">
@@ -1045,10 +1047,7 @@
                                     <ColumnDefinition Width="Auto" />
                                 </Grid.ColumnDefinitions>
                                 <Border Grid.ColumnSpan="3" Background="Transparent" />
-                                <ContentPresenter
-                                    Content="{Binding Model, RelativeSource={RelativeSource TemplatedParent}}"
-                                    ContentTemplate="{Binding DocumentHeaderTemplate, Mode=OneWay, RelativeSource={RelativeSource AncestorType={x:Type avalonDock:DockingManager}, Mode=FindAncestor}}"
-                                    ContentTemplateSelector="{Binding DocumentHeaderTemplateSelector, Mode=OneWay, RelativeSource={RelativeSource AncestorType={x:Type avalonDock:DockingManager}, Mode=FindAncestor}}" />
+                                <ContentPresenter />
                                 <!--  Close button should be moved out to the container style  -->
                                 <Button
                                     x:Name="DocumentCloseButton"
diff --git a/source/Components/AvalonDock.Themes.VS2010/Theme.xaml b/source/Components/AvalonDock.Themes.VS2010/Theme.xaml
index 80d8c07a..feb3d714 100644
--- a/source/Components/AvalonDock.Themes.VS2010/Theme.xaml
+++ b/source/Components/AvalonDock.Themes.VS2010/Theme.xaml
@@ -1075,6 +1075,8 @@
     </Style>
 
     <Style TargetType="{x:Type avalonDockControls:LayoutDocumentTabItem}">
+        <Setter Property="ContentTemplate" Value="{Binding DocumentHeaderTemplate, Mode=OneWay, RelativeSource={RelativeSource AncestorType={x:Type avalonDock:DockingManager}, Mode=FindAncestor}}" />
+        <Setter Property="ContentTemplateSelector" Value="{Binding DocumentHeaderTemplateSelector, Mode=OneWay, RelativeSource={RelativeSource AncestorType={x:Type avalonDock:DockingManager}, Mode=FindAncestor}}" />
         <Setter Property="Template">
             <Setter.Value>
                 <ControlTemplate TargetType="{x:Type avalonDockControls:LayoutDocumentTabItem}">
@@ -1091,10 +1093,7 @@
                                     <ColumnDefinition Width="Auto" />
                                 </Grid.ColumnDefinitions>
                                 <Border Grid.ColumnSpan="3" Background="Transparent" />
-                                <ContentPresenter
-                                    Content="{Binding Model, RelativeSource={RelativeSource TemplatedParent}}"
-                                    ContentTemplate="{Binding DocumentHeaderTemplate, Mode=OneWay, RelativeSource={RelativeSource AncestorType={x:Type avalonDock:DockingManager}, Mode=FindAncestor}}"
-                                    ContentTemplateSelector="{Binding DocumentHeaderTemplateSelector, Mode=OneWay, RelativeSource={RelativeSource AncestorType={x:Type avalonDock:DockingManager}, Mode=FindAncestor}}" />
+                                <ContentPresenter />
                                 <!--  Close button should be moved out to the container style  -->
                                 <Button
                                     x:Name="DocumentCloseButton"
diff --git a/source/Components/AvalonDock.Themes.VS2013/Themes/Generic.xaml b/source/Components/AvalonDock.Themes.VS2013/Themes/Generic.xaml
index 8d2ea0af..cb37eb71 100644
--- a/source/Components/AvalonDock.Themes.VS2013/Themes/Generic.xaml
+++ b/source/Components/AvalonDock.Themes.VS2013/Themes/Generic.xaml
@@ -1348,6 +1348,8 @@
     </Style>
 
     <Style TargetType="{x:Type avalonDockControls:LayoutDocumentTabItem}">
+        <Setter Property="ContentTemplate" Value="{Binding DocumentHeaderTemplate, Mode=OneWay, RelativeSource={RelativeSource AncestorType={x:Type avalonDock:DockingManager}, Mode=FindAncestor}}" />
+        <Setter Property="ContentTemplateSelector" Value="{Binding DocumentHeaderTemplateSelector, Mode=OneWay, RelativeSource={RelativeSource AncestorType={x:Type avalonDock:DockingManager}, Mode=FindAncestor}}" />
         <Setter Property="Template">
             <Setter.Value>
                 <ControlTemplate TargetType="{x:Type avalonDockControls:LayoutDocumentTabItem}">
@@ -1366,12 +1368,7 @@
                                     <ColumnDefinition Width="Auto" />
                                 </Grid.ColumnDefinitions>
                                 <Border Grid.ColumnSpan="2" Background="Transparent" />
-                                <ContentPresenter
-                                    Margin="4,0"
-                                    Content="{Binding Model, RelativeSource={RelativeSource TemplatedParent}}"
-                                    ContentTemplate="{Binding DocumentHeaderTemplate, Mode=OneWay, RelativeSource={RelativeSource AncestorType={x:Type avalonDock:DockingManager}, Mode=FindAncestor}}"
-                                    ContentTemplateSelector="{Binding DocumentHeaderTemplateSelector, Mode=OneWay, RelativeSource={RelativeSource AncestorType={x:Type avalonDock:DockingManager}, Mode=FindAncestor}}"
-                                    TextBlock.Foreground="{Binding Foreground, RelativeSource={RelativeSource Mode=FindAncestor, AncestorType=TabItem}}" />
+                                <ContentPresenter Margin="4,0" TextBlock.Foreground="{Binding Foreground, RelativeSource={RelativeSource Mode=FindAncestor, AncestorType=TabItem}}" />
                                 <!--  Close button should be moved out to the container style  -->
                                 <Button
                                     x:Name="DocumentCloseButton"
diff --git a/source/Components/AvalonDock/Controls/LayoutAutoHideWindowControl.cs b/source/Components/AvalonDock/Controls/LayoutAutoHideWindowControl.cs
index 9573a724..053aaedb 100644
--- a/source/Components/AvalonDock/Controls/LayoutAutoHideWindowControl.cs
+++ b/source/Components/AvalonDock/Controls/LayoutAutoHideWindowControl.cs
@@ -144,8 +144,8 @@ internal bool IsWin32MouseOver
 				var rectWindow = this.GetScreenArea();
 				if (rectWindow.Contains(new Point(ptMouse.X, ptMouse.Y))) return true;
 
-				var manager = Model.Root.Manager;
-				var anchor = manager.FindVisualChildren<LayoutAnchorControl>().Where(c => c.Model == Model).FirstOrDefault();
+				var manager = Model?.Root.Manager;
+				var anchor = manager?.FindVisualChildren<LayoutAnchorControl>().Where(c => c.Model == Model).FirstOrDefault();
 
 				return anchor != null && anchor.IsMouseOver;
 				//location = anchor.PointToScreenDPI(new Point());
diff --git a/source/Components/AvalonDock/Controls/LayoutDocumentPaneControl.cs b/source/Components/AvalonDock/Controls/LayoutDocumentPaneControl.cs
index 79c52cc4..53944d2d 100644
--- a/source/Components/AvalonDock/Controls/LayoutDocumentPaneControl.cs
+++ b/source/Components/AvalonDock/Controls/LayoutDocumentPaneControl.cs
@@ -8,6 +8,8 @@ This program is provided to you under the terms of the Microsoft Public
  ************************************************************************/
 
 using System;
+using System.Collections;
+using System.Collections.Specialized;
 using System.Windows;
 using System.Windows.Controls;
 using System.Windows.Data;
@@ -87,11 +89,31 @@ protected override void OnMouseRightButtonDown(System.Windows.Input.MouseButtonE
 				_model.SelectedContent.IsActive = true;
 		}
 
-		#endregion Overrides
+        protected override void OnItemsChanged(NotifyCollectionChangedEventArgs e)
+        {
+            base.OnItemsChanged(e);
+			if (e.Action == NotifyCollectionChangedAction.Remove)
+			{
+				foreach (var item in e.OldItems)
+				{
+					if (item is LayoutContent layoutContent)
+					{
+						layoutContent.TabItem.Model = null;
+						layoutContent.TabItem.ContextMenu = null;
+						layoutContent.TabItem.Content = null;
+						var panel = layoutContent.TabItem.FindVisualAncestor<Panel>();
+						if (panel != null) panel.Children.Remove(layoutContent.TabItem);
+						layoutContent.TabItem = null;
+					}
+				}
+			}
+		}
+
+        #endregion Overrides
 
-		#region Private Methods
+        #region Private Methods
 
-		private void OnSizeChanged(object sender, SizeChangedEventArgs e)
+        private void OnSizeChanged(object sender, SizeChangedEventArgs e)
 		{
 			var modelWithAtcualSize = _model as ILayoutPositionableElementWithActualSize;
 			modelWithAtcualSize.ActualWidth = ActualWidth;
diff --git a/source/Components/AvalonDock/Controls/LayoutDocumentTabItem.cs b/source/Components/AvalonDock/Controls/LayoutDocumentTabItem.cs
index 4171788d..5f0ab605 100644
--- a/source/Components/AvalonDock/Controls/LayoutDocumentTabItem.cs
+++ b/source/Components/AvalonDock/Controls/LayoutDocumentTabItem.cs
@@ -24,7 +24,7 @@ namespace AvalonDock.Controls
 	/// document from its docking position.
 	/// </summary>
 	/// <seealso cref="Control"/>
-	public class LayoutDocumentTabItem : Control
+	public class LayoutDocumentTabItem : ContentControl
 	{
 		#region fields
 		private List<Rect> _otherTabsScreenArea = null;
@@ -69,8 +69,10 @@ public LayoutContent Model
 		/// <summary>Provides derived classes an opportunity to handle changes to the <see cref="Model"/> property.</summary>
 		protected virtual void OnModelChanged(DependencyPropertyChangedEventArgs e)
 		{
-			DockingManager manager = Model?.Root?.Manager;
-			SetLayoutItem(manager != null ? manager.GetLayoutItemFromModel(Model) : null);
+            var layoutItem = (Model?.Root?.Manager)?.GetLayoutItemFromModel(Model);
+			SetLayoutItem(layoutItem);
+			if (layoutItem != null)
+				Model.TabItem = this;
 			//UpdateLogicalParent();
 		}
 
diff --git a/source/Components/AvalonDock/DockingManager.cs b/source/Components/AvalonDock/DockingManager.cs
index 4a72db1c..fe45fac0 100644
--- a/source/Components/AvalonDock/DockingManager.cs
+++ b/source/Components/AvalonDock/DockingManager.cs
@@ -1714,6 +1714,8 @@ internal void ExecuteCloseCommand(LayoutDocument document)
             }
             if (!document.CloseDocument()) return;
             RemoveViewFromLogicalChild(document);
+            if (document.Content is UIElement uIElement)
+                RemoveLogicalChild(uIElement);
             DocumentClosed?.Invoke(this, new DocumentClosedEventArgs(document));
         }
 
diff --git a/source/Components/AvalonDock/Layout/LayoutContent.cs b/source/Components/AvalonDock/Layout/LayoutContent.cs
index dedce6a2..3eb08602 100644
--- a/source/Components/AvalonDock/Layout/LayoutContent.cs
+++ b/source/Components/AvalonDock/Layout/LayoutContent.cs
@@ -462,6 +462,11 @@ public bool IsEnabled
 
 		#endregion IsEnabled
 
+		#region TabItem
+		public LayoutDocumentTabItem TabItem { get; internal set; }
+
+		#endregion TabItem
+
 		#endregion Properties
 
 		#region Public Methods
@@ -723,6 +728,7 @@ internal void CloseInternal()
 
 			parentAsContainer.RemoveChild(this);
 			root?.CollectGarbage();
+			this.Content = null;
 			OnClosed();
 		}
 
diff --git a/source/Components/AvalonDock/Themes/generic.xaml b/source/Components/AvalonDock/Themes/generic.xaml
index 2c1b6372..41dee3c0 100644
--- a/source/Components/AvalonDock/Themes/generic.xaml
+++ b/source/Components/AvalonDock/Themes/generic.xaml
@@ -754,6 +754,8 @@
     </Style>
 
     <Style TargetType="{x:Type avalonDockControls:LayoutDocumentTabItem}">
+        <Setter Property="ContentTemplate" Value="{Binding DocumentHeaderTemplate, Mode=OneWay, RelativeSource={RelativeSource AncestorType={x:Type avalonDock:DockingManager}, Mode=FindAncestor}}" />
+        <Setter Property="ContentTemplateSelector" Value="{Binding DocumentHeaderTemplateSelector, Mode=OneWay, RelativeSource={RelativeSource AncestorType={x:Type avalonDock:DockingManager}, Mode=FindAncestor}}" />
         <Setter Property="Template">
             <Setter.Value>
                 <ControlTemplate TargetType="{x:Type avalonDockControls:LayoutDocumentTabItem}">
@@ -769,11 +771,7 @@
                                     <ColumnDefinition Width="Auto" />
                                 </Grid.ColumnDefinitions>
                                 <Border Grid.ColumnSpan="3" Background="Transparent" />
-                                <ContentPresenter
-                                    Content="{Binding Model, RelativeSource={RelativeSource TemplatedParent}}"
-                                    ContentTemplate="{Binding DocumentHeaderTemplate, Mode=OneWay, RelativeSource={RelativeSource AncestorType={x:Type avalonDock:DockingManager}, Mode=FindAncestor}}"
-                                    ContentTemplateSelector="{Binding DocumentHeaderTemplateSelector, Mode=OneWay, RelativeSource={RelativeSource AncestorType={x:Type avalonDock:DockingManager}, Mode=FindAncestor}}" />
-
+                                <ContentPresenter />
                                 <Button
                                     x:Name="DocumentCloseButton"
                                     Grid.Column="2"

From 1c1f266a265114af70d1f9a9c7cbc03509c11e08 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=88=98=E6=99=93=E9=9D=92?= <569132102@qq.com>
Date: Fri, 3 Jul 2020 13:43:43 +0800
Subject: [PATCH 08/10] fix layoutContent.TabItem is null, fix document header
 disappear

---
 source/Components/AvalonDock.Themes.Aero/Theme.xaml      | 7 ++++---
 .../Components/AvalonDock.Themes.Expression/Theme.xaml   | 7 ++++---
 source/Components/AvalonDock.Themes.Metro/Theme.xaml     | 7 ++++---
 source/Components/AvalonDock.Themes.VS2010/Theme.xaml    | 7 ++++---
 .../AvalonDock.Themes.VS2013/Themes/Generic.xaml         | 9 ++++++---
 source/Components/AvalonDock/Themes/generic.xaml         | 8 +++++---
 6 files changed, 27 insertions(+), 18 deletions(-)

diff --git a/source/Components/AvalonDock.Themes.Aero/Theme.xaml b/source/Components/AvalonDock.Themes.Aero/Theme.xaml
index 11455974..da765898 100644
--- a/source/Components/AvalonDock.Themes.Aero/Theme.xaml
+++ b/source/Components/AvalonDock.Themes.Aero/Theme.xaml
@@ -1008,8 +1008,6 @@
     </Style>
 
     <Style TargetType="{x:Type avalonDockControls:LayoutDocumentTabItem}">
-        <Setter Property="ContentTemplate" Value="{Binding DocumentHeaderTemplate, Mode=OneWay, RelativeSource={RelativeSource AncestorType={x:Type avalonDock:DockingManager}, Mode=FindAncestor}}" />
-        <Setter Property="ContentTemplateSelector" Value="{Binding DocumentHeaderTemplateSelector, Mode=OneWay, RelativeSource={RelativeSource AncestorType={x:Type avalonDock:DockingManager}, Mode=FindAncestor}}" />
         <Setter Property="Template">
             <Setter.Value>
                 <ControlTemplate TargetType="{x:Type avalonDockControls:LayoutDocumentTabItem}">
@@ -1025,7 +1023,10 @@
                                     <ColumnDefinition Width="Auto" />
                                 </Grid.ColumnDefinitions>
                                 <Border Grid.ColumnSpan="3" Background="Transparent" />
-                                <ContentPresenter />
+                                <ContentPresenter
+                                    Content="{Binding Model, RelativeSource={RelativeSource TemplatedParent}}"
+                                    ContentTemplate="{Binding DocumentHeaderTemplate, Mode=OneWay, RelativeSource={RelativeSource AncestorType={x:Type avalonDock:DockingManager}, Mode=FindAncestor}}"
+                                    ContentTemplateSelector="{Binding DocumentHeaderTemplateSelector, Mode=OneWay, RelativeSource={RelativeSource AncestorType={x:Type avalonDock:DockingManager}, Mode=FindAncestor}}" />
                                 <!--  Close button should be moved out to the container style  -->
                                 <Button
                                     x:Name="DocumentCloseButton"
diff --git a/source/Components/AvalonDock.Themes.Expression/Theme.xaml b/source/Components/AvalonDock.Themes.Expression/Theme.xaml
index bb09e7cb..35d9ea8d 100644
--- a/source/Components/AvalonDock.Themes.Expression/Theme.xaml
+++ b/source/Components/AvalonDock.Themes.Expression/Theme.xaml
@@ -880,8 +880,6 @@
     </Style>
 
     <Style TargetType="{x:Type avalonDockControls:LayoutDocumentTabItem}">
-        <Setter Property="ContentTemplate" Value="{Binding DocumentHeaderTemplate, Mode=OneWay, RelativeSource={RelativeSource AncestorType={x:Type avalonDock:DockingManager}, Mode=FindAncestor}}" />
-        <Setter Property="ContentTemplateSelector" Value="{Binding DocumentHeaderTemplateSelector, Mode=OneWay, RelativeSource={RelativeSource AncestorType={x:Type avalonDock:DockingManager}, Mode=FindAncestor}}" />
         <Setter Property="Template">
             <Setter.Value>
                 <ControlTemplate TargetType="{x:Type avalonDockControls:LayoutDocumentTabItem}">
@@ -897,7 +895,10 @@
                                     <ColumnDefinition Width="Auto" />
                                 </Grid.ColumnDefinitions>
                                 <Border Grid.ColumnSpan="2" Background="Transparent" />
-                                <ContentPresenter />
+                                <ContentPresenter
+                                    Content="{Binding Model, RelativeSource={RelativeSource TemplatedParent}}"
+                                    ContentTemplate="{Binding DocumentHeaderTemplate, Mode=OneWay, RelativeSource={RelativeSource AncestorType={x:Type avalonDock:DockingManager}, Mode=FindAncestor}}"
+                                    ContentTemplateSelector="{Binding DocumentHeaderTemplateSelector, Mode=OneWay, RelativeSource={RelativeSource AncestorType={x:Type avalonDock:DockingManager}, Mode=FindAncestor}}" />
                                 <!--  Close button should be moved out to the container style  -->
                                 <Button
                                     x:Name="DocumentCloseButton"
diff --git a/source/Components/AvalonDock.Themes.Metro/Theme.xaml b/source/Components/AvalonDock.Themes.Metro/Theme.xaml
index 89d14bc1..e2055c5e 100644
--- a/source/Components/AvalonDock.Themes.Metro/Theme.xaml
+++ b/source/Components/AvalonDock.Themes.Metro/Theme.xaml
@@ -1029,8 +1029,6 @@
     </Style>
 
     <Style TargetType="{x:Type avalonDockControls:LayoutDocumentTabItem}">
-        <Setter Property="ContentTemplate" Value="{Binding DocumentHeaderTemplate, Mode=OneWay, RelativeSource={RelativeSource AncestorType={x:Type avalonDock:DockingManager}, Mode=FindAncestor}}" />
-        <Setter Property="ContentTemplateSelector" Value="{Binding DocumentHeaderTemplateSelector, Mode=OneWay, RelativeSource={RelativeSource AncestorType={x:Type avalonDock:DockingManager}, Mode=FindAncestor}}" />
         <Setter Property="Template">
             <Setter.Value>
                 <ControlTemplate TargetType="{x:Type avalonDockControls:LayoutDocumentTabItem}">
@@ -1047,7 +1045,10 @@
                                     <ColumnDefinition Width="Auto" />
                                 </Grid.ColumnDefinitions>
                                 <Border Grid.ColumnSpan="3" Background="Transparent" />
-                                <ContentPresenter />
+                                <ContentPresenter
+                                    Content="{Binding Model, RelativeSource={RelativeSource TemplatedParent}}"
+                                    ContentTemplate="{Binding DocumentHeaderTemplate, Mode=OneWay, RelativeSource={RelativeSource AncestorType={x:Type avalonDock:DockingManager}, Mode=FindAncestor}}"
+                                    ContentTemplateSelector="{Binding DocumentHeaderTemplateSelector, Mode=OneWay, RelativeSource={RelativeSource AncestorType={x:Type avalonDock:DockingManager}, Mode=FindAncestor}}" />
                                 <!--  Close button should be moved out to the container style  -->
                                 <Button
                                     x:Name="DocumentCloseButton"
diff --git a/source/Components/AvalonDock.Themes.VS2010/Theme.xaml b/source/Components/AvalonDock.Themes.VS2010/Theme.xaml
index feb3d714..80d8c07a 100644
--- a/source/Components/AvalonDock.Themes.VS2010/Theme.xaml
+++ b/source/Components/AvalonDock.Themes.VS2010/Theme.xaml
@@ -1075,8 +1075,6 @@
     </Style>
 
     <Style TargetType="{x:Type avalonDockControls:LayoutDocumentTabItem}">
-        <Setter Property="ContentTemplate" Value="{Binding DocumentHeaderTemplate, Mode=OneWay, RelativeSource={RelativeSource AncestorType={x:Type avalonDock:DockingManager}, Mode=FindAncestor}}" />
-        <Setter Property="ContentTemplateSelector" Value="{Binding DocumentHeaderTemplateSelector, Mode=OneWay, RelativeSource={RelativeSource AncestorType={x:Type avalonDock:DockingManager}, Mode=FindAncestor}}" />
         <Setter Property="Template">
             <Setter.Value>
                 <ControlTemplate TargetType="{x:Type avalonDockControls:LayoutDocumentTabItem}">
@@ -1093,7 +1091,10 @@
                                     <ColumnDefinition Width="Auto" />
                                 </Grid.ColumnDefinitions>
                                 <Border Grid.ColumnSpan="3" Background="Transparent" />
-                                <ContentPresenter />
+                                <ContentPresenter
+                                    Content="{Binding Model, RelativeSource={RelativeSource TemplatedParent}}"
+                                    ContentTemplate="{Binding DocumentHeaderTemplate, Mode=OneWay, RelativeSource={RelativeSource AncestorType={x:Type avalonDock:DockingManager}, Mode=FindAncestor}}"
+                                    ContentTemplateSelector="{Binding DocumentHeaderTemplateSelector, Mode=OneWay, RelativeSource={RelativeSource AncestorType={x:Type avalonDock:DockingManager}, Mode=FindAncestor}}" />
                                 <!--  Close button should be moved out to the container style  -->
                                 <Button
                                     x:Name="DocumentCloseButton"
diff --git a/source/Components/AvalonDock.Themes.VS2013/Themes/Generic.xaml b/source/Components/AvalonDock.Themes.VS2013/Themes/Generic.xaml
index cb37eb71..8d2ea0af 100644
--- a/source/Components/AvalonDock.Themes.VS2013/Themes/Generic.xaml
+++ b/source/Components/AvalonDock.Themes.VS2013/Themes/Generic.xaml
@@ -1348,8 +1348,6 @@
     </Style>
 
     <Style TargetType="{x:Type avalonDockControls:LayoutDocumentTabItem}">
-        <Setter Property="ContentTemplate" Value="{Binding DocumentHeaderTemplate, Mode=OneWay, RelativeSource={RelativeSource AncestorType={x:Type avalonDock:DockingManager}, Mode=FindAncestor}}" />
-        <Setter Property="ContentTemplateSelector" Value="{Binding DocumentHeaderTemplateSelector, Mode=OneWay, RelativeSource={RelativeSource AncestorType={x:Type avalonDock:DockingManager}, Mode=FindAncestor}}" />
         <Setter Property="Template">
             <Setter.Value>
                 <ControlTemplate TargetType="{x:Type avalonDockControls:LayoutDocumentTabItem}">
@@ -1368,7 +1366,12 @@
                                     <ColumnDefinition Width="Auto" />
                                 </Grid.ColumnDefinitions>
                                 <Border Grid.ColumnSpan="2" Background="Transparent" />
-                                <ContentPresenter Margin="4,0" TextBlock.Foreground="{Binding Foreground, RelativeSource={RelativeSource Mode=FindAncestor, AncestorType=TabItem}}" />
+                                <ContentPresenter
+                                    Margin="4,0"
+                                    Content="{Binding Model, RelativeSource={RelativeSource TemplatedParent}}"
+                                    ContentTemplate="{Binding DocumentHeaderTemplate, Mode=OneWay, RelativeSource={RelativeSource AncestorType={x:Type avalonDock:DockingManager}, Mode=FindAncestor}}"
+                                    ContentTemplateSelector="{Binding DocumentHeaderTemplateSelector, Mode=OneWay, RelativeSource={RelativeSource AncestorType={x:Type avalonDock:DockingManager}, Mode=FindAncestor}}"
+                                    TextBlock.Foreground="{Binding Foreground, RelativeSource={RelativeSource Mode=FindAncestor, AncestorType=TabItem}}" />
                                 <!--  Close button should be moved out to the container style  -->
                                 <Button
                                     x:Name="DocumentCloseButton"
diff --git a/source/Components/AvalonDock/Themes/generic.xaml b/source/Components/AvalonDock/Themes/generic.xaml
index 41dee3c0..2c1b6372 100644
--- a/source/Components/AvalonDock/Themes/generic.xaml
+++ b/source/Components/AvalonDock/Themes/generic.xaml
@@ -754,8 +754,6 @@
     </Style>
 
     <Style TargetType="{x:Type avalonDockControls:LayoutDocumentTabItem}">
-        <Setter Property="ContentTemplate" Value="{Binding DocumentHeaderTemplate, Mode=OneWay, RelativeSource={RelativeSource AncestorType={x:Type avalonDock:DockingManager}, Mode=FindAncestor}}" />
-        <Setter Property="ContentTemplateSelector" Value="{Binding DocumentHeaderTemplateSelector, Mode=OneWay, RelativeSource={RelativeSource AncestorType={x:Type avalonDock:DockingManager}, Mode=FindAncestor}}" />
         <Setter Property="Template">
             <Setter.Value>
                 <ControlTemplate TargetType="{x:Type avalonDockControls:LayoutDocumentTabItem}">
@@ -771,7 +769,11 @@
                                     <ColumnDefinition Width="Auto" />
                                 </Grid.ColumnDefinitions>
                                 <Border Grid.ColumnSpan="3" Background="Transparent" />
-                                <ContentPresenter />
+                                <ContentPresenter
+                                    Content="{Binding Model, RelativeSource={RelativeSource TemplatedParent}}"
+                                    ContentTemplate="{Binding DocumentHeaderTemplate, Mode=OneWay, RelativeSource={RelativeSource AncestorType={x:Type avalonDock:DockingManager}, Mode=FindAncestor}}"
+                                    ContentTemplateSelector="{Binding DocumentHeaderTemplateSelector, Mode=OneWay, RelativeSource={RelativeSource AncestorType={x:Type avalonDock:DockingManager}, Mode=FindAncestor}}" />
+
                                 <Button
                                     x:Name="DocumentCloseButton"
                                     Grid.Column="2"

From 981370f2159fe33b2ba99c237b9f9f74f9269841 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=88=98=E6=99=93=E9=9D=92?= <569132102@qq.com>
Date: Fri, 3 Jul 2020 13:43:57 +0800
Subject: [PATCH 09/10] ..

---
 .../Components/AvalonDock/Controls/LayoutDocumentPaneControl.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/Components/AvalonDock/Controls/LayoutDocumentPaneControl.cs b/source/Components/AvalonDock/Controls/LayoutDocumentPaneControl.cs
index 53944d2d..da2c900f 100644
--- a/source/Components/AvalonDock/Controls/LayoutDocumentPaneControl.cs
+++ b/source/Components/AvalonDock/Controls/LayoutDocumentPaneControl.cs
@@ -96,7 +96,7 @@ protected override void OnItemsChanged(NotifyCollectionChangedEventArgs e)
 			{
 				foreach (var item in e.OldItems)
 				{
-					if (item is LayoutContent layoutContent)
+					if (item is LayoutContent layoutContent && layoutContent.TabItem != null)
 					{
 						layoutContent.TabItem.Model = null;
 						layoutContent.TabItem.ContextMenu = null;

From 5032524bae6e342dbb648a4c1d3fc3264f449db9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=88=98=E6=99=93=E9=9D=92?= <569132102@qq.com>
Date: Fri, 3 Jul 2020 15:01:43 +0800
Subject: [PATCH 10/10] modify code

---
 .../MainWindow.xaml.cs                        |  6 ++-
 .../AvalonDock/Controls/Extensions.cs         |  8 ++--
 .../LayoutAnchorableFloatingWindowControl.cs  |  2 +-
 .../Controls/LayoutAnchorablePaneControl.cs   |  2 +-
 .../Controls/LayoutAutoHideWindowControl.cs   |  2 +-
 .../Controls/LayoutDocumentPaneControl.cs     |  2 +-
 .../LayoutDocumentPaneGroupControl.cs         |  2 +-
 .../AvalonDock/Controls/LayoutGridControl.cs  |  6 +--
 .../AvalonDock/Controls/LayoutItem.cs         |  4 +-
 .../AvalonDock/Controls/LayoutPanelControl.cs | 43 ++++++++-----------
 .../Controls/Shell/Standard/NativeMethods.cs  | 18 +++++---
 .../AvalonDock/Layout/LayoutDocumentPane.cs   |  9 ++--
 .../AvalonDock/Layout/LayoutGroup.cs          |  2 +-
 .../Demos/ViewModels/WorkSpaceViewModel.cs    |  7 ++-
 source/MLibTest/MLibTest/MainWindow.xaml.cs   |  8 ++--
 15 files changed, 57 insertions(+), 64 deletions(-)

diff --git a/source/AvalonDocPanelMemoryLeaks/MainWindow.xaml.cs b/source/AvalonDocPanelMemoryLeaks/MainWindow.xaml.cs
index 2689d8b8..c17c60dc 100644
--- a/source/AvalonDocPanelMemoryLeaks/MainWindow.xaml.cs
+++ b/source/AvalonDocPanelMemoryLeaks/MainWindow.xaml.cs
@@ -34,8 +34,10 @@ private void Button_Click(object sender, RoutedEventArgs e)
             UserControl content = new UserControl();
             HeavyLoad = new HeavyLoad();
             content.DataContext = HeavyLoad;
-            LayoutDocument docDocument = new LayoutDocument();
-            docDocument.Content = content;
+            LayoutDocument docDocument = new LayoutDocument
+            {
+                Content = content
+            };
             docGrup.Children.Add(docDocument);
             docDocument.Closed += DocClosed;
         }
diff --git a/source/Components/AvalonDock/Controls/Extensions.cs b/source/Components/AvalonDock/Controls/Extensions.cs
index 9761f28e..fbcc5caf 100644
--- a/source/Components/AvalonDock/Controls/Extensions.cs
+++ b/source/Components/AvalonDock/Controls/Extensions.cs
@@ -28,8 +28,8 @@ public static IEnumerable<T> FindVisualChildren<T>(this DependencyObject depObj)
 			for (var i = 0; i < VisualTreeHelper.GetChildrenCount(depObj); i++)
 			{
 				var child = VisualTreeHelper.GetChild(depObj, i);
-				if (child is T)
-					yield return (T) child;
+				if (child is T t)
+					yield return t;
 				foreach (var childOfChild in FindVisualChildren<T>(child))
 					yield return childOfChild;
 			}
@@ -45,8 +45,8 @@ public static IEnumerable<T> FindLogicalChildren<T>(this DependencyObject depObj
 			if (depObj == null) yield break;
 			foreach (var child in LogicalTreeHelper.GetChildren(depObj).OfType<DependencyObject>())
 			{
-				if (child is T)
-					yield return (T) child;
+				if (child is T t)
+					yield return t;
 				foreach (var childOfChild in FindLogicalChildren<T>(child))
 					yield return childOfChild;
 			}
diff --git a/source/Components/AvalonDock/Controls/LayoutAnchorableFloatingWindowControl.cs b/source/Components/AvalonDock/Controls/LayoutAnchorableFloatingWindowControl.cs
index e8235e13..705fe1df 100644
--- a/source/Components/AvalonDock/Controls/LayoutAnchorableFloatingWindowControl.cs
+++ b/source/Components/AvalonDock/Controls/LayoutAnchorableFloatingWindowControl.cs
@@ -31,7 +31,7 @@ namespace AvalonDock.Controls
 	public class LayoutAnchorableFloatingWindowControl : LayoutFloatingWindowControl, IOverlayWindowHost
 	{
 		#region fields
-		private LayoutAnchorableFloatingWindow _model;
+		private readonly LayoutAnchorableFloatingWindow _model;
 		private OverlayWindow _overlayWindow = null;
 		private List<IDropArea> _dropAreas = null;
 		#endregion fields
diff --git a/source/Components/AvalonDock/Controls/LayoutAnchorablePaneControl.cs b/source/Components/AvalonDock/Controls/LayoutAnchorablePaneControl.cs
index 5f44d6ed..117ea059 100644
--- a/source/Components/AvalonDock/Controls/LayoutAnchorablePaneControl.cs
+++ b/source/Components/AvalonDock/Controls/LayoutAnchorablePaneControl.cs
@@ -26,7 +26,7 @@ namespace AvalonDock.Controls
 	public class LayoutAnchorablePaneControl : TabControlEx, ILayoutControl//, ILogicalChildrenContainer
 	{
 		#region fields
-		private LayoutAnchorablePane _model;
+		private readonly LayoutAnchorablePane _model;
 		#endregion fields
 
 		#region Constructors
diff --git a/source/Components/AvalonDock/Controls/LayoutAutoHideWindowControl.cs b/source/Components/AvalonDock/Controls/LayoutAutoHideWindowControl.cs
index 053aaedb..68c3fc74 100644
--- a/source/Components/AvalonDock/Controls/LayoutAutoHideWindowControl.cs
+++ b/source/Components/AvalonDock/Controls/LayoutAutoHideWindowControl.cs
@@ -34,7 +34,7 @@ public class LayoutAutoHideWindowControl : HwndHost, ILayoutControl
 		private LayoutAnchorable _model;
 		private HwndSource _internalHwndSource = null;
 		private IntPtr parentWindowHandle;
-		private ContentPresenter _internalHostPresenter = new ContentPresenter();
+		private readonly ContentPresenter _internalHostPresenter = new ContentPresenter();
 		private Grid _internalGrid = null;
 		private AnchorSide _side;
 		private LayoutGridResizerControl _resizer = null;
diff --git a/source/Components/AvalonDock/Controls/LayoutDocumentPaneControl.cs b/source/Components/AvalonDock/Controls/LayoutDocumentPaneControl.cs
index da2c900f..9e74d48f 100644
--- a/source/Components/AvalonDock/Controls/LayoutDocumentPaneControl.cs
+++ b/source/Components/AvalonDock/Controls/LayoutDocumentPaneControl.cs
@@ -29,7 +29,7 @@ namespace AvalonDock.Controls
 	public class LayoutDocumentPaneControl : TabControlEx, ILayoutControl//, ILogicalChildrenContainer
 	{
 		#region fields
-		private LayoutDocumentPane _model;
+		private readonly LayoutDocumentPane _model;
 		#endregion fields
 
 		#region Constructors
diff --git a/source/Components/AvalonDock/Controls/LayoutDocumentPaneGroupControl.cs b/source/Components/AvalonDock/Controls/LayoutDocumentPaneGroupControl.cs
index b5ea43f1..50637401 100644
--- a/source/Components/AvalonDock/Controls/LayoutDocumentPaneGroupControl.cs
+++ b/source/Components/AvalonDock/Controls/LayoutDocumentPaneGroupControl.cs
@@ -22,7 +22,7 @@ namespace AvalonDock.Controls
 	public class LayoutDocumentPaneGroupControl : LayoutGridControl<ILayoutDocumentPane>, ILayoutControl
 	{
 		#region fields
-		private LayoutDocumentPaneGroup _model;
+		private readonly LayoutDocumentPaneGroup _model;
 		#endregion fields
 
 		#region Constructors
diff --git a/source/Components/AvalonDock/Controls/LayoutGridControl.cs b/source/Components/AvalonDock/Controls/LayoutGridControl.cs
index 9a7afdb3..dbd984a7 100644
--- a/source/Components/AvalonDock/Controls/LayoutGridControl.cs
+++ b/source/Components/AvalonDock/Controls/LayoutGridControl.cs
@@ -34,11 +34,11 @@ namespace AvalonDock.Controls
 	public abstract class LayoutGridControl<T> : Grid, ILayoutControl, IAdjustableSizeLayout where T : class, ILayoutPanelElement
 	{
 		#region fields
-		private LayoutPositionableGroup<T> _model;
-		private Orientation _orientation;
+		private readonly LayoutPositionableGroup<T> _model;
+		private readonly Orientation _orientation;
 		private bool _initialized;
 		private ChildrenTreeChange? _asyncRefreshCalled;
-		private ReentrantFlag _fixingChildrenDockLengths = new ReentrantFlag();
+		private readonly ReentrantFlag _fixingChildrenDockLengths = new ReentrantFlag();
 		private Border _resizerGhost = null;
 		private Window _resizerWindowHost = null;
 		private Vector _initialStartPoint;
diff --git a/source/Components/AvalonDock/Controls/LayoutItem.cs b/source/Components/AvalonDock/Controls/LayoutItem.cs
index 513c8e93..749ad92c 100644
--- a/source/Components/AvalonDock/Controls/LayoutItem.cs
+++ b/source/Components/AvalonDock/Controls/LayoutItem.cs
@@ -39,8 +39,8 @@ public abstract class LayoutItem : FrameworkElement
 		private ICommand _defaultMoveToNextTabGroupCommand;
 		private ICommand _defaultMoveToPreviousTabGroupCommand;
 		private ContentPresenter _view = null;
-		private ReentrantFlag _isSelectedReentrantFlag = new ReentrantFlag();
-		private ReentrantFlag _isActiveReentrantFlag = new ReentrantFlag();
+		private readonly ReentrantFlag _isSelectedReentrantFlag = new ReentrantFlag();
+		private readonly ReentrantFlag _isActiveReentrantFlag = new ReentrantFlag();
 		#endregion fields
 
 		#region Constructors
diff --git a/source/Components/AvalonDock/Controls/LayoutPanelControl.cs b/source/Components/AvalonDock/Controls/LayoutPanelControl.cs
index 72fbccfc..968bd59a 100644
--- a/source/Components/AvalonDock/Controls/LayoutPanelControl.cs
+++ b/source/Components/AvalonDock/Controls/LayoutPanelControl.cs
@@ -21,7 +21,7 @@ namespace AvalonDock.Controls
 	public class LayoutPanelControl : LayoutGridControl<ILayoutPanelElement>, ILayoutControl
 	{
 		#region fields
-		private LayoutPanel _model;
+		private readonly LayoutPanel _model;
 		#endregion fields
 
 		#region Constructors
@@ -41,34 +41,29 @@ protected override void OnFixChildrenDockLengths()
 		{
 			if (ActualWidth == 0.0 || ActualHeight == 0.0) return;
 
-			var modelAsPositionableElement = _model as ILayoutPositionableElementWithActualSize;
-			#region Setup DockWidth/Height for children
-			if (_model.Orientation == Orientation.Horizontal)
+            #region Setup DockWidth/Height for children
+            if (_model.Orientation == Orientation.Horizontal)
 			{
 				if (_model.ContainsChildOfType<LayoutDocumentPane, LayoutDocumentPaneGroup>())
 				{
 					for (var i = 0; i < _model.Children.Count; i++)
 					{
-						var childContainerModel = _model.Children[i] as ILayoutContainer;
-						var childPositionableModel = _model.Children[i] as ILayoutPositionableElement;
-
-						if (childContainerModel != null &&
-							(childContainerModel.IsOfType<LayoutDocumentPane, LayoutDocumentPaneGroup>() ||
-							 childContainerModel.ContainsChildOfType<LayoutDocumentPane, LayoutDocumentPaneGroup>()))
+                        if (_model.Children[i] as ILayoutContainer != null &&
+							((_model.Children[i] as ILayoutContainer).IsOfType<LayoutDocumentPane, LayoutDocumentPaneGroup>() ||
+                             (_model.Children[i] as ILayoutContainer).ContainsChildOfType<LayoutDocumentPane, LayoutDocumentPaneGroup>()))
 						{
 							// Keep set values (from XML for instance)
-							if(!childPositionableModel.DockWidth.IsStar) childPositionableModel.DockWidth = new GridLength(1.0, GridUnitType.Star);
+							if(!(_model.Children[i] as ILayoutPositionableElement).DockWidth.IsStar) (_model.Children[i] as ILayoutPositionableElement).DockWidth = new GridLength(1.0, GridUnitType.Star);
 						}
-						else if (childPositionableModel != null && childPositionableModel.DockWidth.IsStar)
+						else if (_model.Children[i] as ILayoutPositionableElement != null && (_model.Children[i] as ILayoutPositionableElement).DockWidth.IsStar)
 						{
-							var childPositionableModelWidthActualSize = childPositionableModel as ILayoutPositionableElementWithActualSize;
-							var childDockMinWidth = childPositionableModel.CalculatedDockMinWidth();
+							var childPositionableModelWidthActualSize = _model.Children[i] as ILayoutPositionableElement as ILayoutPositionableElementWithActualSize;
+							var childDockMinWidth = (_model.Children[i] as ILayoutPositionableElement).CalculatedDockMinWidth();
 							var widthToSet = Math.Max(childPositionableModelWidthActualSize.ActualWidth, childDockMinWidth);
 
 							widthToSet = Math.Min(widthToSet, ActualWidth / 2.0);
 							widthToSet = Math.Max(widthToSet, childDockMinWidth);
-
-							childPositionableModel.DockWidth = new GridLength(widthToSet, GridUnitType.Pixel);
+                            (_model.Children[i] as ILayoutPositionableElement).DockWidth = new GridLength(widthToSet, GridUnitType.Pixel);
 						}
 					}
 				}
@@ -91,25 +86,21 @@ protected override void OnFixChildrenDockLengths()
 				{
 					for (var i = 0; i < _model.Children.Count; i++)
 					{
-						var childContainerModel = _model.Children[i] as ILayoutContainer;
-						var childPositionableModel = _model.Children[i] as ILayoutPositionableElement;
-
-						if (childContainerModel != null &&
+                        if (_model.Children[i] is ILayoutContainer childContainerModel &&
 							(childContainerModel.IsOfType<LayoutDocumentPane, LayoutDocumentPaneGroup>() ||
 							 childContainerModel.ContainsChildOfType<LayoutDocumentPane, LayoutDocumentPaneGroup>()))
 						{
 							// Keep set values (from XML for instance)
-							if(!childPositionableModel.DockHeight.IsStar) childPositionableModel.DockHeight = new GridLength(1.0, GridUnitType.Star);
+							if(!(_model.Children[i] as ILayoutPositionableElement).DockHeight.IsStar) (_model.Children[i] as ILayoutPositionableElement).DockHeight = new GridLength(1.0, GridUnitType.Star);
 						}
-						else if (childPositionableModel != null && childPositionableModel.DockHeight.IsStar)
+						else if (_model.Children[i] as ILayoutPositionableElement != null && (_model.Children[i] as ILayoutPositionableElement).DockHeight.IsStar)
 						{
-							var childPositionableModelWidthActualSize = childPositionableModel as ILayoutPositionableElementWithActualSize;
-							var childDockMinHeight = childPositionableModel.CalculatedDockMinHeight();
+							var childPositionableModelWidthActualSize = _model.Children[i] as ILayoutPositionableElement as ILayoutPositionableElementWithActualSize;
+							var childDockMinHeight = (_model.Children[i] as ILayoutPositionableElement).CalculatedDockMinHeight();
 							var heightToSet = Math.Max(childPositionableModelWidthActualSize.ActualHeight, childDockMinHeight);
 							heightToSet = Math.Min(heightToSet, ActualHeight / 2.0);
 							heightToSet = Math.Max(heightToSet, childDockMinHeight);
-
-							childPositionableModel.DockHeight = new GridLength(heightToSet, GridUnitType.Pixel);
+                            (_model.Children[i] as ILayoutPositionableElement).DockHeight = new GridLength(heightToSet, GridUnitType.Pixel);
 						}
 					}
 				}
diff --git a/source/Components/AvalonDock/Controls/Shell/Standard/NativeMethods.cs b/source/Components/AvalonDock/Controls/Shell/Standard/NativeMethods.cs
index be78b405..e316c251 100644
--- a/source/Components/AvalonDock/Controls/Shell/Standard/NativeMethods.cs
+++ b/source/Components/AvalonDock/Controls/Shell/Standard/NativeMethods.cs
@@ -1907,9 +1907,11 @@ public static NONCLIENTMETRICS VistaMetricsStruct
 		{
 			get
 			{
-				var ncm = new NONCLIENTMETRICS();
-				ncm.cbSize = Marshal.SizeOf(typeof(NONCLIENTMETRICS));
-				return ncm;
+                var ncm = new NONCLIENTMETRICS
+                {
+                    cbSize = Marshal.SizeOf(typeof(NONCLIENTMETRICS))
+                };
+                return ncm;
 			}
 		}
 
@@ -1918,10 +1920,12 @@ public static NONCLIENTMETRICS XPMetricsStruct
 		{
 			get
 			{
-				var ncm = new NONCLIENTMETRICS();
-				// Account for the missing iPaddedBorderWidth
-				ncm.cbSize = Marshal.SizeOf(typeof(NONCLIENTMETRICS)) - sizeof(int);
-				return ncm;
+                var ncm = new NONCLIENTMETRICS
+                {
+                    // Account for the missing iPaddedBorderWidth
+                    cbSize = Marshal.SizeOf(typeof(NONCLIENTMETRICS)) - sizeof(int)
+                };
+                return ncm;
 			}
 		}
 	}
diff --git a/source/Components/AvalonDock/Layout/LayoutDocumentPane.cs b/source/Components/AvalonDock/Layout/LayoutDocumentPane.cs
index 1bd5adaf..023bf548 100644
--- a/source/Components/AvalonDock/Layout/LayoutDocumentPane.cs
+++ b/source/Components/AvalonDock/Layout/LayoutDocumentPane.cs
@@ -29,7 +29,7 @@ public class LayoutDocumentPane : LayoutPositionableGroup<LayoutContent>, ILayou
 		string _id;
 
 		[XmlIgnore]
-		bool _autoFixSelectedContent = true;
+        readonly bool _autoFixSelectedContent = true;
 		#endregion fields
 
 		#region Constructors
@@ -111,7 +111,7 @@ public IEnumerable<LayoutContent> ChildrenSorted
 		protected override bool GetVisibility()
 		{
 			if (Parent is LayoutDocumentPaneGroup)
-				return ChildrenCount > 0 && Children.Any(c => c is LayoutDocument && ((LayoutDocument)c).IsVisible || c is LayoutAnchorable);
+				return ChildrenCount > 0 && Children.Any(c => (c is LayoutDocument document && document.IsVisible) || c is LayoutAnchorable);
 			return true;
 		}
 
@@ -200,9 +200,8 @@ public override void ConsoleDump(int tab)
 		/// <returns></returns>
 		public int IndexOf(LayoutContent content)
 		{
-			var documentChild = content as LayoutDocument;
-			return documentChild == null ? -1 : Children.IndexOf(documentChild);
-		}
+            return !(content is LayoutDocument documentChild) ? -1 : Children.IndexOf(documentChild);
+        }
 
 		/// <summary>Invalidates the current <see cref="SelectedContentIndex"/> and sets the index for the next avialable child with IsEnabled == true.</summary>
 		internal void SetNextSelectedIndex()
diff --git a/source/Components/AvalonDock/Layout/LayoutGroup.cs b/source/Components/AvalonDock/Layout/LayoutGroup.cs
index 62e8951a..17f27b43 100644
--- a/source/Components/AvalonDock/Layout/LayoutGroup.cs
+++ b/source/Components/AvalonDock/Layout/LayoutGroup.cs
@@ -25,7 +25,7 @@ namespace AvalonDock.Layout
 	public abstract class LayoutGroup<T> : LayoutGroupBase, ILayoutGroup, IXmlSerializable where T : class, ILayoutElement
 	{
 		#region fields
-		private ObservableCollection<T> _children = new ObservableCollection<T>();
+		private readonly ObservableCollection<T> _children = new ObservableCollection<T>();
 		private bool _isVisible = true;
 		#endregion fields
 
diff --git a/source/MLibTest/MLibTest/Demos/ViewModels/WorkSpaceViewModel.cs b/source/MLibTest/MLibTest/Demos/ViewModels/WorkSpaceViewModel.cs
index 6441eb30..097f5740 100644
--- a/source/MLibTest/MLibTest/Demos/ViewModels/WorkSpaceViewModel.cs
+++ b/source/MLibTest/MLibTest/Demos/ViewModels/WorkSpaceViewModel.cs
@@ -93,7 +93,7 @@ public string DisplayName
 	internal class WorkSpaceViewModel : MLibTest.ViewModels.Base.ViewModelBase, IWorkSpaceViewModel
 	{
 		#region fields
-		private ObservableCollection<DocumentViewModel> _files = new ObservableCollection<DocumentViewModel>();
+		private readonly ObservableCollection<DocumentViewModel> _files = new ObservableCollection<DocumentViewModel>();
 		private ToolViewModel[] _tools = null;
 
 		private ICommand _openCommand = null;
@@ -138,9 +138,8 @@ public DocumentViewModel ActiveDocument
 					_activeDocument = value;
 					RaisePropertyChanged(nameof(ActiveDocument));
 
-					if (ActiveDocumentChanged != null)
-						ActiveDocumentChanged(this, EventArgs.Empty);
-				}
+                    ActiveDocumentChanged?.Invoke(this, EventArgs.Empty);
+                }
 			}
 		}
 
diff --git a/source/MLibTest/MLibTest/MainWindow.xaml.cs b/source/MLibTest/MLibTest/MainWindow.xaml.cs
index 192af7e1..5fdf7cf2 100644
--- a/source/MLibTest/MLibTest/MainWindow.xaml.cs
+++ b/source/MLibTest/MLibTest/MainWindow.xaml.cs
@@ -170,12 +170,10 @@ internal void OnLayoutLoaded_Event(object sender, LayoutLoadedEventArgs layoutLo
 
 		internal async void OnLoadLayoutAsync(object parameter = null)
 		{
-			AppViewModel wspace = this.DataContext as AppViewModel;
-			
-			if (wspace != null)
-				wspace.CloseAllDocuments();
+            if (this.DataContext is AppViewModel wspace)
+                wspace.CloseAllDocuments();
 
-			App myApp = (App)Application.Current;
+            App myApp = (App)Application.Current;
 
 			LayoutLoaderResult LoaderResult = await myApp.LayoutLoaded.GetLayoutString(OnLayoutLoaded_Event);