public async Task LongRunning() { ServiceContainer services = new ServiceContainer(); services.AddScopedPool <ISingleService, SingleService>(); for (int i = 0; i < 50; i++) { IContainerScope scope1 = services.CreateScope(); IContainerScope scope2 = services.CreateScope(); ISingleService service1 = await services.Get <ISingleService>(scope1); ISingleService service2 = await services.Get <ISingleService>(scope2); Assert.NotNull(service1); Assert.NotNull(service2); Assert.NotEqual(service1, service2); await Task.Delay(10); scope1.Dispose(); scope2.Dispose(); } }
public async Task ScopedInTransient() { ServiceContainer services = new ServiceContainer(); services.AddTransient <IParentService, ParentService>(); services.AddScoped <IFirstChildService, FirstChildService>(); services.AddScoped <ISecondChildService, SecondChildService>(); await Assert.ThrowsAsync <InvalidOperationException>(async() => await services.Get <IParentService>()); await Assert.ThrowsAsync <InvalidOperationException>(async() => await services.Get <IFirstChildService>()); await Assert.ThrowsAsync <InvalidOperationException>(async() => await services.Get <ISecondChildService>()); IContainerScope scope = services.CreateScope(); IParentService parent = await services.Get <IParentService>(scope); parent.Foo = "parent"; parent.First.Foo = "first"; parent.Second.Foo = "second"; IParentService p1 = await services.Get <IParentService>(scope); Assert.NotEqual(parent.Foo, p1.Foo); Assert.Equal(parent.First.Foo, p1.First.Foo); Assert.Equal(parent.Second.Foo, p1.Second.Foo); IContainerScope scope2 = services.CreateScope(); IParentService p2 = await services.Get <IParentService>(scope2); Assert.NotEqual(parent.Foo, p2.Foo); Assert.NotEqual(parent.First.Foo, p2.First.Foo); Assert.NotEqual(parent.Second.Foo, p2.Second.Foo); }
public void Transient() { ServiceContainer services = new ServiceContainer(); services.AddTransientPool <ISingleService, SingleService>(); IContainerScope scope = services.CreateScope(); ISingleService single = services.Get <ISingleService>(scope); single.Foo = "single"; ISingleService s1 = services.Get <ISingleService>(scope); Assert.NotEqual(single.Foo, s1.Foo); ISingleService s2 = services.Get <ISingleService>(); Assert.NotEqual(single.Foo, s2.Foo); IContainerScope scope2 = services.CreateScope(); ISingleService s3 = services.Get <ISingleService>(scope2); Assert.NotEqual(single.Foo, s3.Foo); }
public void Single() { ServiceContainer services = new ServiceContainer(); services.AddScoped <ISingleService, SingleService>(); IContainerScope scope = services.CreateScope(); ISingleService s1 = services.Get <ISingleService>(scope); s1.Foo = "a"; ISingleService s2 = services.Get <ISingleService>(scope); Assert.Equal(s1.Foo, s2.Foo); //scopeless should throw error Assert.Throws <ScopeException>(() => services.Get <ISingleService>()); //another scope should not equal IContainerScope scope2 = services.CreateScope(); ISingleService s4 = services.Get <ISingleService>(scope2); Assert.NotEqual(s1.Foo, s4.Foo); Assert.NotEqual(s2.Foo, s4.Foo); }
public void ScopedInTransient() { ServiceContainer services = new ServiceContainer(); services.AddTransient <IParentService, ParentService>(); services.AddScoped <IFirstChildService, FirstChildService>(); services.AddScoped <ISecondChildService, SecondChildService>(); Assert.Throws <ScopeException>(() => services.Get <IParentService>()); Assert.Throws <ScopeException>(() => services.Get <IFirstChildService>()); Assert.Throws <ScopeException>(() => services.Get <ISecondChildService>()); IContainerScope scope = services.CreateScope(); IParentService parent = services.Get <IParentService>(scope); parent.Foo = "parent"; parent.First.Foo = "first"; parent.Second.Foo = "second"; IParentService p1 = services.Get <IParentService>(scope); Assert.NotEqual(parent.Foo, p1.Foo); Assert.Equal(parent.First.Foo, p1.First.Foo); Assert.Equal(parent.Second.Foo, p1.Second.Foo); IContainerScope scope2 = services.CreateScope(); IParentService p2 = services.Get <IParentService>(scope2); Assert.NotEqual(parent.Foo, p2.Foo); Assert.NotEqual(parent.First.Foo, p2.First.Foo); Assert.NotEqual(parent.Second.Foo, p2.Second.Foo); }
public async void Single() { ServiceContainer services = new ServiceContainer(); services.AddScoped <ISingleService, SingleService>(); IContainerScope scope = services.CreateScope(); ISingleService s1 = await services.Get <ISingleService>(scope); s1.Foo = "a"; ISingleService s2 = await services.Get <ISingleService>(scope); Assert.Equal(s1.Foo, s2.Foo); //scopeless should throw error await Assert.ThrowsAsync <InvalidOperationException>(async() => await services.Get <ISingleService>()); //another scope should not equal IContainerScope scope2 = services.CreateScope(); ISingleService s4 = await services.Get <ISingleService>(scope2); Assert.NotEqual(s1.Foo, s4.Foo); Assert.NotEqual(s2.Foo, s4.Foo); }
public void MultipleNestedDoubleParameter() { ServiceContainer services = new ServiceContainer(); services.AddScoped <INestParentService, NestParentService>(); services.AddScoped <ISingleService, SingleService>(); services.AddScoped <IParentService, ParentService>(); services.AddScoped <IFirstChildService, FirstChildService>(); services.AddScoped <ISecondChildService, SecondChildService>(); IContainerScope scope = services.CreateScope(); INestParentService nest = services.Get <INestParentService>(scope); nest.Foo = "nest"; nest.Parent.Foo = "parent"; nest.Parent.First.Foo = "first"; nest.Parent.Second.Foo = "second"; nest.Single.Foo = "single"; INestParentService n1 = services.Get <INestParentService>(scope); Assert.Equal(nest.Foo, n1.Foo); Assert.Equal(nest.Single.Foo, n1.Single.Foo); Assert.Equal(nest.Parent.Foo, n1.Parent.Foo); Assert.Equal(nest.Parent.First.Foo, n1.Parent.First.Foo); Assert.Equal(nest.Parent.Second.Foo, n1.Parent.Second.Foo); IParentService parent = services.Get <IParentService>(scope); Assert.Equal(nest.Parent.Foo, parent.Foo); Assert.Equal(nest.Parent.First.Foo, parent.First.Foo); Assert.Equal(nest.Parent.Second.Foo, parent.Second.Foo); ISingleService single = services.Get <ISingleService>(scope); Assert.Equal(nest.Single.Foo, single.Foo); IFirstChildService first = services.Get <IFirstChildService>(scope); Assert.Equal(nest.Parent.First.Foo, first.Foo); ISecondChildService second = services.Get <ISecondChildService>(scope); Assert.Equal(nest.Parent.Second.Foo, second.Foo); //scopeless should throw error Assert.Throws <ScopeException>(() => services.Get <INestParentService>()); //another scope should not equal IContainerScope scope2 = services.CreateScope(); INestParentService n3 = services.Get <INestParentService>(scope2); Assert.NotEqual(nest.Foo, n3.Foo); Assert.NotEqual(nest.Single.Foo, n3.Single.Foo); Assert.NotEqual(nest.Parent.Foo, n3.Parent.Foo); Assert.NotEqual(nest.Parent.First.Foo, n3.Parent.First.Foo); Assert.NotEqual(nest.Parent.Second.Foo, n3.Parent.Second.Foo); }
public async Task ScopedInSingleton() { ServiceContainer services = new ServiceContainer(); services.AddSingleton <IParentService, ParentService>(); services.AddScoped <IFirstChildService, FirstChildService>(); services.AddScoped <ISecondChildService, SecondChildService>(); await Assert.ThrowsAsync <InvalidOperationException>(async() => await services.Get <IParentService>()); await Assert.ThrowsAsync <InvalidOperationException>(async() => await services.Get <IFirstChildService>()); await Assert.ThrowsAsync <InvalidOperationException>(async() => await services.Get <ISecondChildService>()); IContainerScope scope = services.CreateScope(); IParentService parent = await services.Get <IParentService>(scope); parent.Foo = "parent"; parent.First.Foo = "first"; parent.Second.Foo = "second"; IParentService p1 = await services.Get <IParentService>(scope); Assert.Equal(parent.Foo, p1.Foo); Assert.Equal(parent.First.Foo, p1.First.Foo); Assert.Equal(parent.Second.Foo, p1.Second.Foo); //in same scope, individual scoped items should equal IFirstChildService f1 = await services.Get <IFirstChildService>(scope); ISecondChildService s1 = await services.Get <ISecondChildService>(scope); Assert.Equal(parent.First.Foo, f1.Foo); Assert.Equal(parent.Second.Foo, s1.Foo); //scoped services in singleton should equal (because parent is same) IContainerScope scope2 = services.CreateScope(); IParentService p2 = await services.Get <IParentService>(scope2); Assert.Equal(parent.Foo, p2.Foo); Assert.Equal(parent.First.Foo, p2.First.Foo); Assert.Equal(parent.Second.Foo, p2.Second.Foo); //but individual created scoped items in different scope should not equal IFirstChildService f2 = await services.Get <IFirstChildService>(scope2); ISecondChildService s2 = await services.Get <ISecondChildService>(scope2); Assert.NotEqual(parent.First.Foo, f2.Foo); Assert.NotEqual(parent.Second.Foo, s2.Foo); }
public async void Nested() { ServiceContainer services = new ServiceContainer(); services.AddScoped <IParentService, ParentService>(); services.AddScoped <IFirstChildService, FirstChildService>(); services.AddScoped <ISecondChildService, SecondChildService>(); IContainerScope scope = services.CreateScope(); IParentService parent = await services.Get <IParentService>(scope); parent.Foo = "parent"; parent.First.Foo = "first"; parent.Second.Foo = "second"; IParentService p1 = await services.Get <IParentService>(scope); Assert.Equal(parent.Foo, p1.Foo); Assert.Equal(parent.First, p1.First); Assert.Equal(parent.Second, p1.Second); Assert.Equal(parent.First.Foo, p1.First.Foo); Assert.Equal(parent.Second.Foo, p1.Second.Foo); IFirstChildService first = await services.Get <IFirstChildService>(scope); ISecondChildService second = await services.Get <ISecondChildService>(scope); Assert.Equal(parent.First, first); Assert.Equal(parent.First.Foo, first.Foo); Assert.Equal(parent.Second.Foo, second.Foo); //scopeless should throw error await Assert.ThrowsAsync <InvalidOperationException>(async() => await services.Get <IParentService>()); await Assert.ThrowsAsync <InvalidOperationException>(async() => await services.Get <IFirstChildService>()); await Assert.ThrowsAsync <InvalidOperationException>(async() => await services.Get <ISecondChildService>()); //another scope should not equal IContainerScope scope2 = services.CreateScope(); IParentService p3 = await services.Get <IParentService>(scope2); Assert.NotEqual(parent.Foo, p3.Foo); Assert.NotEqual(parent.First, p3.First); Assert.NotEqual(parent.Second, p3.Second); Assert.NotEqual(parent.First.Foo, p3.First.Foo); Assert.NotEqual(parent.Second.Foo, p3.Second.Foo); }
public void TransientInTransientPool() { ServiceContainer services = new ServiceContainer(); services.AddTransientPool <IParentService, ParentService>(); services.AddTransient <IFirstChildService, FirstChildService>(); services.AddTransient <ISecondChildService, SecondChildService>(); IContainerScope scope = services.CreateScope(); IParentService parent = services.Get <IParentService>(scope); parent.Foo = "parent"; parent.First.Foo = "first"; parent.Second.Foo = "second"; IParentService p = services.Get <IParentService>(scope); Assert.NotEqual(parent.Foo, p.Foo); Assert.NotEqual(parent.First.Foo, p.First.Foo); Assert.NotEqual(parent.Second.Foo, p.Second.Foo); IFirstChildService f1 = services.Get <IFirstChildService>(); IFirstChildService f2 = services.Get <IFirstChildService>(scope); Assert.NotEqual(parent.First.Foo, f1.Foo); Assert.NotEqual(parent.First.Foo, f2.Foo); ISecondChildService s1 = services.Get <ISecondChildService>(); ISecondChildService s2 = services.Get <ISecondChildService>(scope); Assert.NotEqual(parent.Second.Foo, s1.Foo); Assert.NotEqual(parent.Second.Foo, s2.Foo); }
public void TransientInScoped() { ServiceContainer services = new ServiceContainer(); services.AddScoped <IParentService, ParentService>(); services.AddTransient <IFirstChildService, FirstChildService>(); services.AddTransient <ISecondChildService, SecondChildService>(); IContainerScope scope = services.CreateScope(); IParentService parent = services.Get <IParentService>(scope); parent.Foo = "parent"; parent.First.Foo = "first"; parent.Second.Foo = "second"; //services in scoped service is created only once (cuz they created via parent) IParentService p = services.Get <IParentService>(scope); Assert.Equal(parent.Foo, p.Foo); Assert.Equal(parent.First.Foo, p.First.Foo); Assert.Equal(parent.Second.Foo, p.Second.Foo); IFirstChildService first = services.Get <IFirstChildService>(scope); Assert.NotEqual(parent.First.Foo, first.Foo); ISecondChildService second = services.Get <ISecondChildService>(scope); Assert.NotEqual(parent.Second.Foo, second.Foo); }
public void WaitLimitAndTimeout() { ServiceContainer services = new ServiceContainer(); services.AddTransientPool <ISingleService, SingleService>(o => { o.PoolMaxSize = 10; o.ExceedLimitWhenWaitTimeout = false; o.WaitAvailableDuration = TimeSpan.FromMilliseconds(1500); }); IContainerScope scope = services.CreateScope(); for (int i = 0; i < 10; i++) { ISingleService service = services.Get <ISingleService>(scope); Assert.NotNull(service); } DateTime start = DateTime.UtcNow; Assert.Throws <NullReferenceException>(() => services.Get <ISingleService>(scope)); DateTime end = DateTime.UtcNow; Assert.True(end - start > TimeSpan.FromMilliseconds(1490)); }
public async void Single() { ServiceContainer services = new ServiceContainer(); services.AddTransient <ISingleService, SingleService>(); ISingleService s1 = await services.Get <ISingleService>(); s1.Foo = "a"; //s1 and s2 should not be equal because they should be different instances ISingleService s2 = await services.Get <ISingleService>(); Assert.NotEqual(s1.Foo, s2.Foo); //s1 or s2 should not equal to scoped transient instance IContainerScope scope = services.CreateScope(); ISingleService s3 = await services.Get <ISingleService>(scope); Assert.NotEqual(s1.Foo, s3.Foo); s3.Foo = "b"; //two transient instances in same scope should not be equal ISingleService s4 = await services.Get <ISingleService>(scope); Assert.NotEqual(s1.Foo, s4.Foo); Assert.NotEqual(s3.Foo, s4.Foo); }
public async Task PoolsInSingleton() { ServiceContainer services = new ServiceContainer(); services.AddSingleton <IParentService, ParentService>(); services.AddTransientPool <IFirstChildService, FirstChildService>(); services.AddScopedPool <ISecondChildService, SecondChildService>(); IContainerScope scope = services.CreateScope(); await Assert.ThrowsAsync <InvalidOperationException>(async() => await services.Get <IParentService>()); await Assert.ThrowsAsync <InvalidOperationException>(async() => await services.Get <ISecondChildService>()); IParentService parent = await services.Get <IParentService>(scope); parent.Foo = "parent"; parent.First.Foo = "first"; parent.Second.Foo = "second"; //getting same parent instance (cuz of singleton) so, transients in the same parent instances should be same IParentService p1 = await services.Get <IParentService>(scope); Assert.Equal(parent.Foo, p1.Foo); Assert.Equal(parent.First.Foo, p1.First.Foo); Assert.Equal(parent.Second.Foo, p1.Second.Foo); IFirstChildService first = await services.Get <IFirstChildService>(scope); IFirstChildService f2 = await services.Get <IFirstChildService>(); Assert.NotEqual(parent.First.Foo, first.Foo); Assert.NotEqual(parent.First.Foo, f2.Foo); ISecondChildService second = await services.Get <ISecondChildService>(scope); Assert.Equal(parent.Second.Foo, second.Foo); //children in same singleton instance are same IContainerScope scope2 = services.CreateScope(); IParentService p2 = await services.Get <IParentService>(scope2); Assert.Equal(parent.Foo, p2.Foo); Assert.Equal(parent.First.Foo, p2.First.Foo); Assert.Equal(parent.Second.Foo, p2.Second.Foo); }
public void Empty() { var services = new ServiceContainer(); Assert.Empty(services); Assert.False(services.IsReadOnly); Assert.DoesNotContain(new ServiceDescriptor(typeof(IService1), new Service1()), services); Assert.NotNull(services.CreateScope()); }
public async Task TransientInScopedPool() { ServiceContainer services = new ServiceContainer(); services.AddScopedPool <IParentService, ParentService>(); services.AddTransient <IFirstChildService, FirstChildService>(); services.AddTransient <ISecondChildService, SecondChildService>(); IContainerScope scope = services.CreateScope(); IParentService parent = await services.Get <IParentService>(scope); parent.Foo = "parent"; parent.First.Foo = "first"; parent.Second.Foo = "second"; //we are getting same instance of parent. so, children are same. IParentService p = await services.Get <IParentService>(scope); Assert.Equal(parent.Foo, p.Foo); Assert.Equal(parent.First.Foo, p.First.Foo); Assert.Equal(parent.Second.Foo, p.Second.Foo); //we are getting individual children, so they are created new and different IFirstChildService f1 = await services.Get <IFirstChildService>(); IFirstChildService f2 = await services.Get <IFirstChildService>(scope); Assert.NotEqual(parent.First.Foo, f1.Foo); Assert.NotEqual(parent.First.Foo, f2.Foo); //we are getting individual children, so they are created new and different ISecondChildService s1 = await services.Get <ISecondChildService>(); ISecondChildService s2 = await services.Get <ISecondChildService>(scope); Assert.NotEqual(parent.Second.Foo, s1.Foo); Assert.NotEqual(parent.Second.Foo, s2.Foo); IContainerScope scope2 = services.CreateScope(); IParentService p2 = await services.Get <IParentService>(scope2); Assert.NotEqual(parent.Foo, p2.Foo); }
public void PoolsInScopedPool() { ServiceContainer services = new ServiceContainer(); services.AddScopedPool <IParentService, ParentService>(); services.AddTransientPool <IFirstChildService, FirstChildService>(); services.AddScopedPool <ISecondChildService, SecondChildService>(); IContainerScope scope = services.CreateScope(); Assert.Throws <ScopeException>(() => services.Get <IParentService>()); Assert.Throws <ScopeException>(() => services.Get <ISecondChildService>()); IParentService parent = services.Get <IParentService>(scope); parent.Foo = "parent"; parent.First.Foo = "first"; parent.Second.Foo = "second"; //getting same parent instance (cuz of scoped) so, transients in the same parent instances should be same IParentService p1 = services.Get <IParentService>(scope); Assert.Equal(parent.Foo, p1.Foo); Assert.Equal(parent.First.Foo, p1.First.Foo); Assert.Equal(parent.Second.Foo, p1.Second.Foo); IFirstChildService first = services.Get <IFirstChildService>(scope); IFirstChildService f2 = services.Get <IFirstChildService>(); Assert.NotEqual(parent.First.Foo, first.Foo); Assert.NotEqual(parent.First.Foo, f2.Foo); ISecondChildService second = services.Get <ISecondChildService>(scope); Assert.Equal(parent.Second.Foo, second.Foo); IContainerScope scope2 = services.CreateScope(); IParentService p2 = services.Get <IParentService>(scope2); Assert.NotEqual(parent.Foo, p2.Foo); Assert.NotEqual(parent.First.Foo, p2.First.Foo); Assert.NotEqual(parent.Second.Foo, p2.Second.Foo); }
public async Task SingletonInScopedPool() { ServiceContainer services = new ServiceContainer(); services.AddScopedPool <IParentService, ParentService>(); services.AddSingleton <IFirstChildService, FirstChildService>(); services.AddSingleton <ISecondChildService, SecondChildService>(); IContainerScope scope = services.CreateScope(); IParentService parent = await services.Get <IParentService>(scope); parent.Foo = "parent"; parent.First.Foo = "first"; parent.Second.Foo = "second"; IParentService p = await services.Get <IParentService>(scope); Assert.Equal(parent.Foo, p.Foo); Assert.Equal(parent.First.Foo, p.First.Foo); Assert.Equal(parent.Second.Foo, p.Second.Foo); IFirstChildService f2 = await services.Get <IFirstChildService>(scope); IFirstChildService f3 = await services.Get <IFirstChildService>(); Assert.Equal(parent.First.Foo, f2.Foo); Assert.Equal(parent.First.Foo, f3.Foo); ISecondChildService s2 = await services.Get <ISecondChildService>(scope); ISecondChildService s3 = await services.Get <ISecondChildService>(); Assert.Equal(parent.Second.Foo, s2.Foo); Assert.Equal(parent.Second.Foo, s3.Foo); IContainerScope scope2 = services.CreateScope(); IParentService p2 = await services.Get <IParentService>(scope2); Assert.NotEqual(parent.Foo, p2.Foo); Assert.Equal(parent.First.Foo, p2.First.Foo); Assert.Equal(parent.Second.Foo, p2.Second.Foo); }
public async Task MultipleNestedDoubleParameter() { ServiceContainer services = new ServiceContainer(); services.AddSingleton <INestParentService, NestParentService>(); services.AddSingleton <ISingleService, SingleService>(); services.AddSingleton <IParentService, ParentService>(); services.AddSingleton <IFirstChildService, FirstChildService>(); services.AddSingleton <ISecondChildService, SecondChildService>(); INestParentService nest = await services.Get <INestParentService>(); nest.Foo = "nest"; nest.Parent.Foo = "parent"; nest.Parent.First.Foo = "first"; nest.Parent.Second.Foo = "second"; nest.Single.Foo = "single"; INestParentService n1 = await services.Get <INestParentService>(); Assert.Equal(nest.Foo, n1.Foo); Assert.Equal(nest.Single.Foo, n1.Single.Foo); Assert.Equal(nest.Parent.Foo, n1.Parent.Foo); Assert.Equal(nest.Parent.First.Foo, n1.Parent.First.Foo); Assert.Equal(nest.Parent.Second.Foo, n1.Parent.Second.Foo); IParentService parent = await services.Get <IParentService>(); Assert.Equal(nest.Parent.Foo, parent.Foo); Assert.Equal(nest.Parent.First.Foo, parent.First.Foo); Assert.Equal(nest.Parent.Second.Foo, parent.Second.Foo); ISingleService single = await services.Get <ISingleService>(); Assert.Equal(nest.Single.Foo, single.Foo); IFirstChildService first = await services.Get <IFirstChildService>(); Assert.Equal(nest.Parent.First.Foo, first.Foo); ISecondChildService second = await services.Get <ISecondChildService>(); Assert.Equal(nest.Parent.Second.Foo, second.Foo); IContainerScope scope = services.CreateScope(); INestParentService n2 = await services.Get <INestParentService>(scope); Assert.Equal(nest.Foo, n2.Foo); Assert.Equal(nest.Single.Foo, n2.Single.Foo); Assert.Equal(nest.Parent.Foo, n2.Parent.Foo); Assert.Equal(nest.Parent.First.Foo, n2.Parent.First.Foo); Assert.Equal(nest.Parent.Second.Foo, n2.Parent.Second.Foo); }
public async Task WaitLimitAndGet() { ServiceContainer services = new ServiceContainer(); services.AddTransientPool <ISingleService, SingleService>(o => { o.PoolMaxSize = 10; o.ExceedLimitWhenWaitTimeout = false; o.WaitAvailableDuration = TimeSpan.FromMilliseconds(5000); }); IContainerScope scope = services.CreateScope(); for (int i = 0; i < 10; i++) { ISingleService service = await services.Get <ISingleService>(scope); Assert.NotNull(service); } DateTime start = DateTime.UtcNow; Thread th = new Thread(() => { Thread.Sleep(500); scope.Dispose(); }); th.Start(); IContainerScope scope2 = services.CreateScope(); ISingleService s = await services.Get <ISingleService>(scope2); Assert.NotNull(s); DateTime end = DateTime.UtcNow; TimeSpan time = end - start; Assert.True(time > TimeSpan.FromMilliseconds(490)); Assert.True(time < TimeSpan.FromMilliseconds(750)); }
public async Task Scoped() { ServiceContainer services = new ServiceContainer(); services.AddScopedPool <ISingleService, SingleService>(); IContainerScope scope = services.CreateScope(); ISingleService single = await services.Get <ISingleService>(scope); single.Foo = "single"; ISingleService s1 = await services.Get <ISingleService>(scope); Assert.Equal(single.Foo, s1.Foo); await Assert.ThrowsAsync <InvalidOperationException>(async() => await services.Get <ISingleService>()); IContainerScope scope2 = services.CreateScope(); ISingleService s3 = await services.Get <ISingleService>(scope2); Assert.NotEqual(single.Foo, s3.Foo); }
public void Scoped() { ServiceContainer services = new ServiceContainer(); services.AddScopedPool <ISingleService, SingleService>(); IContainerScope scope = services.CreateScope(); ISingleService single = services.Get <ISingleService>(scope); single.Foo = "single"; ISingleService s1 = services.Get <ISingleService>(scope); Assert.Equal(single.Foo, s1.Foo); Assert.Throws <ScopeException>(() => services.Get <ISingleService>()); IContainerScope scope2 = services.CreateScope(); ISingleService s3 = services.Get <ISingleService>(scope2); Assert.NotEqual(single.Foo, s3.Foo); }
public void SingletonInScoped() { ServiceContainer services = new ServiceContainer(); services.AddScoped <IParentService, ParentService>(); services.AddSingleton <IFirstChildService, FirstChildService>(); services.AddSingleton <ISecondChildService, SecondChildService>(); IContainerScope scope = services.CreateScope(); IFirstChildService first = services.Get <IFirstChildService>(scope); first.Foo = "first"; IParentService parent = services.Get <IParentService>(scope); parent.Foo = "parent"; parent.Second.Foo = "second"; Assert.Equal(first.Foo, parent.First.Foo); ISecondChildService second = services.Get <ISecondChildService>(scope); Assert.Equal(second.Foo, parent.Second.Foo); IParentService p1 = services.Get <IParentService>(scope); Assert.Equal(p1.Foo, parent.Foo); Assert.Equal(p1.First.Foo, parent.First.Foo); Assert.Equal(p1.Second.Foo, parent.Second.Foo); IContainerScope scope2 = services.CreateScope(); IParentService p2 = services.Get <IParentService>(scope2); Assert.NotEqual(p2.Foo, parent.Foo); Assert.Equal(p2.First.Foo, parent.First.Foo); Assert.Equal(p2.Second.Foo, parent.Second.Foo); }
public async void Nested() { ServiceContainer services = new ServiceContainer(); services.AddTransient <IParentService, ParentService>(); services.AddTransient <IFirstChildService, FirstChildService>(); services.AddTransient <ISecondChildService, SecondChildService>(); IParentService parent = await services.Get <IParentService>(); parent.Foo = "parent"; parent.First.Foo = "first"; parent.Second.Foo = "second"; IParentService p1 = await services.Get <IParentService>(); Assert.NotEqual(parent.Foo, p1.Foo); Assert.NotEqual(parent.First.Foo, p1.First.Foo); Assert.NotEqual(parent.Second.Foo, p1.Second.Foo); IFirstChildService first = await services.Get <IFirstChildService>(); ISecondChildService second = await services.Get <ISecondChildService>(); Assert.NotEqual(parent.First.Foo, first.Foo); Assert.NotEqual(parent.Second.Foo, second.Foo); //scoped IContainerScope scope = services.CreateScope(); IParentService p2 = await services.Get <IParentService>(scope); Assert.NotEqual(parent.Foo, p2.Foo); Assert.NotEqual(parent.First, p2.First); Assert.NotEqual(parent.Second, p2.Second); Assert.NotEqual(parent.First.Foo, p2.First.Foo); Assert.NotEqual(parent.Second.Foo, p2.Second.Foo); IFirstChildService firstScoped = await services.Get <IFirstChildService>(scope); ISecondChildService secondScoped = await services.Get <ISecondChildService>(scope); Assert.NotEqual(parent.First, firstScoped); Assert.NotEqual(parent.First.Foo, firstScoped.Foo); Assert.NotEqual(parent.Second.Foo, secondScoped.Foo); }
public async Task Single() { ServiceContainer services = new ServiceContainer(); services.AddSingleton <ISingleService, SingleService>(); ISingleService singleton = await services.Get <ISingleService>(); singleton.Foo = "singleton"; ISingleService s1 = await services.Get <ISingleService>(); Assert.Equal(singleton.Foo, s1.Foo); IContainerScope scope = services.CreateScope(); ISingleService s2 = await services.Get <ISingleService>(scope); Assert.Equal(singleton.Foo, s2.Foo); }
public void Instanced() { SingleService singleService = new SingleService(); singleService.Foo = "singleton"; ServiceContainer services = new ServiceContainer(); services.AddSingleton <ISingleService, SingleService>(singleService); ISingleService s1 = services.Get <ISingleService>(); Assert.Equal(singleService.Foo, s1.Foo); IContainerScope scope = services.CreateScope(); ISingleService s2 = services.Get <ISingleService>(scope); Assert.Equal(singleService.Foo, s2.Foo); }
public async Task Nested() { ServiceContainer services = new ServiceContainer(); services.AddSingleton <IParentService, ParentService>(); services.AddSingleton <IFirstChildService, FirstChildService>(); services.AddSingleton <ISecondChildService, SecondChildService>(); IParentService singleton = await services.Get <IParentService>(); singleton.Foo = "singleton"; singleton.First.Foo = "first"; singleton.Second.Foo = "second"; IParentService p1 = await services.Get <IParentService>(); Assert.Equal(singleton.Foo, p1.Foo); Assert.Equal(singleton.First, p1.First); Assert.Equal(singleton.Second, p1.Second); Assert.Equal(singleton.First.Foo, p1.First.Foo); Assert.Equal(singleton.Second.Foo, p1.Second.Foo); IFirstChildService first = await services.Get <IFirstChildService>(); Assert.Equal(singleton.First.Foo, first.Foo); ISecondChildService second = await services.Get <ISecondChildService>(); Assert.Equal(singleton.Second.Foo, second.Foo); IContainerScope scope = services.CreateScope(); IParentService p2 = await services.Get <IParentService>(scope); Assert.Equal(singleton.Foo, p2.Foo); Assert.Equal(singleton.First, p2.First); Assert.Equal(singleton.Second, p2.Second); Assert.Equal(singleton.First.Foo, p2.First.Foo); Assert.Equal(singleton.Second.Foo, p2.Second.Foo); }
static void Main(string[] args) { IServiceContainer container = new ServiceContainer(); //container.AddDataContextTransient //container.AddDataContextTransientPool container.AddDataContextScoped <MyContext>(o => o.UseNpgsql("connection-string")); container.AddDataContextScopedPool <MyContext>(o => o.UseNpgsql("connection-string"), p => { p.PoolMinSize = 20; p.PoolMaxSize = 120; p.MaximumLockDuration = TimeSpan.FromSeconds(60); p.IdleTimeout = TimeSpan.FromSeconds(90); p.WaitAvailableDuration = TimeSpan.FromMilliseconds(1500); p.ExceedLimitWhenWaitTimeout = false; }); //create a scope for using Scoped registrations IContainerScope scope = container.CreateScope(); //get db context from pool MyContext context = container.Get <MyContext>(scope); }
public void MultipleNestedDoubleParameter() { ServiceContainer services = new ServiceContainer(); services.AddTransient <INestParentService, NestParentService>(); services.AddTransient <ISingleService, SingleService>(); services.AddTransient <IParentService, ParentService>(); services.AddTransient <IFirstChildService, FirstChildService>(); services.AddTransient <ISecondChildService, SecondChildService>(); INestParentService nest = services.Get <INestParentService>(); nest.Foo = "nest"; nest.Parent.Foo = "parent"; nest.Parent.First.Foo = "first"; nest.Parent.Second.Foo = "second"; nest.Single.Foo = "single"; INestParentService n1 = services.Get <INestParentService>(); Assert.NotEqual(nest.Foo, n1.Foo); Assert.NotEqual(nest.Single.Foo, n1.Single.Foo); Assert.NotEqual(nest.Parent.Foo, n1.Parent.Foo); Assert.NotEqual(nest.Parent.First.Foo, n1.Parent.First.Foo); Assert.NotEqual(nest.Parent.Second.Foo, n1.Parent.Second.Foo); IParentService parent = services.Get <IParentService>(); Assert.NotEqual(nest.Parent.Foo, parent.Foo); Assert.NotEqual(nest.Parent.First.Foo, parent.First.Foo); Assert.NotEqual(nest.Parent.Second.Foo, parent.Second.Foo); ISingleService single = services.Get <ISingleService>(); Assert.NotEqual(nest.Single.Foo, single.Foo); IFirstChildService first = services.Get <IFirstChildService>(); Assert.NotEqual(nest.Parent.First.Foo, first.Foo); ISecondChildService second = services.Get <ISecondChildService>(); Assert.NotEqual(nest.Parent.Second.Foo, second.Foo); IContainerScope scope = services.CreateScope(); INestParentService n2 = services.Get <INestParentService>(scope); Assert.NotEqual(nest.Foo, n2.Foo); Assert.NotEqual(nest.Single.Foo, n2.Single.Foo); Assert.NotEqual(nest.Parent.Foo, n2.Parent.Foo); Assert.NotEqual(nest.Parent.First.Foo, n2.Parent.First.Foo); Assert.NotEqual(nest.Parent.Second.Foo, n2.Parent.Second.Foo); n2.Foo = "nest-2"; n2.Parent.Foo = "parent-2"; n2.Parent.First.Foo = "first-2"; n2.Parent.Second.Foo = "second-2"; n2.Single.Foo = "single-2"; INestParentService n3 = services.Get <INestParentService>(scope); Assert.NotEqual(n2.Foo, n3.Foo); Assert.NotEqual(n2.Single.Foo, n3.Single.Foo); Assert.NotEqual(n2.Parent.Foo, n3.Parent.Foo); Assert.NotEqual(n2.Parent.First.Foo, n3.Parent.First.Foo); Assert.NotEqual(n2.Parent.Second.Foo, n3.Parent.Second.Foo); }
public static void BuiltInIocTest() { using (IServiceContainer container = new ServiceContainer()) { container.AddSingleton <IConfiguration>(new ConfigurationBuilder() .AddJsonFile("appsettings.json") .Build() ); container.AddScoped <IFly, MonkeyKing>(); container.AddScoped <IFly, Superman>(); container.AddScoped <HasDependencyTest>(); container.AddScoped <HasDependencyTest1>(); container.AddScoped <HasDependencyTest2>(); container.AddScoped <HasDependencyTest3>(); container.AddScoped(typeof(HasDependencyTest4 <>)); container.AddTransient <WuKong>(); container.AddScoped <WuJing>(serviceProvider => new WuJing()); container.AddSingleton(typeof(GenericServiceTest <>)); var rootConfig = container.ResolveService <IConfiguration>(); //try //{ // container.ResolveService<IFly>(); //} //catch (Exception e) //{ // Console.WriteLine(e); //} using (var scope = container.CreateScope()) { var config = scope.ResolveService <IConfiguration>(); var fly1 = scope.ResolveService <IFly>(); var fly2 = scope.ResolveService <IFly>(); var wukong1 = scope.ResolveService <WuKong>(); var wukong2 = scope.ResolveService <WuKong>(); var wuJing1 = scope.ResolveService <WuJing>(); var wuJing2 = scope.ResolveService <WuJing>(); Console.WriteLine("fly1 == fly2, {0}", fly1 == fly2); Console.WriteLine("rootConfig == config, {0}", rootConfig == config); Console.WriteLine("wukong1 == wukong2, {0}", wukong1 == wukong2); Console.WriteLine("wujing1 == wujing2, {0}", wuJing1 == wuJing2); fly1.Fly(); wukong1.Jump(); wukong2.Jump(); wuJing1.Eat(); var s0 = scope.ResolveRequiredService <HasDependencyTest>(); s0.Test(); Console.WriteLine($"s0._fly == fly1 : {s0._fly == fly1}"); var s1 = scope.ResolveService <HasDependencyTest1>(); s1.Test(); var s2 = scope.ResolveService <HasDependencyTest2>(); s2.Test(); var s3 = scope.ResolveService <HasDependencyTest3>(); s3.Test(); var s4 = scope.ResolveService <HasDependencyTest4 <string> >(); s4.Test(); using (var innerScope = scope.CreateScope()) { var config2 = innerScope.ResolveRequiredService <IConfiguration>(); Console.WriteLine("rootConfig == config2, {0}", rootConfig == config2); var fly3 = innerScope.ResolveRequiredService <IFly>(); fly3.Fly(); } var number = config.GetAppSetting <int>("Number"); Console.WriteLine(number); var flySvcs = scope.ResolveServices <IFly>(); foreach (var f in flySvcs) { f.Fly(); } } var genericService1 = container.ResolveRequiredService <GenericServiceTest <int> >(); genericService1.Test(); var genericService2 = container.ResolveRequiredService <GenericServiceTest <string> >(); genericService2.Test(); } }