Translated error messages to english per issue 19. (#27)

spasarto · ENikS · commit 6dd92dfd2d16 · 2018-10-23T12:16:25.000-04:00
Added resolution customization.
diff --git a/src/HostingExtension.cs b/src/HostingExtension.cs
@@ -1,28 +1,32 @@
 ﻿using Microsoft.AspNetCore.Hosting;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.DependencyInjection.Extensions;
+using System;
 
 namespace Unity.Microsoft.DependencyInjection
 {
     public static class HostingExtension
     {
-        private static ServiceProviderFactory _factory;
-
         public static IWebHostBuilder UseUnityServiceProvider(this IWebHostBuilder hostBuilder, IUnityContainer container = null)
         {
-            _factory = new ServiceProviderFactory(container);
+            return UseUnityServiceProvider(hostBuilder, c => c.UnityContainer = container);
+        }
+
+        public static IWebHostBuilder UseUnityServiceProvider(this IWebHostBuilder hostBuilder, Action<UnityConfigurationOptions> config)
+        {
+            var factory = new ServiceProviderFactory(config);
 
 #if NETCOREAPP1_1
             return hostBuilder.ConfigureServices((services) =>
             {
-                services.Replace(ServiceDescriptor.Singleton<IServiceProviderFactory<IUnityContainer>>(_factory));
-                services.Replace(ServiceDescriptor.Singleton<IServiceProviderFactory<IServiceCollection>>(_factory));
+                services.Replace(ServiceDescriptor.Singleton<IServiceProviderFactory<IUnityContainer>>(factory));
+                services.Replace(ServiceDescriptor.Singleton<IServiceProviderFactory<IServiceCollection>>(factory));
             });
 #else
             return hostBuilder.ConfigureServices((context, services) =>
             {
-                services.Replace(ServiceDescriptor.Singleton<IServiceProviderFactory<IUnityContainer>>(_factory));
-                services.Replace(ServiceDescriptor.Singleton<IServiceProviderFactory<IServiceCollection>>(_factory));
+                services.Replace(ServiceDescriptor.Singleton<IServiceProviderFactory<IUnityContainer>>(factory));
+                services.Replace(ServiceDescriptor.Singleton<IServiceProviderFactory<IServiceCollection>>(factory));
             });
 #endif
         }
diff --git a/src/Policy/ConstructorSelectorPolicy.cs b/src/Policy/ConstructorSelectorPolicy.cs
@@ -48,8 +48,7 @@ private ConstructorInfo FindDependencyConstructor<T>(IBuilderContext context)
                 case 1: return injectionConstructors[0];
                 default:
                     throw new InvalidOperationException(
-               $"Existem multiplos construtores decorados com Inject para a classe " +
-               $"{context.BuildKey.Type.GetTypeInfo().Name}");
+               $"There are multiple constructors decorated with Inject attribute for the class {context.BuildKey.Type.GetTypeInfo().Name}");
             }
         }
 
@@ -115,8 +114,7 @@ private ConstructorInfo Other(ConstructorInfo[] constructors, IBuilderContext co
                                 && !parameters.All(p => p.ParameterType.GetTypeInfo().IsInterface))
                                 return bestConstructor;
 
-                            var msg = $"Falha ao procurar um construtor para {context.BuildKey.Type.FullName}\n" +
-                                $"Há uma abiquidade entre os construtores";
+                            var msg = $"Failed to search for a constructor for {context.BuildKey.Type.FullName}{Environment.NewLine}There is an abnormality between the constructors";
                             throw new InvalidOperationException(msg);
                         }
                         else
