public void ResolveAllStartable() { var registrar = new ContainerRegistrar(); registrar.RegisterConcrete<Startable1>(Lifetime.Singleton); registrar.RegisterConcrete<Startable2>(Lifetime.Singleton); var builder = new ContainerBuilder(); var container = builder.Build(registrar); var instances = container.ResolveAll<ISingletonStartable>(); Assert.Equal(2, instances.Count()); }
public void Test() { var registrar = new ContainerRegistrar(); registrar.RegisterConcrete <Service1>(); registrar.RegisterConcrete <Service2>(); registrar.RegisterConcrete <Service3>(); var builder = new ContainerBuilder(); Assert.Throws <CircularDependenciesException>(() => builder.Build(registrar)); }
public void OneDependencySingleton() { var registrar = new ContainerRegistrar(); registrar.RegisterConcrete<MySelf>(Lifetime.Transient); registrar.RegisterConcrete<OneDepencency>(Lifetime.Singleton); var builder = new ContainerBuilder(); var container = builder.Build(registrar); var instance1 = container.Resolve<OneDepencency>(); var instance2 = container.Resolve<OneDepencency>(); Assert.Same(instance1, instance2); }
public void ResolveAllStartable() { var registrar = new ContainerRegistrar(); registrar.RegisterConcrete <Startable1>(Lifetime.Singleton); registrar.RegisterConcrete <Startable2>(Lifetime.Singleton); var builder = new ContainerBuilder(); var container = builder.Build(registrar); var instances = container.ResolveAll <ISingletonStartable>(); Assert.Equal(2, instances.Count()); }
public void Test() { var registrar = new ContainerRegistrar(Lifetime.Transient); registrar.RegisterConcrete<Will>(); registrar.RegisterConcrete<Wont>(); registrar.RegisterConcrete<Subject>(); var c = registrar.Build(); var actual = c.Resolve<Subject>(); Assert.NotNull(actual); Assert.IsAssignableFrom<Subject>(actual); }
public void Test() { var registrar = new ContainerRegistrar(Lifetime.Transient); registrar.RegisterConcrete <Will>(); registrar.RegisterConcrete <Wont>(); registrar.RegisterConcrete <Subject>(); var c = registrar.Build(); var actual = c.Resolve <Subject>(); Assert.NotNull(actual); Assert.IsAssignableFrom <Subject>(actual); }
public void OneDependencySingleton() { var registrar = new ContainerRegistrar(); registrar.RegisterConcrete <MySelf>(Lifetime.Transient); registrar.RegisterConcrete <OneDepencency>(Lifetime.Singleton); var builder = new ContainerBuilder(); var container = builder.Build(registrar); var instance1 = container.Resolve <OneDepencency>(); var instance2 = container.Resolve <OneDepencency>(); Assert.Same(instance1, instance2); }
private Container ConfigureGriffinContainer() { var registrar = new ContainerRegistrar(); // Repositories registrar.RegisterConcrete<RaceMemoryRepository>(Lifetime.Singleton); registrar.RegisterConcrete<UserMemoryRepository>(Lifetime.Singleton); registrar.RegisterConcrete<ResultMemoryRepository>(Lifetime.Singleton); registrar.RegisterConcrete<ApplicationStateMemoryRepository>(Lifetime.Singleton); registrar.RegisterComponents(Lifetime.Default, typeof(RfidTagRegistrationHandler).Assembly); registrar.RegisterComponents(Lifetime.Singleton, typeof(DebugUserControlViewModel).Assembly); return registrar.Build(); }
static void Main(string[] args) { var registrar = new ContainerRegistrar(); registrar.RegisterConcrete <Hello>(Lifetime.Singleton); // will register as the implemented interfaces var container = registrar.Build(); // will get var instance1 = container.Resolve <IPrintable>(); var instance2 = container.Resolve <IInvokable>(); // Will get same instance // since both is implemented by the same class. instance1.Print(null); instance2.DoSomeWork(); try { container.Resolve <Hello>(); } catch (ServiceNotRegisteredException) { // throws exception as we've implemented // non .NET specific interfaces. // // since we should not depend on concretes. // (design choice in griffin.container) } Console.WriteLine("Press enter to quit"); Console.ReadLine(); }
static void Main(string[] args) { var registrar = new ContainerRegistrar(); registrar.RegisterConcrete<Hello>(Lifetime.Singleton); // will register as the implemented interfaces var container = registrar.Build(); // will get var instance1 = container.Resolve<IPrintable>(); var instance2 = container.Resolve<IInvokable>(); // Will get same instance // since both is implemented by the same class. instance1.Print(null); instance2.DoSomeWork(); try { container.Resolve<Hello>(); } catch(ServiceNotRegisteredException) { // throws exception as we've implemented // non .NET specific interfaces. // // since we should not depend on concretes. // (design choice in griffin.container) } Console.WriteLine("Press enter to quit"); Console.ReadLine(); }
public void Should_be_able_To_take_an_specified_generic_as_a_dependency() { var t = typeof(ISomeDude <>); var t2 = typeof(ISomeDude <string>); var registrar = new ContainerRegistrar(); registrar.RegisterType(typeof(IRestrictedGeneric <SomeClass>), typeof(RestrictedGeneric <SomeClass>), Lifetime.Singleton); registrar.RegisterConcrete <Word>(Lifetime.Transient); registrar.RegisterConcrete <SomeProcessor>(Lifetime.Singleton); var container = registrar.Build(); var actual = container.Resolve <SomeProcessor>(); Assert.NotNull(actual); }
public void Build(Action <ContainerRegistrar> action, ConfigurationStore configStore) { var builder = new ContainerRegistrar(); //need to invoke first to allow plug-ins to override default behavior. action(builder); builder.RegisterComponents(Lifetime.Scoped, Assembly.GetExecutingAssembly()); builder.RegisterService(CreateUnitOfWork, Lifetime.Scoped); builder.RegisterService(CreateTaskInvoker, Lifetime.Singleton); RegisterBuiltInComponents(builder); RegisterQueues(builder); builder.RegisterService(x => Container, Lifetime.Singleton); builder.RegisterService(x => x); builder.RegisterConcrete <AnalysisDbContext>(); builder.RegisterInstance(configStore); builder.RegisterType(typeof(IConfiguration <>), typeof(ConfigWrapper <>), Lifetime.Transient); builder.RegisterApiControllers(Assembly.GetExecutingAssembly()); builder.RegisterControllers(Assembly.GetExecutingAssembly()); builder.RegisterService(x => configStore.Load <BaseConfiguration>()); var ioc = builder.Build(); DependencyResolver.SetResolver(new GriffinDependencyResolver(ioc)); GlobalConfiguration.Configuration.DependencyResolver = new GriffinWebApiDependencyResolver2(ioc); Container = new GriffinContainerAdapter(ioc); }
public void TwoChildContainers() { var registrar = new ContainerRegistrar(); registrar.RegisterConcrete <MySelf>(); var builder = new ContainerBuilder(); var container = builder.Build(registrar); MySelf instance1, instance2; var childContainer1 = container.CreateChildContainer(); var childContainer2 = container.CreateChildContainer(); instance1 = childContainer1.Resolve <MySelf>(); instance2 = childContainer2.Resolve <MySelf>(); Assert.False(instance1.IsDisposed); Assert.False(instance2.IsDisposed); childContainer1.Dispose(); Assert.True(instance1.IsDisposed); Assert.False(instance2.IsDisposed); childContainer2.Dispose(); Assert.True(instance2.IsDisposed); }
static void Main(string[] args) { var registrar = new ContainerRegistrar(); registrar.RegisterConcrete <Hello>(Lifetime.Transient); // <-- transient var container = registrar.Build(); // will get var instance1 = container.Resolve <Hello>(); instance1.World(); // a new instance var instance2 = container.Resolve <Hello>(); instance2.World(); // every time = transient var instance3 = container.Resolve <Hello>(); instance3.World(); Console.WriteLine("Press enter to quit"); Console.ReadLine(); }
/// <summary> /// Creates a <see cref="T:System.ServiceModel.ServiceHost"/> for a specified type of service with a specific base address. /// </summary> /// <param name="serviceType">Specifies the type of service to host.</param> /// <param name="baseAddresses">The <see cref="T:System.Array"/> of type <see cref="T:System.Uri"/> that contains the base addresses for the service hosted.</param> /// <returns> /// A <see cref="T:System.ServiceModel.ServiceHost"/> for the type of service specified with a specific base address. /// </returns> protected override ServiceHost CreateServiceHost(Type serviceType, Uri[] baseAddresses) { if (serviceType == null) { throw new ArgumentNullException("serviceType"); } ServiceBehaviorAttribute attribute; var lifetime = GetLifetime(serviceType, out attribute); if (_container == null) { var registrar = new ContainerRegistrar(); registrar.RegisterConcrete(serviceType, lifetime); registrar.RegisterModules(serviceType.Assembly); _container = registrar.Build(); } var host = new ServiceLocatorServiceHost(_container, serviceType, baseAddresses); if (ConfigurationCallback != null) { ConfigurationCallback(host); } return(host); }
private void RegisterQueues(ContainerRegistrar builder) { builder.RegisterComponents(Lifetime.Scoped, typeof(QueueProvider).Assembly); var queueProviderTypeStr = ConfigurationManager.AppSettings["QueueProviderType"]; if (string.IsNullOrEmpty(queueProviderTypeStr)) { builder.RegisterConcrete <QueueProvider>(Lifetime.Singleton); return; } var type = Type.GetType(queueProviderTypeStr, true); builder.RegisterConcrete(type, Lifetime.Singleton); }
public void Build(Action <ContainerRegistrar> action, ConfigurationStore configStore) { var builder = new ContainerRegistrar(); builder.RegisterComponents(Lifetime.Scoped, Assembly.GetExecutingAssembly()); builder.RegisterService(CreateConnection, Lifetime.Scoped); builder.RegisterService(CreateTaskInvoker, Lifetime.Singleton); builder.RegisterInstance(Startup.ConnectionFactory); action(builder); RegisterBuiltInComponents(builder); RegisterQueues(builder); builder.RegisterService(x => Container, Lifetime.Singleton); builder.RegisterService(x => x); builder.RegisterConcrete <AnalysisDbContext>(); builder.RegisterInstance(configStore); builder.RegisterApiControllers(Assembly.GetExecutingAssembly()); builder.RegisterControllers(Assembly.GetExecutingAssembly()); var ioc = builder.Build(); DependencyResolver.SetResolver(new GriffinDependencyResolver(ioc)); GlobalConfiguration.Configuration.DependencyResolver = new GriffinWebApiDependencyResolver2(ioc); Container = new GriffinContainerAdapter(ioc); }
public void TestDecorateHiearchy() { // register services var registrar = new ContainerRegistrar(); registrar.RegisterConcrete<Decorated1>(Lifetime.Transient); registrar.RegisterConcrete<Decorated2>(Lifetime.Transient); registrar.RegisterConcrete<Decorated3>(Lifetime.Transient); var container = registrar.Build(); // only log transient services var filter = new DelegateDecoratorFilter(ctx => ctx.Lifetime == Lifetime.Transient); var decorator = new ExceptionLoggerDecorator(this, filter); container.AddDecorator(decorator); // exception will be logged. var all = container.ResolveAll<IShouldBeDecorated>(); Assert.True(all.All(x => x.GetType().Name.Contains("Proxy"))); }
public void TestSingleton() { var registrar = new ContainerRegistrar(); registrar.RegisterInstance <MySelf>(new MySelf()); registrar.RegisterConcrete <OneDepencency>(Lifetime.Singleton); var container = registrar.Build(); container.Resolve <OneDepencency>(); }
static void Main(string[] args) { var registrar = new ContainerRegistrar(); registrar.RegisterConcrete<Hello>(Lifetime.Transient); registrar.RegisterConcrete<OurDependency>(Lifetime.Singleton); var container = registrar.Build(); // gets a new OurDependency var obj1 = container.Resolve<Hello>(); obj1.World(); // New Hello instance, but with the same OurDependency. var obj2 = container.Resolve<Hello>(); obj2.World(); Console.WriteLine(); Console.WriteLine("Press enter to quit"); Console.ReadLine(); }
public void TestDelegateFactory() { var registrar = new ContainerRegistrar(); registrar.RegisterService <MySelf>(ctnr => new MySelf(), Lifetime.Transient); registrar.RegisterConcrete <OneDepencency>(Lifetime.Singleton); var container = registrar.Build(); container.Resolve <OneDepencency>(); }
public void Test() { var registrar = new ContainerRegistrar(); registrar.RegisterConcrete<Service1>(); var builder = new ContainerBuilder(); Assert.Throws<ConcreteDependencyMissingException>(() =>builder.Build(registrar)); }
public void NoRegisteredConcretes() { var registrar = new ContainerRegistrar(Lifetime.Transient); registrar.RegisterConcrete<NoInstancesSubject>(); var c = registrar.Build(); var actual = c.Resolve<NoInstancesSubject>(); Assert.NotNull(actual); Assert.IsAssignableFrom<NoInstancesSubject>(actual); }
public void InterfaceToConcrete() { var registrar = new ContainerRegistrar(); registrar.RegisterType(typeof(ISomeDude <>), typeof(SomeDude <>), Lifetime.Transient); registrar.RegisterConcrete <Word>(Lifetime.Transient); var container = registrar.Build(); var actual = container.Resolve <ISomeDude <string> >(); Assert.NotNull(actual); }
public void Should_be_able_To_resolve_open_generics_which_are_type_restricted() { var registrar = new ContainerRegistrar(); registrar.RegisterType(typeof(IRestrictedGeneric <>), typeof(RestrictedGeneric <>), Lifetime.Singleton); registrar.RegisterConcrete <Word>(Lifetime.Transient); var container = registrar.Build(); var actual = container.Resolve <IRestrictedGeneric <SomeClass> >(); Assert.NotNull(actual); }
public void NoRegisteredConcretes() { var registrar = new ContainerRegistrar(Lifetime.Transient); registrar.RegisterConcrete <NoInstancesSubject>(); var c = registrar.Build(); var actual = c.Resolve <NoInstancesSubject>(); Assert.NotNull(actual); Assert.IsAssignableFrom <NoInstancesSubject>(actual); }
public void RegisterServiceAsInstance() { var registrar = new ContainerRegistrar(Lifetime.Transient); registrar.RegisterInstance<IThinkNot>(new Will()); registrar.RegisterConcrete<InstanceSubject>(); var c = registrar.Build(); var actual = c.Resolve<InstanceSubject>(); Assert.NotNull(actual); Assert.IsAssignableFrom<InstanceSubject>(actual); }
public void TestDecorateHiearchy() { // register services var registrar = new ContainerRegistrar(); registrar.RegisterConcrete <Decorated1>(Lifetime.Transient); registrar.RegisterConcrete <Decorated2>(Lifetime.Transient); registrar.RegisterConcrete <Decorated3>(Lifetime.Transient); var container = registrar.Build(); // only log transient services var filter = new DelegateDecoratorFilter(ctx => ctx.Lifetime == Lifetime.Transient); var decorator = new ExceptionLoggerDecorator(this, filter); container.AddDecorator(decorator); // exception will be logged. var all = container.ResolveAll <IShouldBeDecorated>(); Assert.True(all.All(x => x.GetType().Name.Contains("Proxy"))); }
public void Should_be_able_To_resolve_open_generics_in_singleton_scope() { var registrar = new ContainerRegistrar(); registrar.RegisterType(typeof(ISomeDude <>), typeof(SomeDude <>), Lifetime.Singleton); registrar.RegisterConcrete <Word>(Lifetime.Transient); var container = registrar.Build(); var actual = container.Resolve <ISomeDude <string> >(); Assert.NotNull(actual); }
public void SimpleRegistrationTransient() { var registrar = new ContainerRegistrar(); registrar.RegisterConcrete<MySelf>(Lifetime.Transient); var builder = new ContainerBuilder(); var container = builder.Build(registrar); var instance1 = container.Resolve<MySelf>(); var instance2 = container.Resolve<MySelf>(); Assert.NotSame(instance1, instance2); }
public void RegisteredSpecific() { var registrar = new ContainerRegistrar(); registrar.RegisterType(typeof(ISomeDude <>), typeof(SomeDude <>), Lifetime.Transient); registrar.RegisterType(typeof(ISomeDude <int>), typeof(MyClass), Lifetime.Transient); registrar.RegisterConcrete <Word>(Lifetime.Transient); var container = registrar.Build(); var actual = container.Resolve <ISomeDude <int> >(); Assert.IsType <MyClass>(actual); }
public void RegisterServiceAsInstance() { var registrar = new ContainerRegistrar(Lifetime.Transient); registrar.RegisterInstance <IThinkNot>(new Will()); registrar.RegisterConcrete <InstanceSubject>(); var c = registrar.Build(); var actual = c.Resolve <InstanceSubject>(); Assert.NotNull(actual); Assert.IsAssignableFrom <InstanceSubject>(actual); }
static void Main(string[] args) { var registrar = new ContainerRegistrar(); registrar.RegisterConcrete <Hello>(Lifetime.Transient); registrar.RegisterConcrete <OurDependency>(Lifetime.Singleton); var container = registrar.Build(); // gets a new OurDependency var obj1 = container.Resolve <Hello>(); obj1.World(); // New Hello instance, but with the same OurDependency. var obj2 = container.Resolve <Hello>(); obj2.World(); Console.WriteLine(); Console.WriteLine("Press enter to quit"); Console.ReadLine(); }
public void SimpleRegistrationTransient() { var registrar = new ContainerRegistrar(); registrar.RegisterConcrete <MySelf>(Lifetime.Transient); var builder = new ContainerBuilder(); var container = builder.Build(registrar); var instance1 = container.Resolve <MySelf>(); var instance2 = container.Resolve <MySelf>(); Assert.NotSame(instance1, instance2); }
public void Test() { var reg = new ContainerRegistrar(); reg.RegisterConcrete <FirstService>(Lifetime.Singleton); reg.RegisterConcrete <AnotherFirstService>(Lifetime.Scoped); reg.RegisterConcrete <TestWithDependency>(Lifetime.Singleton); reg.RegisterConcrete <TestWithDependency2>(Lifetime.Scoped); var container = reg.Build(); var single = container.Resolve <IFirstService>(); container.Resolve <TestWithDependency>(); IFirstService scoped; using (var scope = container.CreateChildContainer()) { scoped = scope.Resolve <IFirstService>(); scope.Resolve <TestWithDependency2>(); } Assert.IsType <FirstService>(single); Assert.IsType <AnotherFirstService>(scoped); }
public void ChildContainer() { var registrar = new ContainerRegistrar(); registrar.RegisterConcrete<MySelf>(); var builder = new ContainerBuilder(); var container = builder.Build(registrar); MySelf instance; using (var childContainer = container.CreateChildContainer()) { instance = childContainer.Resolve<MySelf>(); } Assert.True(instance.IsDisposed); }
public void ChildContainer() { var registrar = new ContainerRegistrar(); registrar.RegisterConcrete <MySelf>(); var builder = new ContainerBuilder(); var container = builder.Build(registrar); MySelf instance; using (var childContainer = container.CreateChildContainer()) { instance = childContainer.Resolve <MySelf>(); } Assert.True(instance.IsDisposed); }
public void TestLoggingDecorator() { // register services var registrar = new ContainerRegistrar(); registrar.RegisterConcrete<TotalFailure>(Lifetime.Transient); var container = registrar.Build(); // only log transient services var filter = new DelegateDecoratorFilter(ctx => ctx.Lifetime == Lifetime.Transient); var decorator = new ExceptionLoggerDecorator(this, filter); container.AddDecorator(decorator); // exception will be logged. var tmp = container.Resolve<TotalFailure>(); Assert.Throws<InvalidOperationException>(() => tmp.Fail("Big!")); Assert.IsType<InvalidOperationException>(_exception); }
public void TestLoggingDecorator() { // register services var registrar = new ContainerRegistrar(); registrar.RegisterConcrete <TotalFailure>(Lifetime.Transient); var container = registrar.Build(); // only log transient services var filter = new DelegateDecoratorFilter(ctx => ctx.Lifetime == Lifetime.Transient); var decorator = new ExceptionLoggerDecorator(this, filter); container.AddDecorator(decorator); // exception will be logged. var tmp = container.Resolve <TotalFailure>(); Assert.Throws <InvalidOperationException>(() => tmp.Fail("Big!")); Assert.IsType <InvalidOperationException>(_exception); }
static void Main(string[] args) { var registrar = new ContainerRegistrar(); registrar.RegisterConcrete<Hello>(Lifetime.Singleton); //<-- singleton var container = registrar.Build(); // Will get var instance1 = container.Resolve<Hello>(); instance1.World(); // the same instance var instance2 = container.Resolve<Hello>(); instance2.World(); // every time = singleton var instance3 = container.Resolve<Hello>(); instance3.World(); Console.WriteLine("Press enter to quit"); Console.ReadLine(); }
static void Main(string[] args) { var registrar = new ContainerRegistrar(); registrar.RegisterConcrete<Hello>(Lifetime.Transient); // <-- transient var container = registrar.Build(); // will get var instance1 = container.Resolve<Hello>(); instance1.World(); // a new instance var instance2 = container.Resolve<Hello>(); instance2.World(); // every time = transient var instance3 = container.Resolve<Hello>(); instance3.World(); Console.WriteLine("Press enter to quit"); Console.ReadLine(); }
/// <summary> /// Creates a <see cref="T:System.ServiceModel.ServiceHost"/> for a specified type of service with a specific base address. /// </summary> /// <param name="serviceType">Specifies the type of service to host.</param> /// <param name="baseAddresses">The <see cref="T:System.Array"/> of type <see cref="T:System.Uri"/> that contains the base addresses for the service hosted.</param> /// <returns> /// A <see cref="T:System.ServiceModel.ServiceHost"/> for the type of service specified with a specific base address. /// </returns> protected override ServiceHost CreateServiceHost(Type serviceType, Uri[] baseAddresses) { if (serviceType == null) throw new ArgumentNullException("serviceType"); ServiceBehaviorAttribute attribute; var lifetime = GetLifetime(serviceType, out attribute); if (_container == null) { var registrar = new ContainerRegistrar(); registrar.RegisterConcrete(serviceType, lifetime); registrar.RegisterModules(serviceType.Assembly); _container = registrar.Build(); } var host = new ServiceLocatorServiceHost(_container, serviceType, baseAddresses); if (ConfigurationCallback != null) ConfigurationCallback(host); return host; }
static void Main(string[] args) { var registrar = new ContainerRegistrar(); registrar.RegisterConcrete <Hello>(Lifetime.Scoped); //<-- scoped var container = registrar.Build(); try { // May not resolve scoped objects // in the global container. var instance1 = container.Resolve <Hello>(); instance1.World(); } catch (InvalidOperationException) { } using (var scope = container.CreateChildContainer()) { // notice that it get disposed when the scope gets disposed. var obj1 = scope.Resolve <Hello>(); obj1.World(); // will get same instance var obj2 = scope.Resolve <Hello>(); obj2.World(); } using (var scope = container.CreateChildContainer()) { // Will get a new instance, since it's a new scope. var obj1 = scope.Resolve <Hello>(); obj1.World(); } Console.WriteLine("Press enter to quit"); Console.ReadLine(); }
static void Main(string[] args) { var registrar = new ContainerRegistrar(); registrar.RegisterConcrete<Hello>(Lifetime.Scoped); //<-- scoped var container = registrar.Build(); try { // May not resolve scoped objects // in the global container. var instance1 = container.Resolve<Hello>(); instance1.World(); } catch(InvalidOperationException) { } using (var scope = container.CreateChildContainer()) { // notice that it get disposed when the scope gets disposed. var obj1 = scope.Resolve<Hello>(); obj1.World(); // will get same instance var obj2 = scope.Resolve<Hello>(); obj2.World(); } using (var scope = container.CreateChildContainer()) { // Will get a new instance, since it's a new scope. var obj1 = scope.Resolve<Hello>(); obj1.World(); } Console.WriteLine("Press enter to quit"); Console.ReadLine(); }
static void Main(string[] args) { // Used to configure which classes // the container should create var registrar = new ContainerRegistrar(); // transient = new object every time registrar.RegisterConcrete<Hello>(Lifetime.Transient); // Build the actual container // nothing can be done with the registrar after this point. // (as changes whill have no effect unless you build a new container) var container = registrar.Build(); // Ask the container after your class. var instance = container.Resolve<Hello>(); // and invoke something on it instance.World(); Console.WriteLine("Press enter to quit"); Console.ReadLine(); }
public void TestDelegateFactory() { var registrar = new ContainerRegistrar(); registrar.RegisterService<MySelf>(ctnr => new MySelf(), Lifetime.Transient); registrar.RegisterConcrete<OneDepencency>(Lifetime.Singleton); var container = registrar.Build(); container.Resolve<OneDepencency>(); }
public void Init() { _registrar = new ContainerRegistrar(); _registrar.RegisterConcrete<UserMemoryRepository>(Lifetime.Singleton); _registrar.Build(); }
public void TestSingleton() { var registrar = new ContainerRegistrar(); registrar.RegisterInstance<MySelf>(new MySelf()); registrar.RegisterConcrete<OneDepencency>(Lifetime.Singleton); var container = registrar.Build(); container.Resolve<OneDepencency>(); }
public void TwoChildContainers() { var registrar = new ContainerRegistrar(); registrar.RegisterConcrete<MySelf>(); var builder = new ContainerBuilder(); var container = builder.Build(registrar); MySelf instance1, instance2; var childContainer1 = container.CreateChildContainer(); var childContainer2 = container.CreateChildContainer(); instance1 = childContainer1.Resolve<MySelf>(); instance2 = childContainer2.Resolve<MySelf>(); Assert.False(instance1.IsDisposed); Assert.False(instance2.IsDisposed); childContainer1.Dispose(); Assert.True(instance1.IsDisposed); Assert.False(instance2.IsDisposed); childContainer2.Dispose(); Assert.True(instance2.IsDisposed); }