Merge branch 'master' of https://github.com/unitycontainer/container into v5.x

Author: ENikS

src/Extension/Diagnostic.cs

@@ -1,8 +1,52 @@
-using System;
+using System;
 using System.Diagnostics;
+using Unity.Extension;
 
 namespace Unity
 {
+    /// <summary>
+    /// Diagnostic extension implements validating when calling <see cref="IUnityContainer.RegisterType"/>, 
+    /// <see cref="IUnityContainer.Resolve"/>, and <see cref="IUnityContainer.BuildUp"/> methods. When executed 
+    /// these methods provide extra layer of verification and validation as well 
+    /// as more detailed reporting of error conditions.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// Unity uses reflection to gather information about types, members, and parameters. 
+    /// It is quite obvious that it takes significant amount of time during execution. So, 
+    /// to optimize performance all these verifications where moved to the Diagnostic
+    /// extension. It is recommended to include this extension only during 
+    /// development cycle and refrain from executing it in production 
+    /// environment.
+    /// </para>
+    /// <para>
+    /// This extension can be registered in two ways: by adding an extension or by calling
+    /// <c>EnableDiagnostic()</c> extension method on container. 
+    /// Adding extension to container will work in any build, where <c>EnableDiagnostic()</c>
+    /// will only enable it in DEBUG mode. 
+    /// </para>
+    /// </remarks>
+    /// <example>
+    /// <code>
+    ///     var container = new UnityContainer();
+    /// #if DEBUG
+    ///     container.AddExtension(new Diagnostic());
+    /// #endif
+    /// </code>
+    /// <code>
+    /// var container = new UnityContainer();
+    /// container.EnableDiagnostic();
+    /// </code>
+    /// </example>
+    public class Diagnostic : UnityContainerExtension
+    {
+        protected override void Initialize()
+        {
+            ((UnityContainer)Container).SetDefaultPolicies = UnityContainer.SetDiagnosticPolicies;
+            ((UnityContainer)Container).SetDefaultPolicies((UnityContainer)Container);
+        }
+    }
+
     public static class DiagnosticExtensions
     {
         /// <summary>
@@ -54,9 +98,10 @@ public static void EnableDebugDiagnostic(this UnityContainer container)
         public static UnityContainer EnableDiagnostic(this UnityContainer container)
         {
             if (null == container) throw new ArgumentNullException(nameof(container));
-               
+
             container.AddExtension(new Diagnostic());
             return container;
         }
     }
+
 }

src/Extensions/DiagnosticExtensions.cs renamed to src/Extensions/Diagnostic.cs

@@ -1,6 +1,4 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
+using System.Linq;
 using Unity.Builder;
 using Unity.Processors;
 using Unity.Storage;

src/Extension/Legacy.cs renamed to src/Extensions/Legacy.cs

@@ -0,0 +1,39 @@
+using Unity.Extension;
+using Unity.Policy;
+
+namespace Unity
+{
+    /// <summary>
+    /// This extension forces the container to only use activated strategies during resolution
+    /// </summary>
+    /// <remarks>
+    /// This extension forces compatibility with systems without support for runtime compilers. 
+    /// One of such systems is iOS.
+    /// </remarks>
+    public class ForceActivation : UnityContainerExtension
+    {
+        protected override void Initialize()
+        {
+            var unity = (UnityContainer)Container;
+
+            unity._buildStrategy = unity.ResolvingFactory;
+            unity.Defaults.Set(typeof(ResolveDelegateFactory), unity._buildStrategy);
+        }
+    }
+
+    /// <summary>
+    /// This extension forces the container to only use compiled strategies during resolution
+    /// </summary>
+    public class ForceCompillation : UnityContainerExtension
+    {
+        protected override void Initialize()
+        {
+            var unity = (UnityContainer)Container;
+
+            unity._buildStrategy = unity.CompilingFactory;
+            unity.Defaults.Set(typeof(ResolveDelegateFactory), unity._buildStrategy);
+
+        }
+    }
+
+}

src/Extensions/Strategies.cs

@@ -1,25 +1,5 @@
 using System;
-using System.Runtime.CompilerServices;
 using System.Security;
 
-[assembly:CLSCompliant(true)]
+[assembly: CLSCompliant(true)]
 [assembly: AllowPartiallyTrustedCallers]
