Minor performance optimizations

Author: ENikS

src/Storage/StagedStrategyChain.cs

@@ -19,11 +19,10 @@ public class StagedStrategyChain<TStrategyType, TStageEnum> : IStagedStrategyCha
     {
         #region Fields
 
+        private static readonly int _size = typeof(TStageEnum).GetTypeInfo().DeclaredFields.Count(f => f.IsPublic && f.IsStatic);
         private readonly object _lockObject = new object();
         private readonly StagedStrategyChain<TStrategyType, TStageEnum> _innerChain;
-        private readonly IList<TStrategyType>[] _stages =  new IList<TStrategyType>[typeof(TStageEnum).GetTypeInfo()
-                                                                                                      .DeclaredFields
-                                                                                                      .Count(f => f.IsPublic && f.IsStatic)];
+        private readonly IList<TStrategyType>[] _stages =  new IList<TStrategyType>[_size];
 
         private IEnumerable<TStrategyType> _cache;
 

src/UnityContainer.ContainerContext.cs

@@ -27,6 +27,7 @@ private class ContainerContext : ExtensionContext,
         {
             #region Fields
 
+            private readonly object syncRoot = new object();
             private readonly UnityContainer _container;
 
             #endregion
@@ -47,9 +48,52 @@ public ContainerContext(UnityContainer container)
 
             public override IUnityContainer Container => _container;
 
-            public override IStagedStrategyChain<IBuilderStrategy, UnityBuildStage> Strategies => _container._strategies;
+            public override IStagedStrategyChain<IBuilderStrategy, UnityBuildStage> Strategies
+            {
+                get
+                {
+                    if (null != _container._parent && 
+                        _container._parent._strategies == _container._strategies)
+                    {
+                        lock (syncRoot)
+                        {
+                            if (_container._parent._strategies == _container._strategies)
+                            {
+                                _container._strategies.Invalidated -= _container.OnStrategiesChanged;
+                                _container._strategies = 
+                                    new StagedStrategyChain<IBuilderStrategy, UnityBuildStage>(_container._parent._strategies);
+                                _container._strategies.Invalidated += _container.OnStrategiesChanged;
+                                _container._lifetimeContainer.Add(_container._strategies);
+
+                            }
+                        }
+                    }
+
+                    return _container._strategies;
+                }
+            }
 
-            public override IStagedStrategyChain<IBuilderStrategy, BuilderStage> BuildPlanStrategies => _container._buildPlanStrategies;
+            public override IStagedStrategyChain<IBuilderStrategy, BuilderStage> BuildPlanStrategies
+            {
+                get
+                {
+                    if (null != _container._parent && 
+                        _container._parent._buildPlanStrategies == _container._buildPlanStrategies)
+                    {
+                        lock (syncRoot)
+                        {
+                            if (_container._parent._buildPlanStrategies == _container._buildPlanStrategies)
+                            {
+                                _container._buildPlanStrategies = 
+                                    new StagedStrategyChain<IBuilderStrategy, BuilderStage>(_container._parent._buildPlanStrategies);
+                                _container._lifetimeContainer.Add(_container._buildPlanStrategies);
+                            }
+                        }
+                    }
+
+                    return _container._buildPlanStrategies;
+                }
+            }
 
             public override IPolicyList Policies { get; }
 

src/UnityContainer.Implementation.cs

@@ -39,8 +39,8 @@ public partial class UnityContainer
         private readonly ContainerContext _context;
 
         // Strategies
-        private readonly StagedStrategyChain<IBuilderStrategy, UnityBuildStage> _strategies;
-        private readonly StagedStrategyChain<IBuilderStrategy, BuilderStage> _buildPlanStrategies;
+        private StagedStrategyChain<IBuilderStrategy, UnityBuildStage> _strategies;
+        private StagedStrategyChain<IBuilderStrategy, BuilderStage> _buildPlanStrategies;
 
         // Events
         private event EventHandler<RegisterEventArgs> Registering;
@@ -68,11 +68,13 @@ private UnityContainer(UnityContainer parent)
             _parent?._lifetimeContainer.Add(this);
 
             // Strategies
-            _strategies = new StagedStrategyChain<IBuilderStrategy, UnityBuildStage>(_parent?._strategies);
-            _buildPlanStrategies = new StagedStrategyChain<IBuilderStrategy, BuilderStage>(_parent?._buildPlanStrategies);
+            _strategies = _parent?._strategies;
+            _buildPlanStrategies = _parent?._buildPlanStrategies;
+            _registerTypeStrategies = _parent?._registerTypeStrategies;
+            _strategyChain = _parent?._strategyChain;
 
             // Lifetime
-            _lifetimeContainer = new LifetimeContainer(this) { _strategies, _buildPlanStrategies };
+            _lifetimeContainer = new LifetimeContainer(this);
 
             // Default Policies
             if (null == _parent) InitializeRootContainer();
@@ -84,7 +86,6 @@ private UnityContainer(UnityContainer parent)
             _context = new ContainerContext(this);
 
             // Caches
-            OnStrategiesChanged(this, null);
             _strategies.Invalidated += OnStrategiesChanged;
         }
 
@@ -95,6 +96,12 @@ private UnityContainer(UnityContainer parent)
 
         protected void InitializeRootContainer()
         {
+            // Initialize strategies
+            _strategies = new StagedStrategyChain<IBuilderStrategy, UnityBuildStage>();
+            _buildPlanStrategies = new StagedStrategyChain<IBuilderStrategy, BuilderStage>();
+            _lifetimeContainer.Add(_strategies);
+            _lifetimeContainer.Add(_buildPlanStrategies);
+
             // Main strategy chain
             _strategies.Add(new BuildKeyMappingStrategy(), UnityBuildStage.TypeMapping);
             _strategies.Add(new LifetimeStrategy(), UnityBuildStage.Lifetime);
@@ -116,6 +123,10 @@ protected void InitializeRootContainer()
             this[typeof(IEnumerable<>), string.Empty, typeof(IBuildPlanCreatorPolicy)] = 
                 new DelegateBasedBuildPlanCreatorPolicy(typeof(UnityContainer).GetTypeInfo().GetDeclaredMethod(nameof(ResolveEnumerable)),
                                                         context => context.BuildKey.Type.GetTypeInfo().GenericTypeArguments.First());
+            // Caches
+            _registerTypeStrategies = _strategies.OfType<IRegisterTypeStrategy>().ToArray();
+            _strategyChain = new StrategyChain(_strategies);
+
             // Register this instance
             RegisterInstance(typeof(IUnityContainer), null, this, new ContainerLifetimeManager());
         }

src/UnityContainer.Public.cs

@@ -2,6 +2,8 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
+using Unity.Builder;
+using Unity.Builder.Strategy;
 using Unity.Events;
 using Unity.Extension;
 using Unity.Policy;
@@ -83,8 +85,9 @@ public IUnityContainer RemoveAllExtensions()
             _extensions.Clear();
 
             // Reset our policies, strategies, and registered names to reset to "zero"
-            _strategies.Clear();
-            ((IPolicyList)_context).ClearAll();
+            _strategies = new StagedStrategyChain<IBuilderStrategy, UnityBuildStage>(_parent?._strategies);
+
+            _context.ClearAll();
 
             if (null == _parent)
                 InitializeRootContainer();