@@ -131,7 +129,7 @@ private ConstructorInfo Other(ConstructorInfo[] constructors, IBuilderContext co
             {
                 //return null;
                 throw new InvalidOperationException(
-                    $"Construtor não encontrado para {context.BuildKey.Type.FullName}");
+                    $"Constructor not found for {context.BuildKey.Type.FullName}");
             }
             else
             {
diff --git a/src/ServiceProvider.cs b/src/ServiceProvider.cs
@@ -4,31 +4,37 @@
 
 namespace Unity.Microsoft.DependencyInjection
 {
-    public class ServiceProvider : IServiceProvider, 
-                                   IServiceScopeFactory, 
-                                   IServiceScope, 
+    public class ServiceProvider : IServiceProvider,
+                                   IServiceScopeFactory,
+                                   IServiceScope,
                                    IDisposable
     {
-        private IUnityContainer _container;
+        private readonly UnityConfigurationOptions _options;
 
-
-        internal ServiceProvider(IUnityContainer container)
+        internal ServiceProvider(UnityConfigurationOptions options)
         {
-            _container = container;
-            _container.RegisterInstance<IServiceScope>(this, new ExternallyControlledLifetimeManager());
-            _container.RegisterInstance<IServiceProvider>(this, new ExternallyControlledLifetimeManager());
-            _container.RegisterInstance<IServiceScopeFactory>(this, new ExternallyControlledLifetimeManager());
+            _options = options;
+            _options.UnityContainer.RegisterInstance<IServiceScope>(this, new ExternallyControlledLifetimeManager());
+            _options.UnityContainer.RegisterInstance<IServiceProvider>(this, new ExternallyControlledLifetimeManager());
+            _options.UnityContainer.RegisterInstance<IServiceScopeFactory>(this, new ExternallyControlledLifetimeManager());
         }
 
         #region IServiceProvider
 
         public object GetService(Type serviceType)
         {
+            ResolutionParameters parameters = new ResolutionParameters { Type = serviceType };
+
+            _options.ResolveConfiguration?.Invoke(parameters);
+
             try
             {
-                return _container.Resolve(serviceType);
+                return _options.UnityContainer.Resolve(parameters.Type, parameters.Name, parameters.ResolverOverrides ?? Array.Empty<Resolution.ResolverOverride>());
+            }
+            catch
+            {
+                parameters.ResolutionFailureHanlder?.Invoke(serviceType);
             }
-            catch  { /* Ignore */}
 
             return null;
         }
@@ -40,7 +46,10 @@ public object GetService(Type serviceType)
 
         public IServiceScope CreateScope()
         {
-            return new ServiceProvider(_container.CreateChildContainer());
+            var childOptions = _options.With(_options.UnityContainer.CreateChildContainer());
+            childOptions.CreateScope?.Invoke(childOptions);
+
+            return new ServiceProvider(childOptions);
         }
 
         #endregion
@@ -57,13 +66,15 @@ public IServiceScope CreateScope()
 
         public static IServiceProvider ConfigureServices(IServiceCollection services)
         {
-            return new ServiceProvider(new UnityContainer().AddExtension(new MdiExtension())
-                                                           .AddServices(services));
+            var container = new UnityContainer().AddExtension(new MdiExtension())
+                                                           .AddServices(services);
+
+            return new ServiceProvider(new UnityConfigurationOptions { UnityContainer = container });
         }
 
         public static explicit operator UnityContainer(ServiceProvider c)
         {
-            return (UnityContainer)c._container;
+            return (UnityContainer)c._options.UnityContainer;
         }
 
         #endregion
@@ -77,11 +88,14 @@ public void Dispose()
             GC.SuppressFinalize(this);
         }
 
-        private void Dispose(bool _)
+        protected virtual void Dispose(bool _)
+        {
+            _options.UnityContainer?.Dispose();
+        }
+
+        ~ServiceProvider()
         {
-            IDisposable disposable = _container;
-            _container = null;
-            disposable?.Dispose();
+            Dispose(false);
         }
 
         #endregion
diff --git a/src/ServiceProviderExtensions.cs b/src/ServiceProviderExtensions.cs
@@ -17,8 +17,10 @@ public static class ServiceProviderExtensions
         /// <returns>The <see cref="ServiceProvider"/>.</returns>
         public static IServiceProvider BuildServiceProvider(this IServiceCollection services, bool validateScopes = false)
         {
-            return new ServiceProvider(new UnityContainer().AddExtension(new MdiExtension())
-                                                           .AddServices(services));
+            var container = new UnityContainer().AddExtension(new MdiExtension())
+                                               .AddServices(services);
+
+            return new ServiceProvider(new UnityConfigurationOptions { UnityContainer = container });
         }
 
         /// <summary>
@@ -30,8 +32,10 @@ public static IServiceProvider BuildServiceProvider(this IServiceCollection serv
         /// <returns>Service provider</returns>
         public static IServiceProvider BuildServiceProvider(this IServiceCollection services, IUnityContainer container)
         {
-            return new ServiceProvider(container.AddExtension(new MdiExtension())
-                                                .AddServices(services));
+            container.AddExtension(new MdiExtension())
+                     .AddServices(services);
+
+            return new ServiceProvider(new UnityConfigurationOptions { UnityContainer = container });
         }
 
         /// <summary>
@@ -43,8 +47,10 @@ public static IServiceProvider BuildServiceProvider(this IServiceCollection serv
         /// <returns>Service provider</returns>
         public static IServiceProvider BuildServiceProvider(this IUnityContainer container, IServiceCollection services)
         {
-            return new ServiceProvider(container.AddExtension(new MdiExtension())
-                                                .AddServices(services));
+            container.AddExtension(new MdiExtension())
+                     .AddServices(services);
+
+            return new ServiceProvider(new UnityConfigurationOptions { UnityContainer = container });
         }
     }
 }
diff --git a/src/ServiceProviderFactory.cs b/src/ServiceProviderFactory.cs
@@ -1,25 +1,22 @@
-﻿using System;
-using Microsoft.Extensions.DependencyInjection;
+﻿using Microsoft.Extensions.DependencyInjection;
+using System;
 using Unity.Lifetime;
 
 namespace Unity.Microsoft.DependencyInjection
 {
     public class ServiceProviderFactory : IServiceProviderFactory<IUnityContainer>,
                                           IServiceProviderFactory<IServiceCollection>
     {
-        private readonly IUnityContainer _container;
+        private readonly Action<UnityConfigurationOptions> _config;
 
-        public ServiceProviderFactory(IUnityContainer container)
+        public ServiceProviderFactory(Action<UnityConfigurationOptions> config)
         {
-            _container = container ?? new UnityContainer();
-
-            _container.RegisterInstance<IServiceProviderFactory<IUnityContainer>>(this, new ContainerControlledLifetimeManager());
-            _container.RegisterInstance<IServiceProviderFactory<IServiceCollection>>(this, new ExternallyControlledLifetimeManager());
+            _config = config;
         }
 
         public IServiceProvider CreateServiceProvider(IUnityContainer container)
         {
-            return new ServiceProvider(container);
+            return new ServiceProvider(CreateOptions().With(container));
         }
 
         public IServiceProvider CreateServiceProvider(IServiceCollection containerBuilder)
@@ -29,22 +26,36 @@ public IServiceProvider CreateServiceProvider(IServiceCollection containerBuilde
 
         IUnityContainer IServiceProviderFactory<IUnityContainer>.CreateBuilder(IServiceCollection services)
         {
-            return CreateServiceProviderContainer(services);
+            return CreateServiceProviderContainer(services).UnityContainer;
         }
 
         IServiceCollection IServiceProviderFactory<IServiceCollection>.CreateBuilder(IServiceCollection services)
         {
             return services;
         }
 
+        private UnityConfigurationOptions CreateServiceProviderContainer(IServiceCollection services)
+        {
+            var options = CreateOptions();
+            options.UnityContainer.AddServices(services);
+            return options;
+        }
 
-        private IUnityContainer CreateServiceProviderContainer(IServiceCollection services)
+        private UnityConfigurationOptions CreateOptions()
         {
-            var container = _container.CreateChildContainer();
-            new ServiceProviderFactory(container);
+            var options = new UnityConfigurationOptions();
+            _config(options);
+            options.UnityContainer = options.UnityContainer ?? new UnityContainer();
+            ConfigureContainer(options.UnityContainer);
 
-            return container.AddExtension(new MdiExtension())
-                            .AddServices(services);
+            return options;
+        }
+        
+        private void ConfigureContainer(IUnityContainer container)
+        {
+            container.AddExtension(new MdiExtension());
+            container.RegisterInstance<IServiceProviderFactory<IUnityContainer>>(this, new ContainerControlledLifetimeManager());
+            container.RegisterInstance<IServiceProviderFactory<IServiceCollection>>(this, new ExternallyControlledLifetimeManager());
         }
     }
 }
diff --git a/src/Unity.Microsoft.DependencyInjection.csproj b/src/Unity.Microsoft.DependencyInjection.csproj
@@ -3,8 +3,8 @@
   <Import Project="..\package.props" />
 
   <PropertyGroup>
-    <FileVersion>$(Version).0</FileVersion>
-    <AssemblyVersion>$(Version).0</AssemblyVersion>
+    <FileVersion>2.1.2.1</FileVersion>
+    <AssemblyVersion>2.1.2.1</AssemblyVersion>
     <PackageId>Unity.Microsoft.DependencyInjection</PackageId>
     <Description>Unity for Microsoft Dependency Injection framework.</Description>
     <Copyright>Copyright © Unity Container Project 2018</Copyright>
@@ -19,11 +19,13 @@
     <RootNamespace>Unity.Microsoft.DependencyInjection</RootNamespace>
     <UnityAbstractions>..\..\Abstractions\src\Unity.Abstractions.csproj</UnityAbstractions>
     <UnityContainer>..\..\Container\src\Unity.Container.csproj</UnityContainer>
+    <Version>2.1.2.1</Version>
+    <PackageReleaseNotes>Extended to allow for resolution customization. Updated error language to english.</PackageReleaseNotes>
   </PropertyGroup>
 
 
   <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
-    <GeneratePackageOnBuild>false</GeneratePackageOnBuild>
+    <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
     <TargetFramework>netstandard2.0</TargetFramework>
     <DebugType>Full</DebugType>
   </PropertyGroup>
diff --git a/src/UnityConfigurationOptions.cs b/src/UnityConfigurationOptions.cs
@@ -0,0 +1,53 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Text;
+using Unity.Resolution;
+
+namespace Unity.Microsoft.DependencyInjection
+{
+    public class UnityConfigurationOptions
+    {
+        /// <summary>
+        /// The container to use as the root container.
+        /// </summary>
+        public IUnityContainer UnityContainer { get; set; }
+        /// <summary>
+        /// Controls the unity resolution parameters when resolving a type via the ServiceProvider.
+        /// </summary>
+        public Action<ResolutionParameters> ResolveConfiguration { get; set; }
+        /// <summary>
+        /// Configures the scope options when a new child scope is created.
+        /// </summary>
+        public Action<UnityConfigurationOptions> CreateScope { get; set; }
+
+        public UnityConfigurationOptions With(IUnityContainer unityContainer = null, Action<ResolutionParameters> resolutionConfiguration = null, Action<UnityConfigurationOptions> createScope = null)
+        {
+            return new UnityConfigurationOptions
+            {
+                UnityContainer = unityContainer ?? UnityContainer,
+                ResolveConfiguration = resolutionConfiguration ?? ResolveConfiguration,
+                CreateScope = createScope ?? CreateScope
+            };
+        }
+    }
+
+    public class ResolutionParameters
+    {
+        /// <summary>
+        /// The type being resolved.
+        /// </summary>
+        public Type Type { get; set; }
+        /// <summary>
+        /// The name to use when resolving the type.
+        /// </summary>
+        public string Name { get; set; }
+        /// <summary>
+        /// The resolver overrides to use when resolving the type.
+        /// </summary>
+        public ResolverOverride[] ResolverOverrides { get; set; }
+        /// <summary>
+        /// Action to call when a type resolution fails.
+        /// </summary>
+        public Action<Type> ResolutionFailureHanlder { get; set; }
+    }
+}

Original file line number	Diff line number	Diff line change
`@@ -48,8 +48,7 @@ private ConstructorInfo FindDependencyConstructor<T>(IBuilderContext context)`
`48`	`48`	`case 1: return injectionConstructors[0];`
`49`	`49`	`default:`
`50`	`50`	`throw new InvalidOperationException(`
`51`		`- $"Existem multiplos construtores decorados com Inject para a classe " +`
`52`		`- $"{context.BuildKey.Type.GetTypeInfo().Name}");`
	`51`	`+ $"There are multiple constructors decorated with Inject attribute for the class {context.BuildKey.Type.GetTypeInfo().Name}");`
`53`	`52`	`}`
`54`	`53`	`}`
`55`	`54`
`@@ -115,8 +114,7 @@ private ConstructorInfo Other(ConstructorInfo[] constructors, IBuilderContext co`
`115`	`114`	`&& !parameters.All(p => p.ParameterType.GetTypeInfo().IsInterface))`
`116`	`115`	`return bestConstructor;`
`117`	`116`
`118`		`- var msg = $"Falha ao procurar um construtor para {context.BuildKey.Type.FullName}\n" +`
`119`		`- $"Há uma abiquidade entre os construtores";`
	`117`	`+ var msg = $"Failed to search for a constructor for {context.BuildKey.Type.FullName}{Environment.NewLine}There is an abnormality between the constructors";`
`120`	`118`	`throw new InvalidOperationException(msg);`
`121`	`119`	`}`
`122`	`120`	`else`
`@@ -131,7 +129,7 @@ private ConstructorInfo Other(ConstructorInfo[] constructors, IBuilderContext co`
`131`	`129`	`{`
`132`	`130`	`//return null;`
`133`	`131`	`throw new InvalidOperationException(`
`134`		`- $"Construtor não encontrado para {context.BuildKey.Type.FullName}");`
	`132`	`+ $"Constructor not found for {context.BuildKey.Type.FullName}");`
`135`	`133`	`}`
`136`	`134`	`else`
`137`	`135`	`{`
Original file line number	Diff line number	Diff line change
`@@ -4,31 +4,37 @@`
`4`	`4`
`5`	`5`	`namespace Unity.Microsoft.DependencyInjection`
`6`	`6`	`{`
`7`		`- public class ServiceProvider : IServiceProvider,`
`8`		`- IServiceScopeFactory,`
`9`		`- IServiceScope,`
	`7`	`+ public class ServiceProvider : IServiceProvider,`
	`8`	`+ IServiceScopeFactory,`
	`9`	`+ IServiceScope,`
`10`	`10`	`IDisposable`
`11`	`11`	`{`
`12`		`- private IUnityContainer _container;`
	`12`	`+ private readonly UnityConfigurationOptions _options;`
`13`	`13`
`14`		`-`
`15`		`- internal ServiceProvider(IUnityContainer container)`
	`14`	`+ internal ServiceProvider(UnityConfigurationOptions options)`
`16`	`15`	`{`
`17`		`- _container = container;`
`18`		`- _container.RegisterInstance<IServiceScope>(this, new ExternallyControlledLifetimeManager());`
`19`		`- _container.RegisterInstance<IServiceProvider>(this, new ExternallyControlledLifetimeManager());`
`20`		`- _container.RegisterInstance<IServiceScopeFactory>(this, new ExternallyControlledLifetimeManager());`
	`16`	`+ _options = options;`
	`17`	`+ _options.UnityContainer.RegisterInstance<IServiceScope>(this, new ExternallyControlledLifetimeManager());`
	`18`	`+ _options.UnityContainer.RegisterInstance<IServiceProvider>(this, new ExternallyControlledLifetimeManager());`
	`19`	`+ _options.UnityContainer.RegisterInstance<IServiceScopeFactory>(this, new ExternallyControlledLifetimeManager());`
`21`	`20`	`}`
`22`	`21`
`23`	`22`	`#region IServiceProvider`
`24`	`23`
`25`	`24`	`public object GetService(Type serviceType)`
`26`	`25`	`{`
	`26`	`+ ResolutionParameters parameters = new ResolutionParameters { Type = serviceType };`
	`27`	`+`
	`28`	`+ _options.ResolveConfiguration?.Invoke(parameters);`
	`29`	`+`
`27`	`30`	`try`
`28`	`31`	`{`
`29`		`- return _container.Resolve(serviceType);`
	`32`	`+ return _options.UnityContainer.Resolve(parameters.Type, parameters.Name, parameters.ResolverOverrides ?? Array.Empty<Resolution.ResolverOverride>());`
	`33`	`+ }`
	`34`	`+ catch`
	`35`	`+ {`
	`36`	`+ parameters.ResolutionFailureHanlder?.Invoke(serviceType);`
`30`	`37`	`}`
`31`		`- catch { /* Ignore */}`
`32`	`38`
`33`	`39`	`return null;`
`34`	`40`	`}`
`@@ -40,7 +46,10 @@ public object GetService(Type serviceType)`
`40`	`46`
`41`	`47`	`public IServiceScope CreateScope()`
`42`	`48`	`{`
`43`		`- return new ServiceProvider(_container.CreateChildContainer());`
	`49`	`+ var childOptions = _options.With(_options.UnityContainer.CreateChildContainer());`
	`50`	`+ childOptions.CreateScope?.Invoke(childOptions);`
	`51`	`+`
	`52`	`+ return new ServiceProvider(childOptions);`
`44`	`53`	`}`
`45`	`54`
`46`	`55`	`#endregion`
`@@ -57,13 +66,15 @@ public IServiceScope CreateScope()`
`57`	`66`
`58`	`67`	`public static IServiceProvider ConfigureServices(IServiceCollection services)`
`59`	`68`	`{`
`60`		`- return new ServiceProvider(new UnityContainer().AddExtension(new MdiExtension())`
`61`		`- .AddServices(services));`
	`69`	`+ var container = new UnityContainer().AddExtension(new MdiExtension())`
	`70`	`+ .AddServices(services);`
	`71`	`+`
	`72`	`+ return new ServiceProvider(new UnityConfigurationOptions { UnityContainer = container });`
`62`	`73`	`}`
`63`	`74`
`64`	`75`	`public static explicit operator UnityContainer(ServiceProvider c)`
`65`	`76`	`{`
`66`		`- return (UnityContainer)c._container;`
	`77`	`+ return (UnityContainer)c._options.UnityContainer;`
`67`	`78`	`}`
`68`	`79`
`69`	`80`	`#endregion`
`@@ -77,11 +88,14 @@ public void Dispose()`
`77`	`88`	`GC.SuppressFinalize(this);`
`78`	`89`	`}`
`79`	`90`
`80`		`- private void Dispose(bool _)`
	`91`	`+ protected virtual void Dispose(bool _)`
	`92`	`+ {`
	`93`	`+ _options.UnityContainer?.Dispose();`
	`94`	`+ }`
	`95`	`+`
	`96`	`+ ~ServiceProvider()`
`81`	`97`	`{`
`82`		`- IDisposable disposable = _container;`
`83`		`- _container = null;`
`84`		`- disposable?.Dispose();`
	`98`	`+ Dispose(false);`
`85`	`99`	`}`
`86`	`100`
`87`	`101`	`#endregion`
Original file line number	Diff line number	Diff line change
`@@ -17,8 +17,10 @@ public static class ServiceProviderExtensions`
`17`	`17`	`/// <returns>The <see cref="ServiceProvider"/>.</returns>`
`18`	`18`	`public static IServiceProvider BuildServiceProvider(this IServiceCollection services, bool validateScopes = false)`
`19`	`19`	`{`
`20`		`- return new ServiceProvider(new UnityContainer().AddExtension(new MdiExtension())`
`21`		`- .AddServices(services));`
	`20`	`+ var container = new UnityContainer().AddExtension(new MdiExtension())`
	`21`	`+ .AddServices(services);`
	`22`	`+`
	`23`	`+ return new ServiceProvider(new UnityConfigurationOptions { UnityContainer = container });`
`22`	`24`	`}`
`23`	`25`
`24`	`26`	`/// <summary>`
`@@ -30,8 +32,10 @@ public static IServiceProvider BuildServiceProvider(this IServiceCollection serv`
`30`	`32`	`/// <returns>Service provider</returns>`
`31`	`33`	`public static IServiceProvider BuildServiceProvider(this IServiceCollection services, IUnityContainer container)`
`32`	`34`	`{`
`33`		`- return new ServiceProvider(container.AddExtension(new MdiExtension())`
`34`		`- .AddServices(services));`
	`35`	`+ container.AddExtension(new MdiExtension())`
	`36`	`+ .AddServices(services);`
	`37`	`+`
	`38`	`+ return new ServiceProvider(new UnityConfigurationOptions { UnityContainer = container });`
`35`	`39`	`}`
`36`	`40`
`37`	`41`	`/// <summary>`
`@@ -43,8 +47,10 @@ public static IServiceProvider BuildServiceProvider(this IServiceCollection serv`
`43`	`47`	`/// <returns>Service provider</returns>`
`44`	`48`	`public static IServiceProvider BuildServiceProvider(this IUnityContainer container, IServiceCollection services)`
`45`	`49`	`{`
`46`		`- return new ServiceProvider(container.AddExtension(new MdiExtension())`
`47`		`- .AddServices(services));`
	`50`	`+ container.AddExtension(new MdiExtension())`
	`51`	`+ .AddServices(services);`
	`52`	`+`
	`53`	`+ return new ServiceProvider(new UnityConfigurationOptions { UnityContainer = container });`
`48`	`54`	`}`
`49`	`55`	`}`
`50`	`56`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,25 +1,22 @@`
`1`		`-using System;`
`2`		`-using Microsoft.Extensions.DependencyInjection;`
	`1`	`+using Microsoft.Extensions.DependencyInjection;`
	`2`	`+using System;`
`3`	`3`	`using Unity.Lifetime;`
`4`	`4`
`5`	`5`	`namespace Unity.Microsoft.DependencyInjection`
`6`	`6`	`{`
`7`	`7`	`public class ServiceProviderFactory : IServiceProviderFactory<IUnityContainer>,`
`8`	`8`	`IServiceProviderFactory<IServiceCollection>`
`9`	`9`	`{`
`10`		`- private readonly IUnityContainer _container;`
	`10`	`+ private readonly Action<UnityConfigurationOptions> _config;`
`11`	`11`
`12`		`- public ServiceProviderFactory(IUnityContainer container)`
	`12`	`+ public ServiceProviderFactory(Action<UnityConfigurationOptions> config)`
`13`	`13`	`{`
`14`		`- _container = container ?? new UnityContainer();`
`15`		`-`
`16`		`- _container.RegisterInstance<IServiceProviderFactory<IUnityContainer>>(this, new ContainerControlledLifetimeManager());`
`17`		`- _container.RegisterInstance<IServiceProviderFactory<IServiceCollection>>(this, new ExternallyControlledLifetimeManager());`
	`14`	`+ _config = config;`
`18`	`15`	`}`
`19`	`16`
`20`	`17`	`public IServiceProvider CreateServiceProvider(IUnityContainer container)`
`21`	`18`	`{`
`22`		`- return new ServiceProvider(container);`
	`19`	`+ return new ServiceProvider(CreateOptions().With(container));`
`23`	`20`	`}`
`24`	`21`
`25`	`22`	`public IServiceProvider CreateServiceProvider(IServiceCollection containerBuilder)`
`@@ -29,22 +26,36 @@ public IServiceProvider CreateServiceProvider(IServiceCollection containerBuilde`
`29`	`26`
`30`	`27`	`IUnityContainer IServiceProviderFactory<IUnityContainer>.CreateBuilder(IServiceCollection services)`
`31`	`28`	`{`
`32`		`- return CreateServiceProviderContainer(services);`
	`29`	`+ return CreateServiceProviderContainer(services).UnityContainer;`
`33`	`30`	`}`
`34`	`31`
`35`	`32`	`IServiceCollection IServiceProviderFactory<IServiceCollection>.CreateBuilder(IServiceCollection services)`
`36`	`33`	`{`
`37`	`34`	`return services;`
`38`	`35`	`}`
`39`	`36`
	`37`	`+ private UnityConfigurationOptions CreateServiceProviderContainer(IServiceCollection services)`
	`38`	`+ {`
	`39`	`+ var options = CreateOptions();`
	`40`	`+ options.UnityContainer.AddServices(services);`
	`41`	`+ return options;`
	`42`	`+ }`
`40`	`43`
`41`		`- private IUnityContainer CreateServiceProviderContainer(IServiceCollection services)`
	`44`	`+ private UnityConfigurationOptions CreateOptions()`
`42`	`45`	`{`
`43`		`- var container = _container.CreateChildContainer();`
`44`		`- new ServiceProviderFactory(container);`
	`46`	`+ var options = new UnityConfigurationOptions();`
	`47`	`+ _config(options);`
	`48`	`+ options.UnityContainer = options.UnityContainer ?? new UnityContainer();`
	`49`	`+ ConfigureContainer(options.UnityContainer);`
`45`	`50`
`46`		`- return container.AddExtension(new MdiExtension())`
`47`		`- .AddServices(services);`
	`51`	`+ return options;`
	`52`	`+ }`
	`53`	`+`
	`54`	`+ private void ConfigureContainer(IUnityContainer container)`
	`55`	`+ {`
	`56`	`+ container.AddExtension(new MdiExtension());`
	`57`	`+ container.RegisterInstance<IServiceProviderFactory<IUnityContainer>>(this, new ContainerControlledLifetimeManager());`
	`58`	`+ container.RegisterInstance<IServiceProviderFactory<IServiceCollection>>(this, new ExternallyControlledLifetimeManager());`
`48`	`59`	`}`
`49`	`60`	`}`
`50`	`61`	`}`