Fixes #12

Fixes #10

Author: ENikS

src/Builder/Strategy/BuilderStrategy.cs

@@ -27,25 +27,5 @@ public virtual void PreBuildUp(IBuilderContext context)
         public virtual void PostBuildUp(IBuilderContext context)
         {
         }
-
-        /// <summary>
-        /// Called during the chain of responsibility for a teardown operation. The
-        /// PreTearDown method is called when the chain is being executed in the
-        /// forward direction.
-        /// </summary>
-        /// <param name="context">Context of the teardown operation.</param>
-        public virtual void PreTearDown(IBuilderContext context)
-        {
-        }
-
-        /// <summary>
-        /// Called during the chain of responsibility for a teardown operation. The
-        /// PostTearDown method is called when the chain has finished the PreTearDown
-        /// phase and executes in reverse order from the PreTearDown calls.
-        /// </summary>
-        /// <param name="context">Context of the teardown operation.</param>
-        public virtual void PostTearDown(IBuilderContext context)
-        {
-        }
     }
 }

src/Builder/Strategy/IBuilderStrategy.cs

@@ -24,21 +24,5 @@ public interface IBuilderStrategy
         /// </summary>
         /// <param name="context">Context of the build operation.</param>
         void PostBuildUp(IBuilderContext context);
-
-        /// <summary>
-        /// Called during the chain of responsibility for a teardown operation. The
-        /// PreTearDown method is called when the chain is being executed in the
-        /// forward direction.
-        /// </summary>
-        /// <param name="context">Context of the teardown operation.</param>
-        void PreTearDown(IBuilderContext context);
-
-        /// <summary>
-        /// Called during the chain of responsibility for a teardown operation. The
-        /// PostTearDown method is called when the chain has finished the PreTearDown
-        /// phase and executes in reverse order from the PreTearDown calls.
-        /// </summary>
-        /// <param name="context">Context of the teardown operation.</param>
-        void PostTearDown(IBuilderContext context);
     }
 }

src/Builder/Strategy/IRegisterStrategy.cs

@@ -0,0 +1,42 @@
+using System;
+using System.Collections.Generic;
+using Unity.Lifetime;
+using Unity.Registration;
+
+namespace Unity.Builder.Strategy
+{
+    public interface IRegisterStrategy
+    {
+        /// <summary>
+        /// Register a type mapping with the container, where the created instances will use
+        /// the given <see cref="LifetimeManager"/>.
+        /// </summary>
+        /// <param name="typeFrom"><see cref="Type"/> that will be requested.</param>
+        /// <param name="typeTo"><see cref="Type"/> that will actually be returned.</param>
+        /// <param name="name">Name to use for registration, null if a default registration.</param>
+        /// <param name="lifetimeManager">The <see cref="LifetimeManager"/> that controls the lifetime
+        /// of the returned instance.</param>
+        /// <param name="injectionMembers">Injection configuration objects. Can be null.</param>
+        /// <returns>List of policies this registration generates.</returns>
+        IEnumerable<IBuilderPolicy> RegisterType(Type typeFrom, Type typeTo, string name, LifetimeManager lifetimeManager, params InjectionMember[] injectionMembers);
+
+        /// <summary>
+        /// Register an instance with the container.
+        /// </summary>
+        /// <remarks>
+        /// <para>
+        /// Instance registration is much like setting a type as a singleton, except that instead
+        /// of the container creating the instance the first time it is requested, the user
+        /// creates the instance ahead of type and adds that instance to the container.
+        /// </para>
+        /// </remarks>
+        /// <param name="type">Type of instance to register (may be an implemented interface instead of the full type).</param>
+        /// <param name="instance">Object to returned.</param>
+        /// <param name="name">Name for registration.</param>
+        /// <param name="lifetime">
+        /// <see cref="LifetimeManager"/> object that controls how this instance will be managed by the container.</param>
+        /// <returns>List of policies this registration generates.</returns>
+        IEnumerable<IBuilderPolicy> RegisterInstance(Type type, string name, object instance, LifetimeManager lifetime);
+        
+    }
+}

src/IUnityContainer.cs

@@ -54,23 +54,6 @@ public interface IUnityContainer : IDisposable
         /// <returns>The retrieved object.</returns>
         object Resolve(Type type, string name, params ResolverOverride[] resolverOverrides);
 
-        /// <summary>
-        /// Return instances of all registered types requested.
-        /// </summary>
-        /// <remarks>
-        /// <para>
-        /// This method is useful if you've registered multiple types with the same
-        /// <see cref="Type"/> but different names.
-        /// </para>
-        /// <para>
-        /// Be aware that this method does NOT return an instance for the default (unnamed) registration.
-        /// </para>
-        /// </remarks>
-        /// <param name="type">The type requested.</param>
-        /// <param name="resolverOverrides">Any overrides for the resolve calls.</param>
-        /// <returns>Set of objects of type <paramref name="type"/>.</returns>
-        IEnumerable<object> ResolveAll(Type type, params ResolverOverride[] resolverOverrides);
-
         /// <summary>
         /// Run an existing object through the container and perform injection on it.
         /// </summary>
@@ -89,12 +72,6 @@ public interface IUnityContainer : IDisposable
         /// cause this to return a different object (but still type compatible with <paramref name="type"/>).</returns>
         object BuildUp(Type type, object existing, string name, params ResolverOverride[] resolverOverrides);
 
-        /// <summary>
-        /// Run an existing object through the container, and clean it up.
-        /// </summary>
-        /// <param name="o">The object to tear down.</param>
-        void Teardown(object o);
-
         /// <summary>
         /// Add an extension object to the container.
         /// </summary>

src/Strategy/IStrategyChain.cs

@@ -18,12 +18,5 @@ public interface IStrategyChain : IEnumerable<IBuilderStrategy>
         /// <param name="context">Context for the build process.</param>
         /// <returns>The build up object</returns>
         object ExecuteBuildUp(IBuilderContext context);
-
-        /// <summary>
-        /// Execute this strategy chain against the given context,
-        /// calling the TearDown methods on the strategies.
-        /// </summary>
-        /// <param name="context">Context for the teardown process.</param>
-        void ExecuteTearDown(IBuilderContext context);
     }
 }

src/Utility/UnityContainerExtensions.cs

@@ -488,6 +488,29 @@ public static object Resolve(this IUnityContainer container, Type t, params Reso
             return (container ?? throw new ArgumentNullException(nameof(container))).Resolve(t, null, overrides);
         }
 
+
+        /// <summary>
+        /// Return instances of all registered types requested.
+        /// </summary>
+        /// <remarks>
+        /// <para>
+        /// This method is useful if you've registered multiple types with the same
+        /// <see cref="Type"/> but different names.
+        /// </para>
+        /// <para>
+        /// Be aware that this method does NOT return an instance for the default (unnamed) registration.
+        /// </para>
+        /// </remarks>
+        /// <param name="container">Container to resolve from.</param>
+        /// <param name="type">The type requested.</param>
+        /// <param name="resolverOverrides">Any overrides for the resolve calls.</param>
+        /// <returns>Set of objects of type <paramref name="type"/>.</returns>
+        public static IEnumerable<object> ResolveAll(this IUnityContainer container, Type type, params ResolverOverride[] resolverOverrides)
+        {
+            var result = container.Resolve((type ?? throw new ArgumentNullException(nameof(type))).MakeArrayType(), resolverOverrides);
+            return result is IEnumerable<object> objects ? objects : ((Array)result).Cast<object>();
+        }
+
         #endregion
 
         #region ResolveAll overloads