-
-[assembly: InternalsVisibleTo("Performance, PublicKey=" +
-                              "002400000480000094000000060200000024000052534131000400000100010037b16015885a7a" +
-                              "c3c63f3c10b23972ec0dfd6db643eaef45ea2297bdfdc53b1945017fc76fd038dc6e7bf9190024" +
-                              "d5435fa49630fdfd143e3149a1506b895fbcce017df1d4f0eac6f05f6d257be45c7be9a8aa8d3d" +
-                              "4164892dc75e7c379a22da0d986db393fbd09e4ba42398c80a305361553ef90eb3484d9cf12df9" +
-                              "0fc0e6e3")]
-[assembly: InternalsVisibleTo("Unity.Specification.Tests, PublicKey=" +
-                              "002400000480000094000000060200000024000052534131000400000100010037b16015885a7a" +
-                              "c3c63f3c10b23972ec0dfd6db643eaef45ea2297bdfdc53b1945017fc76fd038dc6e7bf9190024" +
-                              "d5435fa49630fdfd143e3149a1506b895fbcce017df1d4f0eac6f05f6d257be45c7be9a8aa8d3d" +
-                              "4164892dc75e7c379a22da0d986db393fbd09e4ba42398c80a305361553ef90eb3484d9cf12df9" +
-                              "0fc0e6e3")]
-[assembly: InternalsVisibleTo("Unity.Specification.Tests.Diagnostic, PublicKey=" +
-                              "002400000480000094000000060200000024000052534131000400000100010037b16015885a7a" +
-                              "c3c63f3c10b23972ec0dfd6db643eaef45ea2297bdfdc53b1945017fc76fd038dc6e7bf9190024" +
-                              "d5435fa49630fdfd143e3149a1506b895fbcce017df1d4f0eac6f05f6d257be45c7be9a8aa8d3d" +
-                              "4164892dc75e7c379a22da0d986db393fbd09e4ba42398c80a305361553ef90eb3484d9cf12df9" +
-                              "0fc0e6e3")]

src/Properties/AssemblyInfo.cs

@@ -2,13 +2,8 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
-using System.Reflection;
-using Unity.Builder;
-using Unity.Injection;
 using Unity.Policy;
-using Unity.Processors;
 using Unity.Registration;
-using Unity.Storage;
 
 namespace Unity
 {
@@ -18,40 +13,12 @@ public partial class UnityContainer
     {
         #region Fields
 
-        private readonly ResolveDelegateFactory _buildStrategy = OptimizingFactory;
+        internal ResolveDelegateFactory _buildStrategy = OptimizingFactory;
 
         #endregion
 
-        internal enum BuildStrategy
-        {
-            Compiled,
-
-            Resolved,
-
-            Optimized
-        }
 
-        #region Diagnostic Constructor
-
-        internal UnityContainer(BuildStrategy strategy)
-            : this()
-        {
-            switch (strategy)
-            {
-                case BuildStrategy.Compiled:
-                    _buildStrategy = CompilingFactory;
-                    Defaults.Set(typeof(ResolveDelegateFactory), _buildStrategy);
-                    break;
-
-                case BuildStrategy.Resolved:
-                    _buildStrategy = ResolvingFactory;
-                    Defaults.Set(typeof(ResolveDelegateFactory), _buildStrategy);
-                    break;
-            }
-        }
-
-
-        #endregion
+        #region Debug Support
 
         private string DebugName()
         {
@@ -80,5 +47,7 @@ public UnityContainerDebugProxy(IUnityContainer container)
             public IEnumerable<IContainerRegistration> Registrations => _container.Registrations;
 
         }
+
+        #endregion
     }
 }

src/UnityContainer.Diagnostic.cs

@@ -208,7 +208,7 @@ private static ResolveDelegate<BuilderContext> OptimizingFactory(ref BuilderCont
             };
         }
 
-        private ResolveDelegate<BuilderContext> CompilingFactory(ref BuilderContext context)
+        internal ResolveDelegate<BuilderContext> CompilingFactory(ref BuilderContext context)
         {
             var expressions = new List<Expression>();
             var type = context.Type;
@@ -228,7 +228,7 @@ private ResolveDelegate<BuilderContext> CompilingFactory(ref BuilderContext cont
             return lambda.Compile();
         }
 
-        private ResolveDelegate<BuilderContext> ResolvingFactory(ref BuilderContext context)
+        internal ResolveDelegate<BuilderContext> ResolvingFactory(ref BuilderContext context)
         {
             ResolveDelegate<BuilderContext> seed = null;
             var type = context.Type;

src/UnityContainer.Resolution.cs

@@ -2,7 +2,6 @@
 using Runner.Setup;
 using System.Collections.Generic;
 using Unity;
-using Unity.Builder;
 
 namespace Runner.Tests
 {
@@ -16,7 +15,7 @@ public class Compiled
         [IterationSetup]
         public virtual void SetupContainer()
         {
-            _container = new UnityContainer(Unity.UnityContainer.BuildStrategy.Compiled);
+            _container = new UnityContainer().AddExtension(new ForceCompillation());
 
             _container.RegisterType<Poco>();
             _container.RegisterType<IFoo, Foo>();

tests/Performance/Tests/Compiled.cs

@@ -16,7 +16,7 @@ public class PreCompiled
         [IterationSetup]
         public virtual void SetupContainer()
         {
-            _container = new UnityContainer(Unity.UnityContainer.BuildStrategy.Compiled);
+            _container = new UnityContainer().AddExtension(new ForceCompillation());
 
             _container.RegisterType<Poco>();
             _container.RegisterType<IFoo, Foo>();

tests/Performance/Tests/PreCompiled.cs

@@ -16,7 +16,7 @@ public class PreResolved
         [IterationSetup]
         public virtual void SetupContainer()
         {
-            _container = new UnityContainer(Unity.UnityContainer.BuildStrategy.Resolved);
+            _container = new UnityContainer().AddExtension(new ForceActivation());
 
             _container.RegisterType<Poco>();
             _container.RegisterType<IFoo, Foo>();