Releasing 2.1.3

ENikS · ENikS · commit 144f184b1aa1 · 2018-12-09T17:31:21.000-05:00
diff --git a/package.props b/package.props
@@ -1,7 +1,7 @@
 <Project>
 
   <PropertyGroup>
-    <Version>2.1.2</Version>
+    <Version>2.1.3</Version>
     <PackageReleaseNotes>Bug fixes, dependency updates and minor performance optimizations</PackageReleaseNotes>
   </PropertyGroup>
 
diff --git a/src/HostingExtension.cs b/src/HostingExtension.cs
@@ -1,32 +1,28 @@
 ﻿using Microsoft.AspNetCore.Hosting;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.DependencyInjection.Extensions;
-using System;
 
 namespace Unity.Microsoft.DependencyInjection
 {
     public static class HostingExtension
     {
-        public static IWebHostBuilder UseUnityServiceProvider(this IWebHostBuilder hostBuilder, IUnityContainer container = null)
-        {
-            return UseUnityServiceProvider(hostBuilder, c => c.UnityContainer = container);
-        }
+        private static ServiceProviderFactory _factory;
 
-        public static IWebHostBuilder UseUnityServiceProvider(this IWebHostBuilder hostBuilder, Action<UnityConfigurationOptions> config)
+        public static IWebHostBuilder UseUnityServiceProvider(this IWebHostBuilder hostBuilder, IUnityContainer container = null)
         {
-            var factory = new ServiceProviderFactory(config);
+            _factory = new ServiceProviderFactory(container);
 
 #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/ServiceProvider.cs b/src/ServiceProvider.cs
@@ -4,37 +4,31 @@
 
 namespace Unity.Microsoft.DependencyInjection
 {
-    public class ServiceProvider : IServiceProvider,
-                                   IServiceScopeFactory,
-                                   IServiceScope,
+    public class ServiceProvider : IServiceProvider, 
+                                   IServiceScopeFactory, 
+                                   IServiceScope, 
                                    IDisposable
     {
-        private readonly UnityConfigurationOptions _options;
+        private IUnityContainer _container;
 
-        internal ServiceProvider(UnityConfigurationOptions options)
+
+        internal ServiceProvider(IUnityContainer container)
         {
-            _options = options;
-            _options.UnityContainer.RegisterInstance<IServiceScope>(this, new ExternallyControlledLifetimeManager());
-            _options.UnityContainer.RegisterInstance<IServiceProvider>(this, new ExternallyControlledLifetimeManager());
-            _options.UnityContainer.RegisterInstance<IServiceScopeFactory>(this, new ExternallyControlledLifetimeManager());
+            _container = container;
+            _container.RegisterInstance<IServiceScope>(this, new ExternallyControlledLifetimeManager());
+            _container.RegisterInstance<IServiceProvider>(this, new ExternallyControlledLifetimeManager());
+            _container.RegisterInstance<IServiceScopeFactory>(this, new ExternallyControlledLifetimeManager());
         }
 
         #region IServiceProvider
 
         public object GetService(Type serviceType)
         {
-            ResolutionParameters parameters = new ResolutionParameters { Type = serviceType };
-
-            _options.ResolveConfiguration?.Invoke(parameters);
-
             try
             {
-                return _options.UnityContainer.Resolve(parameters.Type, parameters.Name, parameters.ResolverOverrides ?? Array.Empty<Resolution.ResolverOverride>());
-            }
-            catch
-            {
-                parameters.ResolutionFailureHanlder?.Invoke(serviceType);
+                return _container.Resolve(serviceType);
             }
+            catch  { /* Ignore */}
 
             return null;
         }
@@ -46,10 +40,7 @@ public object GetService(Type serviceType)
 
         public IServiceScope CreateScope()
         {
-            var childOptions = _options.With(_options.UnityContainer.CreateChildContainer());
-            childOptions.CreateScope?.Invoke(childOptions);
-
-            return new ServiceProvider(childOptions);
+            return new ServiceProvider(_container.CreateChildContainer());
         }
 
         #endregion
@@ -66,15 +57,13 @@ public IServiceScope CreateScope()
 
         public static IServiceProvider ConfigureServices(IServiceCollection services)
         {
-            var container = new UnityContainer().AddExtension(new MdiExtension())
-                                                           .AddServices(services);
-
-            return new ServiceProvider(new UnityConfigurationOptions { UnityContainer = container });
+            return new ServiceProvider(new UnityContainer().AddExtension(new MdiExtension())
+                                                           .AddServices(services));
         }
 
         public static explicit operator UnityContainer(ServiceProvider c)
         {
-            return (UnityContainer)c._options.UnityContainer;
+            return (UnityContainer)c._container;
         }
 
         #endregion
@@ -88,14 +77,11 @@ public void Dispose()
             GC.SuppressFinalize(this);
         }
 
-        protected virtual void Dispose(bool _)
-        {
-            _options.UnityContainer?.Dispose();
-        }
-
-        ~ServiceProvider()
+        private void Dispose(bool _)
         {
-            Dispose(false);
+            IDisposable disposable = _container;
+            _container = null;
+            disposable?.Dispose();
         }
 
         #endregion
diff --git a/src/ServiceProviderExtensions.cs b/src/ServiceProviderExtensions.cs
@@ -17,10 +17,8 @@ public static class ServiceProviderExtensions
         /// <returns>The <see cref="ServiceProvider"/>.</returns>
         public static IServiceProvider BuildServiceProvider(this IServiceCollection services, bool validateScopes = false)
         {
-            var container = new UnityContainer().AddExtension(new MdiExtension())
-                                               .AddServices(services);
-
-            return new ServiceProvider(new UnityConfigurationOptions { UnityContainer = container });
+            return new ServiceProvider(new UnityContainer().AddExtension(new MdiExtension())
+                                                           .AddServices(services));
         }
 
         /// <summary>
@@ -32,10 +30,8 @@ public static IServiceProvider BuildServiceProvider(this IServiceCollection serv
         /// <returns>Service provider</returns>
         public static IServiceProvider BuildServiceProvider(this IServiceCollection services, IUnityContainer container)
         {
-            container.AddExtension(new MdiExtension())
-                     .AddServices(services);
-
-            return new ServiceProvider(new UnityConfigurationOptions { UnityContainer = container });
+            return new ServiceProvider(container.AddExtension(new MdiExtension())
+                                                .AddServices(services));
         }
 
         /// <summary>
@@ -47,10 +43,8 @@ public static IServiceProvider BuildServiceProvider(this IServiceCollection serv
         /// <returns>Service provider</returns>
         public static IServiceProvider BuildServiceProvider(this IUnityContainer container, IServiceCollection services)
         {
-            container.AddExtension(new MdiExtension())
-                     .AddServices(services);
-
-            return new ServiceProvider(new UnityConfigurationOptions { UnityContainer = container });
+            return new ServiceProvider(container.AddExtension(new MdiExtension())
+                                                .AddServices(services));
         }
     }
 }
diff --git a/src/ServiceProviderFactory.cs b/src/ServiceProviderFactory.cs
@@ -1,22 +1,25 @@
-﻿using Microsoft.Extensions.DependencyInjection;
-using System;
+﻿using System;
+using Microsoft.Extensions.DependencyInjection;
 using Unity.Lifetime;
 
 namespace Unity.Microsoft.DependencyInjection
 {
     public class ServiceProviderFactory : IServiceProviderFactory<IUnityContainer>,
                                           IServiceProviderFactory<IServiceCollection>
     {
-        private readonly Action<UnityConfigurationOptions> _config;
+        private readonly IUnityContainer _container;
 
-        public ServiceProviderFactory(Action<UnityConfigurationOptions> config)
+        public ServiceProviderFactory(IUnityContainer container)
         {
-            _config = config;
+            _container = container ?? new UnityContainer();
+
+            _container.RegisterInstance<IServiceProviderFactory<IUnityContainer>>(this, new ContainerControlledLifetimeManager());
+            _container.RegisterInstance<IServiceProviderFactory<IServiceCollection>>(this, new ExternallyControlledLifetimeManager());
         }
 
         public IServiceProvider CreateServiceProvider(IUnityContainer container)
         {
-            return new ServiceProvider(CreateOptions().With(container));
+            return new ServiceProvider(container);
         }
 
         public IServiceProvider CreateServiceProvider(IServiceCollection containerBuilder)
@@ -26,36 +29,22 @@ public IServiceProvider CreateServiceProvider(IServiceCollection containerBuilde
 
         IUnityContainer IServiceProviderFactory<IUnityContainer>.CreateBuilder(IServiceCollection services)
         {
-            return CreateServiceProviderContainer(services).UnityContainer;
+            return CreateServiceProviderContainer(services);
         }
 
         IServiceCollection IServiceProviderFactory<IServiceCollection>.CreateBuilder(IServiceCollection services)
         {
             return services;
         }
 
-        private UnityConfigurationOptions CreateServiceProviderContainer(IServiceCollection services)
-        {
-            var options = CreateOptions();
-            options.UnityContainer.AddServices(services);
-            return options;
-        }
 
-        private UnityConfigurationOptions CreateOptions()
+        private IUnityContainer CreateServiceProviderContainer(IServiceCollection services)
         {
-            var options = new UnityConfigurationOptions();
-            _config(options);
-            options.UnityContainer = options.UnityContainer ?? new UnityContainer();
-            ConfigureContainer(options.UnityContainer);
+            var container = _container.CreateChildContainer();
+            new ServiceProviderFactory(container);
 
-            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());
+            return container.AddExtension(new MdiExtension())
+                            .AddServices(services);
         }
     }
 }
diff --git a/src/Unity.Microsoft.DependencyInjection.csproj b/src/Unity.Microsoft.DependencyInjection.csproj
@@ -3,8 +3,8 @@
   <Import Project="..\package.props" />
 
   <PropertyGroup>
-    <FileVersion>2.1.2.1</FileVersion>
-    <AssemblyVersion>2.1.2.1</AssemblyVersion>
+    <FileVersion>$(Version).0</FileVersion>
+    <AssemblyVersion>$(Version).0</AssemblyVersion>
     <PackageId>Unity.Microsoft.DependencyInjection</PackageId>
     <Description>Unity for Microsoft Dependency Injection framework.</Description>
     <Copyright>Copyright © Unity Container Project 2018</Copyright>
@@ -19,13 +19,11 @@
     <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>true</GeneratePackageOnBuild>
+    <GeneratePackageOnBuild>false</GeneratePackageOnBuild>
     <TargetFramework>netstandard2.0</TargetFramework>
     <DebugType>Full</DebugType>
   </PropertyGroup>
@@ -52,17 +50,17 @@
   </ItemGroup>
 
   <ItemGroup Condition="'$(TargetFramework)' != '' AND '$(TargetFramework)' == 'netstandard2.0' ">
-    <PackageReference Include="Microsoft.AspNetCore.Hosting.Abstractions" Version="2.1.1" />
-    <PackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="2.1.1" /> 
+    <PackageReference Include="Microsoft.AspNetCore.Hosting.Abstractions" Version="2.2.0" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="2.2.0" /> 
   </ItemGroup>
 
 
   <ItemGroup Condition="!Exists('$(UnityAbstractions)')">
-    <PackageReference Include="Unity.Abstractions" Version="3.3.1" />
+    <PackageReference Include="Unity.Abstractions" Version="$(UnityAbstractionsVersion)" />
   </ItemGroup>
 
   <ItemGroup Condition="!Exists('$(UnityContainer)')">
-    <PackageReference Include="Unity.Container" Version="5.8.9" />      
+    <PackageReference Include="Unity.Container" Version="$(UnityContainerVersion)" />      
   </ItemGroup>
 
 </Project>
diff --git a/src/UnityConfigurationOptions.cs b/src/UnityConfigurationOptions.cs
diff --git a/tests/GitHub.cs b/tests/GitHub.cs
@@ -6,7 +6,7 @@
 
 namespace Unity.Microsoft.DependencyInjection.Tests
 {
-    public class GitHubIssues
+    public class IssuesOnGitHub
     {
         public interface IScopedService
         {
@@ -85,7 +85,7 @@ public void Issue_29_Factory()
 
 
         [Fact]
-        public void Test2_failing()
+        public void Issue_28()
         {
 
             var serviceCollection = new ServiceCollection();
@@ -95,10 +95,11 @@ public void Test2_failing()
 
             IUnityContainer container = new UnityContainer().CreateChildContainer();
 
-            var factory = new ServiceProviderFactory(c => c.UnityContainer = container);
+            var factory = new ServiceProviderFactory(container);
 
             var sp = factory.CreateServiceProvider(serviceCollection);
             var scopeFactory = sp.GetRequiredService<IServiceScopeFactory>();
+            var httpFactory0 = sp.GetRequiredService<IHttpClientFactory>();
             using (var scope = scopeFactory.CreateScope())
             {
                 var httpFactory = scope.ServiceProvider.GetRequiredService<IHttpClientFactory>();
diff --git a/tests/Microsoft.DependencyInjection.Tests.csproj b/tests/Microsoft.DependencyInjection.Tests.csproj

Original file line number	Diff line number	Diff line change
`@@ -4,37 +4,31 @@`
`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 readonly UnityConfigurationOptions _options;`
	`12`	`+ private IUnityContainer _container;`
`13`	`13`
`14`		`- internal ServiceProvider(UnityConfigurationOptions options)`
	`14`	`+`
	`15`	`+ internal ServiceProvider(IUnityContainer container)`
`15`	`16`	`{`
`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());`
	`17`	`+ _container = container;`
	`18`	`+ _container.RegisterInstance<IServiceScope>(this, new ExternallyControlledLifetimeManager());`
	`19`	`+ _container.RegisterInstance<IServiceProvider>(this, new ExternallyControlledLifetimeManager());`
	`20`	`+ _container.RegisterInstance<IServiceScopeFactory>(this, new ExternallyControlledLifetimeManager());`
`20`	`21`	`}`
`21`	`22`
`22`	`23`	`#region IServiceProvider`
`23`	`24`
`24`	`25`	`public object GetService(Type serviceType)`
`25`	`26`	`{`
`26`		`- ResolutionParameters parameters = new ResolutionParameters { Type = serviceType };`
`27`		`-`
`28`		`- _options.ResolveConfiguration?.Invoke(parameters);`
`29`		`-`
`30`	`27`	`try`
`31`	`28`	`{`
`32`		`- return _options.UnityContainer.Resolve(parameters.Type, parameters.Name, parameters.ResolverOverrides ?? Array.Empty<Resolution.ResolverOverride>());`
`33`		`- }`
`34`		`- catch`
`35`		`- {`
`36`		`- parameters.ResolutionFailureHanlder?.Invoke(serviceType);`
	`29`	`+ return _container.Resolve(serviceType);`
`37`	`30`	`}`
	`31`	`+ catch { /* Ignore */}`
`38`	`32`
`39`	`33`	`return null;`
`40`	`34`	`}`
`@@ -46,10 +40,7 @@ public object GetService(Type serviceType)`
`46`	`40`
`47`	`41`	`public IServiceScope CreateScope()`
`48`	`42`	`{`
`49`		`- var childOptions = _options.With(_options.UnityContainer.CreateChildContainer());`
`50`		`- childOptions.CreateScope?.Invoke(childOptions);`
`51`		`-`
`52`		`- return new ServiceProvider(childOptions);`
	`43`	`+ return new ServiceProvider(_container.CreateChildContainer());`
`53`	`44`	`}`
`54`	`45`
`55`	`46`	`#endregion`
`@@ -66,15 +57,13 @@ public IServiceScope CreateScope()`
`66`	`57`
`67`	`58`	`public static IServiceProvider ConfigureServices(IServiceCollection services)`
`68`	`59`	`{`
`69`		`- var container = new UnityContainer().AddExtension(new MdiExtension())`
`70`		`- .AddServices(services);`
`71`		`-`
`72`		`- return new ServiceProvider(new UnityConfigurationOptions { UnityContainer = container });`
	`60`	`+ return new ServiceProvider(new UnityContainer().AddExtension(new MdiExtension())`
	`61`	`+ .AddServices(services));`
`73`	`62`	`}`
`74`	`63`
`75`	`64`	`public static explicit operator UnityContainer(ServiceProvider c)`
`76`	`65`	`{`
`77`		`- return (UnityContainer)c._options.UnityContainer;`
	`66`	`+ return (UnityContainer)c._container;`
`78`	`67`	`}`
`79`	`68`
`80`	`69`	`#endregion`
`@@ -88,14 +77,11 @@ public void Dispose()`
`88`	`77`	`GC.SuppressFinalize(this);`
`89`	`78`	`}`
`90`	`79`
`91`		`- protected virtual void Dispose(bool _)`
`92`		`- {`
`93`		`- _options.UnityContainer?.Dispose();`
`94`		`- }`
`95`		`-`
`96`		`- ~ServiceProvider()`
	`80`	`+ private void Dispose(bool _)`
`97`	`81`	`{`
`98`		`- Dispose(false);`
	`82`	`+ IDisposable disposable = _container;`
	`83`	`+ _container = null;`
	`84`	`+ disposable?.Dispose();`
`99`	`85`	`}`
`100`	`86`
`101`	`87`	`#endregion`
Original file line number	Diff line number	Diff line change
`@@ -17,10 +17,8 @@ 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`		`- var container = new UnityContainer().AddExtension(new MdiExtension())`
`21`		`- .AddServices(services);`
`22`		`-`
`23`		`- return new ServiceProvider(new UnityConfigurationOptions { UnityContainer = container });`
	`20`	`+ return new ServiceProvider(new UnityContainer().AddExtension(new MdiExtension())`
	`21`	`+ .AddServices(services));`
`24`	`22`	`}`
`25`	`23`
`26`	`24`	`/// <summary>`
`@@ -32,10 +30,8 @@ public static IServiceProvider BuildServiceProvider(this IServiceCollection serv`
`32`	`30`	`/// <returns>Service provider</returns>`
`33`	`31`	`public static IServiceProvider BuildServiceProvider(this IServiceCollection services, IUnityContainer container)`
`34`	`32`	`{`
`35`		`- container.AddExtension(new MdiExtension())`
`36`		`- .AddServices(services);`
`37`		`-`
`38`		`- return new ServiceProvider(new UnityConfigurationOptions { UnityContainer = container });`
	`33`	`+ return new ServiceProvider(container.AddExtension(new MdiExtension())`
	`34`	`+ .AddServices(services));`
`39`	`35`	`}`
`40`	`36`
`41`	`37`	`/// <summary>`
`@@ -47,10 +43,8 @@ public static IServiceProvider BuildServiceProvider(this IServiceCollection serv`
`47`	`43`	`/// <returns>Service provider</returns>`
`48`	`44`	`public static IServiceProvider BuildServiceProvider(this IUnityContainer container, IServiceCollection services)`
`49`	`45`	`{`
`50`		`- container.AddExtension(new MdiExtension())`
`51`		`- .AddServices(services);`
`52`		`-`
`53`		`- return new ServiceProvider(new UnityConfigurationOptions { UnityContainer = container });`
	`46`	`+ return new ServiceProvider(container.AddExtension(new MdiExtension())`
	`47`	`+ .AddServices(services));`
`54`	`48`	`}`
`55`	`49`	`}`
`56`	`50`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,22 +1,25 @@`
`1`		`-using Microsoft.Extensions.DependencyInjection;`
`2`		`-using System;`
	`1`	`+using System;`
	`2`	`+using Microsoft.Extensions.DependencyInjection;`
`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 Action<UnityConfigurationOptions> _config;`
	`10`	`+ private readonly IUnityContainer _container;`
`11`	`11`
`12`		`- public ServiceProviderFactory(Action<UnityConfigurationOptions> config)`
	`12`	`+ public ServiceProviderFactory(IUnityContainer container)`
`13`	`13`	`{`
`14`		`- _config = config;`
	`14`	`+ _container = container ?? new UnityContainer();`
	`15`	`+`
	`16`	`+ _container.RegisterInstance<IServiceProviderFactory<IUnityContainer>>(this, new ContainerControlledLifetimeManager());`
	`17`	`+ _container.RegisterInstance<IServiceProviderFactory<IServiceCollection>>(this, new ExternallyControlledLifetimeManager());`
`15`	`18`	`}`
`16`	`19`
`17`	`20`	`public IServiceProvider CreateServiceProvider(IUnityContainer container)`
`18`	`21`	`{`
`19`		`- return new ServiceProvider(CreateOptions().With(container));`
	`22`	`+ return new ServiceProvider(container);`
`20`	`23`	`}`
`21`	`24`
`22`	`25`	`public IServiceProvider CreateServiceProvider(IServiceCollection containerBuilder)`
`@@ -26,36 +29,22 @@ public IServiceProvider CreateServiceProvider(IServiceCollection containerBuilde`
`26`	`29`
`27`	`30`	`IUnityContainer IServiceProviderFactory<IUnityContainer>.CreateBuilder(IServiceCollection services)`
`28`	`31`	`{`
`29`		`- return CreateServiceProviderContainer(services).UnityContainer;`
	`32`	`+ return CreateServiceProviderContainer(services);`
`30`	`33`	`}`
`31`	`34`
`32`	`35`	`IServiceCollection IServiceProviderFactory<IServiceCollection>.CreateBuilder(IServiceCollection services)`
`33`	`36`	`{`
`34`	`37`	`return services;`
`35`	`38`	`}`
`36`	`39`
`37`		`- private UnityConfigurationOptions CreateServiceProviderContainer(IServiceCollection services)`
`38`		`- {`
`39`		`- var options = CreateOptions();`
`40`		`- options.UnityContainer.AddServices(services);`
`41`		`- return options;`
`42`		`- }`
`43`	`40`
`44`		`- private UnityConfigurationOptions CreateOptions()`
	`41`	`+ private IUnityContainer CreateServiceProviderContainer(IServiceCollection services)`
`45`	`42`	`{`
`46`		`- var options = new UnityConfigurationOptions();`
`47`		`- _config(options);`
`48`		`- options.UnityContainer = options.UnityContainer ?? new UnityContainer();`
`49`		`- ConfigureContainer(options.UnityContainer);`
	`43`	`+ var container = _container.CreateChildContainer();`
	`44`	`+ new ServiceProviderFactory(container);`
`50`	`45`
`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());`
	`46`	`+ return container.AddExtension(new MdiExtension())`
	`47`	`+ .AddServices(services);`
`59`	`48`	`}`
`60`	`49`	`}`
`61`	`50`	`}`
Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,7 @@`
`6`	`6`
`7`	`7`	`namespace Unity.Microsoft.DependencyInjection.Tests`
`8`	`8`	`{`
`9`		`- public class GitHubIssues`
	`9`	`+ public class IssuesOnGitHub`
`10`	`10`	`{`
`11`	`11`	`public interface IScopedService`
`12`	`12`	`{`
`@@ -85,7 +85,7 @@ public void Issue_29_Factory()`
`85`	`85`
`86`	`86`
`87`	`87`	`[Fact]`
`88`		`- public void Test2_failing()`
	`88`	`+ public void Issue_28()`
`89`	`89`	`{`
`90`	`90`
`91`	`91`	`var serviceCollection = new ServiceCollection();`
`@@ -95,10 +95,11 @@ public void Test2_failing()`
`95`	`95`
`96`	`96`	`IUnityContainer container = new UnityContainer().CreateChildContainer();`
`97`	`97`
`98`		`- var factory = new ServiceProviderFactory(c => c.UnityContainer = container);`
	`98`	`+ var factory = new ServiceProviderFactory(container);`
`99`	`99`
`100`	`100`	`var sp = factory.CreateServiceProvider(serviceCollection);`
`101`	`101`	`var scopeFactory = sp.GetRequiredService<IServiceScopeFactory>();`
	`102`	`+ var httpFactory0 = sp.GetRequiredService<IHttpClientFactory>();`
`102`	`103`	`using (var scope = scopeFactory.CreateScope())`
`103`	`104`	`{`
`104`	`105`	`var httpFactory = scope.ServiceProvider.GetRequiredService<IHttpClientFactory>();`