public void RegisterComplexType_Singleton()
        {
            var injector = new Injection();

            injector.Register<ITimer, MyTimer>(LifestyleType.Transient);
            //Here we fully register the complex type to utilize the container LSM for singleton
            injector.Register<IComplex, Complex>(LifestyleType.Singleton);

            var actual1 = injector.Resolve(typeof(IComplex));
            var actual2 = injector.Resolve(typeof(IComplex));

            Assert.IsInstanceOf<IComplex>(actual1);
            Assert.IsInstanceOf<IComplex>(actual2);
            Assert.AreSame(actual1, actual2);
        }
Exemple #2
0
        public void RegisterComplexType_Singleton()
        {
            var injector = new Injection();

            injector.Register <ITimer, MyTimer>(LifestyleType.Transient);
            //Here we fully register the complex type to utilize the container LSM for singleton
            injector.Register <IComplex, Complex>(LifestyleType.Singleton);

            var actual1 = injector.Resolve(typeof(IComplex));
            var actual2 = injector.Resolve(typeof(IComplex));

            Assert.IsInstanceOf <IComplex>(actual1);
            Assert.IsInstanceOf <IComplex>(actual2);
            Assert.AreSame(actual1, actual2);
        }
Exemple #3
0
 async void RegisterTypes(Injection injection)
 {
     injection.Register <Resampler>(i => new Resampler());
     injection.RegisterSingleton <IAudioSource>(i => new AAudioSource(i.Get <Resampler>()));
     injection.RegisterSingleton <IAudioPlayer>(i => new AAudioPlayer(i.Get <Resampler>()));
     await Task.CompletedTask;
 }
        public void RegisterType_Transient()
        {
            var injector = new Injection();

            injector.Register<ITimer, MyTimer>(LifestyleType.Transient);

            var actual1 = injector.Resolve(typeof(ITimer));
            var actual2 = injector.Resolve(typeof(ITimer));

            Assert.IsInstanceOf<ITimer>(actual1);
            Assert.IsInstanceOf<ITimer>(actual2);
            Assert.AreNotSame(actual1, actual2);
        }
Exemple #5
0
        public void RegisterType_Transient()
        {
            var injector = new Injection();

            injector.Register <ITimer, MyTimer>(LifestyleType.Transient);

            var actual1 = injector.Resolve(typeof(ITimer));
            var actual2 = injector.Resolve(typeof(ITimer));

            Assert.IsInstanceOf <ITimer>(actual1);
            Assert.IsInstanceOf <ITimer>(actual2);
            Assert.AreNotSame(actual1, actual2);
        }
        public void RegisterComplexType_TransientWithSingletonDependency()
        {
            var injector = new Injection();

            injector.Register<ITimer, MyTimer>(LifestyleType.Singleton);
            //The Injector container will handel unregistered resolves but the
            //following line could be uncommented to officially register the "Complex" type.
            //injector.Register<IComplex, Complex>(LifestyleType.Transient);

            var actual1 = (Complex)injector.Resolve(typeof(Complex));
            var actual2 = (Complex)injector.Resolve(typeof(Complex));

            Assert.AreNotSame(actual1, actual2);
            Assert.AreSame(actual1.Timer, actual2.Timer);
        }
Exemple #7
0
        public void RegisterComplexType_TransientWithSingletonDependency()
        {
            var injector = new Injection();

            injector.Register <ITimer, MyTimer>(LifestyleType.Singleton);
            //The Injector container will handel unregistered resolves but the
            //following line could be uncommented to officially register the "Complex" type.
            //injector.Register<IComplex, Complex>(LifestyleType.Transient);

            var actual1 = (Complex)injector.Resolve(typeof(Complex));
            var actual2 = (Complex)injector.Resolve(typeof(Complex));

            Assert.AreNotSame(actual1, actual2);
            Assert.AreSame(actual1.Timer, actual2.Timer);
        }
Exemple #8
0
 public void Basic()
 {
     var container = new Injection(null, null);
     var connstr = "my database connection string";
     container.Register("connname", connstr);
     container.Register("MaxConnecionCount", "5");
     container.Register("AcceptMethod", "GET");
     container.Register<DbContext>();
     container.Register<UserProvider>();
     container.Register<UserBusiness>();
     container.Register<UserController>();
     var item = container.Find(typeof(UserController));
     Assert.NotNull(item);
     var controller = item.GetOrCreateInstance() as UserController;
     
     Assert.NotNull(controller);
     Assert.NotNull(controller.Business);
     Assert.NotNull(controller.Business.DbProvider);
     Assert.NotNull(controller.Business.DbProvider.DbContext);
     Assert.Equal(connstr,controller.Business.DbProvider.DbContext.ConnName);
     Assert.Equal(5,controller.Business.DbProvider.DbContext.MaxConnecionCount);
     Assert.Equal(HttpMethods.GET,controller.AcceptMethod);
     Assert.Null(controller.Business.BusinessId);
 }