Example #1
0
        private void RegisterComplex()
        {
            IFirstService  firstService  = new FirstService();
            ISecondService secondService = new SecondService();
            IThirdService  thirdService  = new ThirdService();

            this.container[typeof(IFirstService)]  = () => firstService;
            this.container[typeof(ISecondService)] = () => secondService;
            this.container[typeof(IThirdService)]  = () => thirdService;
            this.container[typeof(IComplex1)]      = () => new Complex1(
                firstService,
                secondService,
                thirdService,
                new SubObjectOne(firstService),
                new SubObjectTwo(secondService),
                new SubObjectThree(thirdService));
            this.container[typeof(IComplex2)] = () => new Complex2(
                firstService,
                secondService,
                thirdService,
                new SubObjectOne(firstService),
                new SubObjectTwo(secondService),
                new SubObjectThree(thirdService));
            this.container[typeof(IComplex3)] = () => new Complex3(
                firstService,
                secondService,
                thirdService,
                new SubObjectOne(firstService),
                new SubObjectTwo(secondService),
                new SubObjectThree(thirdService));
        }
Example #2
0
        public void TwoLevelTransaction()
        {
            Post.DeleteAll();
            Blog.DeleteAll();

            FirstService service = container.Resolve <FirstService>();

            service.CreateBlogAndPost();

            Assert.AreEqual(1, Blog.FindAll().Length);
            Assert.AreEqual(1, Post.FindAll().Length);
        }
Example #3
0
        public void TwoLevelTransaction()
        {
            Post.DeleteAll();
            Blog.DeleteAll();

            FirstService service = (FirstService)container[typeof(FirstService)];

            service.CreateBlogAndPost();

            Assert.AreEqual(1, Blog.FindAll().Length);
            Assert.AreEqual(1, Post.FindAll().Length);
        }
        private static void RegisterComplex()
        {
            var firstService  = new FirstService();
            var secondService = new SecondService();
            var thirdService  = new ThirdService();

            Injector.SetResolver <IFirstService>(() => firstService);
            Injector.SetResolver <ISecondService>(() => secondService);
            Injector.SetResolver <IThirdService>(() => thirdService);
            Injector.SetResolver <ISubObjectOne, SubObjectOne>();
            Injector.SetResolver <ISubObjectTwo, SubObjectTwo>();
            Injector.SetResolver <ISubObjectThree, SubObjectThree>();

            Injector.SetResolver <IComplex, Complex>();
        }
Example #5
0
        public void TwoLevelTransaction()
        {
            Post.DeleteAll();
            Blog.DeleteAll();

            FirstService service = container.Resolve <FirstService>();

            using (new SessionScope())
            {
                Blog.FindAll();                 // side effects only

                service.CreateBlogAndPost();
            }

            Assert.AreEqual(1, Blog.FindAll().Length);
            Assert.AreEqual(1, Post.FindAll().Length);
        }
Example #6
0
        public void TwoLevelTransaction2()
        {
            Post.DeleteAll();
            Blog.DeleteAll();

            FirstService service = container.Resolve <FirstService>();

            try
            {
                service.CreateBlogAndPost2();
            }
            catch (Exception)
            {
            }

            Assert.AreEqual(0, Blog.FindAll().Length);
            Assert.AreEqual(0, Post.FindAll().Length);
        }
Example #7
0
        public void SingltonIsNotDisposedAfterSubContainerDisposal()
        {
            ContainerBuilder cb = new ContainerBuilder();

            cb.Register <FirstService>(LifecycleType.Singleton);

            IContainer root = cb.Build();

            IScope child = root.NewScope();

            FirstService fs = child.Resolve <FirstService>();

            child.Dispose();
            Assert.False(fs.IsDisposed);

            root.Dispose();
            Assert.True(fs.IsDisposed);
        }
        public void TwoLevelTransaction2()
        {
            Post.DeleteAll();
            Blog.DeleteAll();

            FirstService service = (FirstService)container[typeof(FirstService)];

            using (new SessionScope())
            {
                Blog.FindAll();                 // side effects only

                try
                {
                    service.CreateBlogAndPost2();
                }
                catch (Exception)
                {
                }
            }

            Assert.AreEqual(0, Blog.FindAll().Length);
            Assert.AreEqual(0, Post.FindAll().Length);
        }
Example #9
0
 public IFirstService ProvideFirstService(FirstService service)
 {
     return(service);
 }
 public IFirstService ProvideFirstService(FirstService service) => service;
 public MainWindow(FirstService firstService, Logger <App> logger)
 {
     logger.LogCritical("Test");
     InitializeComponent();
 }
Example #12
0
 public WebController(FirstService firstService)
 {
     this.firstService = firstService;
 }
Example #13
0
 // ReSharper disable UnusedParameter.Local
 public ThirdService(FirstService firstService, SecondService secondService)
 {
 }
Example #14
0
 public RestController(FirstService firstService)
 {
     this.firstService = firstService;
 }
Example #15
0
 // At the moment the order of the paramaters is relevant. Add the custom ones (provided by the Create method) before the ones from the resolver
 public Consumer3(string additional, FirstService service)
 {
     this.service    = service;
     this.additional = additional;
 }