public void RegisterExtension_RegisterMultipleInstances()
        {
            DefaultExtensionRegistry registry = new DefaultExtensionRegistry();

            ServiceA serviceA = new ServiceA();
            ServiceB serviceB = new ServiceB();
            ServiceC serviceC = new ServiceC();

            registry.RegisterExtension(typeof(IMyService), serviceA);
            registry.RegisterExtension(typeof(IMyService), serviceB);
            registry.RegisterExtension(typeof(IMyService), serviceC);

            OtherServiceA otherServiceA = new OtherServiceA();
            OtherServiceB otherServiceB = new OtherServiceB();

            registry.RegisterExtension(typeof(IMyOtherService), otherServiceA);
            registry.RegisterExtension(typeof(IMyOtherService), otherServiceB);

            object[] services = registry.GetExtensions(typeof(IMyService)).ToArray();
            Assert.Equal(3, services.Length);
            Assert.True(services.Contains(serviceA));
            Assert.True(services.Contains(serviceB));
            Assert.True(services.Contains(serviceC));

            services = registry.GetExtensions(typeof(IMyOtherService)).ToArray();
            Assert.Equal(2, services.Length);
            Assert.True(services.Contains(otherServiceA));
            Assert.True(services.Contains(otherServiceB));
        }
Example #2
0
 public DefaultController(ServiceA serviceA, ServiceB serviceB, ServiceC serviceC, ITestService testService)
 {
     this.serviceA    = serviceA;
     this.serviceB    = serviceB;
     this.serviceC    = serviceC;
     this.testService = testService;
 }
Example #3
0
 public int GetSum(ServiceB serviceB)
 {
     lock (_lockA)
     {
         return(_a + serviceB.GetValue());
     }
 }
 public LifeTimeController(ServiceA A, ServiceB B, ServiceC C, ServiceAll All)
 {
     serviceA   = A;
     serviceB   = B;
     serviceC   = C;
     serviceAll = All;
 }
        public void RegisterExtension_RegisterMultipleInstances()
        {
            DefaultExtensionRegistry registry = new DefaultExtensionRegistry();

            ServiceA serviceA = new ServiceA();
            ServiceB serviceB = new ServiceB();
            ServiceC serviceC = new ServiceC();
            registry.RegisterExtension(typeof(IMyService), serviceA);
            registry.RegisterExtension(typeof(IMyService), serviceB);
            registry.RegisterExtension(typeof(IMyService), serviceC);

            OtherServiceA otherServiceA = new OtherServiceA();
            OtherServiceB otherServiceB = new OtherServiceB();
            registry.RegisterExtension(typeof(IMyOtherService), otherServiceA);
            registry.RegisterExtension(typeof(IMyOtherService), otherServiceB);

            object[] services = registry.GetExtensions(typeof(IMyService)).ToArray();
            Assert.Equal(3, services.Length);
            Assert.True(services.Contains(serviceA));
            Assert.True(services.Contains(serviceB));
            Assert.True(services.Contains(serviceC));

            services = registry.GetExtensions(typeof(IMyOtherService)).ToArray();
            Assert.Equal(2, services.Length);
            Assert.True(services.Contains(otherServiceA));
            Assert.True(services.Contains(otherServiceB));
        }
Example #6
0
 public DemoController(ServiceA a, ServiceB b, ServiceC c, ServiceDependencyAll d)
 {
     _serviceA   = a;
     _serviceB   = b;
     _serviceC   = c;
     _serviceDep = d;
 }
Example #7
0
        public void Operation()
        {
            ServiceA serviceA = new ServiceA();
            ServiceB serviceB = new ServiceB();

            serviceA.Operation();
            serviceB.Operation();
        }
Example #8
0
 public Task <IEnumerable <Entity> > GetAllInfo(
     [FromServices] ServiceA serviceA,
     [FromServices] ServiceB serviceB,
     [FromQuery] String filter1,
     [FromQuery] String filter2,
     [FromQuery] String filter3)
 {
     return(null);
 }
        private void RegisterPropertyInjection()
        {
            IServiceA serviceA = new ServiceA();
            IServiceB serviceB = new ServiceB();
            IServiceC serviceC = new ServiceC();

            this.container[typeof(IComplexPropertyObject1)] = () =>
                                                              new ComplexPropertyObject1
            {
                ServiceA   = serviceA,
                ServiceB   = serviceB,
                ServiceC   = serviceC,
                SubObjectA = new SubObjectA {
                    ServiceA = serviceA
                },
                SubObjectB = new SubObjectB {
                    ServiceB = serviceB
                },
                SubObjectC = new SubObjectC {
                    ServiceC = serviceC
                }
            };

            this.container[typeof(IComplexPropertyObject2)] = () =>
                                                              new ComplexPropertyObject2
            {
                ServiceA   = serviceA,
                ServiceB   = serviceB,
                ServiceC   = serviceC,
                SubObjectA = new SubObjectA {
                    ServiceA = serviceA
                },
                SubObjectB = new SubObjectB {
                    ServiceB = serviceB
                },
                SubObjectC = new SubObjectC {
                    ServiceC = serviceC
                }
            };

            this.container[typeof(IComplexPropertyObject3)] = () =>
                                                              new ComplexPropertyObject3
            {
                ServiceA   = serviceA,
                ServiceB   = serviceB,
                ServiceC   = serviceC,
                SubObjectA = new SubObjectA {
                    ServiceA = serviceA
                },
                SubObjectB = new SubObjectB {
                    ServiceB = serviceB
                },
                SubObjectC = new SubObjectC {
                    ServiceC = serviceC
                }
            };
        }
        public void apply_polymorphism_to_services()
        {
            FrameworkServiceContainer c = new FrameworkServiceContainer();
            ServiceB b = new ServiceB();
            ServiceC d = new ServiceC();
            c.AddService(typeof(ServiceB), b);
            c.AddService(typeof(ServiceC), d);

            Assert.That(c.GetServices<ServiceB>().Count(), Is.EqualTo(2));
            Assert.That(c.GetServices<ServiceB>(), Contains.Item(d));
        }
Example #11
0
        public void DecorateInterfaceWithInternalImplementingClass()
        {
            var serviceB     = new ServiceB();
            var decorator    = new PerformanceLoggingDecoratorFactory(_logger);
            var perfServiceB = decorator.Decorate <IService>(serviceB);

            Assert.IsAssignableFrom <IService>(perfServiceB);

            // Call the public methods
            perfServiceB.VoidMethodNoArgument();
            perfServiceB.VoidMethodOneArgument(10);
        }
Example #12
0
 public void Execute()
 {
     Assert.True(Inited);
     Assert.True(ServiceA.IsInited);
     Assert.True(!ServiceA.IsExecuted);
     Assert.True(ServiceB.IsInited);
     Assert.True(!ServiceB.IsExecuted);
     Assert.True(ServiceC.IsInited);
     Assert.True(!ServiceC.IsExecuted);
     ServiceB.Execute();
     ServiceC.Execute();
     Executed = true;
 }
Example #13
0
        static void Main(string[] args)
        {
            ServiceA serviceA = new ServiceA();
            int      sAResult = serviceA.Method2();

            ServiceB serviceB = new ServiceB();
            string   sBResult = serviceB.Method2();

            ServiceC serviceC = new ServiceC();
            double   sCResult = serviceC.Method1();

            Console.WriteLine(sAResult + " - " + sCResult + " - " + sBResult);
        }
Example #14
0
        public void TestB()
        {
            Mock <IServiceA> serviceA = new Mock <IServiceA>();

            var value = "ABC";

            serviceA.Setup(s => s.ReturnValue(It.IsAny <string>())).Returns("ABCDEF");

            var serviceB = new ServiceB(serviceA.Object);

            serviceB.returnValue(false, value);

            serviceA.Verify(mock => mock.ReturnValue(It.IsAny <string>()), Times.Never());
        }
Example #15
0
        public void TestA()
        {
            Mock <IServiceA> serviceA = new Mock <IServiceA>();

            var value = "ABC";

            serviceA.Setup(s => s.ReturnValue(It.IsAny <string>())).Returns(value);

            var serviceB = new ServiceB(serviceA.Object);

            serviceB.returnValue(true, value);

            serviceA.Verify(mock => mock.ReturnValue(It.IsAny <string>()), Times.Once());
        }
Example #16
0
            protected override IServiceCollection ConfigureApi(IServiceCollection services)
            {
                var q1 = new ServiceB("q1Pre", "q1Post");
                var q2 = new ServiceB("q2Pre", "q2Post");

                services.AddService <IServiceB>((sp, next) => q1)
                .AddService <IServiceB>((sp, next) =>
                {
                    q2.InnerHandler = next;
                    return(q2);
                });

                return(services);
            }
            public static new IServiceCollection ConfigureApi(Type apiType, IServiceCollection services)
            {
                ApiBase.ConfigureApi(apiType, services);
                var q1 = new ServiceB("q1Pre", "q1Post");
                var q2 = new ServiceB("q2Pre", "q2Post");

                services.AddService <IServiceB>((sp, next) => q1)
                .AddService <IServiceB>((sp, next) =>
                {
                    q2.InnerHandler = next;
                    return(q2);
                });

                return(services);
            }
Example #18
0
    static void Main(string[] args)
    {
        Console.WriteLine("Create 1MM ServiceA...");
        var sw = new Stopwatch();

        sw.Start();
        for (int i = 0; i < 1000000; i++)
        {
            var o   = new ServiceA();
            var obj = o.GetObject();
        }
        sw.Stop();
        Console.WriteLine("{0} ms", sw.ElapsedMilliseconds);
        Console.WriteLine();
        Console.WriteLine("Create 1MM ServiceB...");
        sw = new Stopwatch();
        sw.Start();
        for (int i = 0; i < 1000000; i++)
        {
            var o   = new ServiceB();
            var obj = o.GetObject();
        }
        sw.Stop();
        Console.WriteLine("{0} ms", sw.ElapsedMilliseconds);
        Console.WriteLine();
        Console.WriteLine("Create 1MM GenericServiceA...");
        sw = new Stopwatch();
        sw.Start();
        for (int i = 0; i < 1000000; i++)
        {
            var o   = new GenericServiceBase();
            var obj = o.GetObject <ServiceA>();
        }
        sw.Stop();
        Console.WriteLine("{0} ms", sw.ElapsedMilliseconds);
        Console.WriteLine();
        Console.WriteLine("Create 1MM GenericServiceB...");
        sw = new Stopwatch();
        sw.Start();
        for (int i = 0; i < 1000000; i++)
        {
            var o   = new GenericServiceBase();
            var obj = o.GetObject <ServiceB>();
        }
        sw.Stop();
        Console.WriteLine("{0} ms", sw.ElapsedMilliseconds);
        Console.WriteLine();
    }
Example #19
0
        protected void Button2_Click(object sender, EventArgs e)
        {
            ServiceB newservice = new ServiceB();

            newservice.ServiceName = serviceTextBox.Text;
            newservice.ServiceType = DropDownListService.Text;
            myctx.ServiceBs.InsertOnSubmit(newservice);
            myctx.SubmitChanges();


            var service = from a in myctx.ServiceBs
                          orderby a.SerciveID descending
                          select a;

            Response.Redirect("~\\General Manager\\ServicesPage.aspx");
        }
Example #20
0
        static void Main(string[] args)
        {
            ///IOC容器 的作用帮程序能够初始化对象,那我们要做的就是把需要初始化的对象放到容器中,其他的就需要我们去管了,用的时候取就行。
            ///众所周知IOC容器里面非常强调一个生命周期的东西,这个例子会用来剖析IOC容器的生命周期是怎么一回事。


            ///首先来看看我们平常所做的实例化一个对象是怎么做的
            ///现在有Service ABC,ServiceB用一个有参数ServiceA的构造函数,而ServiceC有一个含参数的ServiceB的构造函数
            ///所以来实现一下吧

            {
                ServiceA serviceA = new ServiceA();
                ServiceB serviceB = new ServiceB(serviceA);
                ServiceC serviceC = new ServiceC(serviceB);
                ///由上面的代码来实例化类的话其实是非常类的一件事,我这里只有三个类,如果是几十个,上百个的话你想想是多么累的一件事。
            }

            IUnityContainer container = new UnityContainer();

            //实例
            container.RegisterSingleton <IServiceA, ServiceA>(); //单例
            container.RegisterType <IServiceB, ServiceB>();      //瞬时

            {
                var a1 = container.Resolve <IServiceA>();
                var a2 = container.Resolve <IServiceA>();
                Console.WriteLine(object.ReferenceEquals(a1, a2));//运行之后获得结果是true,那说明这个对象是同一个,这就说明了单例的效果,容器初始化,程序全局只有一个单例。
            }
            {
                var b1 = container.Resolve <IServiceB>();
                var b2 = container.Resolve <IServiceB>();
                Console.WriteLine(object.ReferenceEquals(b1, b2));//运行之后得到false,说明两个对象是不相等的,那么其实和我们平时new一个对象是一样的。
            }
            {
                //创建子容器
                var child  = container.CreateChildContainer();
                var child2 = container.CreateChildContainer();
                var b1     = child.Resolve <IServiceB>();
                var b2     = child2.Resolve <IServiceB>();
                Console.WriteLine(object.ReferenceEquals(b1, b2));
                //这个地方说明一件事,那就是就算父容器注册了IServiceB,但是子容器都能解析的类型都是属于自己的实例,容器将返回父容器创建的实例。
            }
            //所以再有了容器之后我们就不需要自己初始化容器,容器帮我把把活做了,再回到之前的例子,我现在需要实例化一个ServiceC那怎么去做呢,
            //首先肯定把IServiceC放入容器在需要是要的地方,使用构造函数注入就行使用了,而且在控制台打印的东西也是能够发现端倪的,我们并没有实例化ServiceC那为什么控制台会提示“ServiceC被构造了”呢,那就是因为容器帮忙做了。
            //为什么会这么强调生命周期呢,因为我们如果利用好生命周期的话是能够提升性能的,比如我们有一个不经常用的Service(不一定是Service结合自己的业务需求)我不想每次都去实例化,想全局只要一个,那么这个时候使用RegisterSingleton注册,不就很好的满足了我们的需求了,譬如一些数据库连接就是使用的单例模式,那么我们就可以将它放到容器中,让容器帮我们管理。
            Console.ReadKey();
        }
Example #21
0
        public void Resolve_lazy_service_in_parent_container_should_work()
        {
            var container1 = new Container();

            container1.Register <ServiceA>(Reuse.Scoped);

            var container2 = container1.With(container1.Rules.WithFactorySelector(Rules.SelectLastRegisteredFactory()), null, RegistrySharing.CloneAndDropCache, null);

            var container2Scope = container2.OpenScope();

            var serviceB = new ServiceB();

            container2Scope.InjectPropertiesAndFields(serviceB);

            Assert.That(serviceB.ServiceA, Is.InstanceOf <Lazy <ServiceA> >());
            Assert.That(serviceB.ServiceA.Value, Is.Not.Null);
        }
        public void IExtensionRegistryExtensions_RegisterAndRetrieve()
        {
            DefaultExtensionRegistry registry = new DefaultExtensionRegistry();

            // use the generic extension methods to register
            ServiceA serviceA = new ServiceA();
            ServiceB serviceB = new ServiceB();
            ServiceC serviceC = new ServiceC();

            registry.RegisterExtension <IMyService>(serviceA);
            registry.RegisterExtension <IMyService>(serviceB);
            registry.RegisterExtension <IMyService>(serviceC);

            IMyService[] services = registry.GetExtensions <IMyService>().ToArray();
            Assert.Equal(3, services.Length);
            Assert.True(services.Contains(serviceA));
            Assert.True(services.Contains(serviceB));
            Assert.True(services.Contains(serviceC));
        }
Example #23
0
        public void Resolve_scoped_lazy_service_in_parent_container_with_WithoutThrowIfDependencyHasShorterReuseLifespan_via_InjectPropertiesAndFields_should_not_return_null()
        {
            var container1 = new Container(rules => rules.WithoutThrowIfDependencyHasShorterReuseLifespan());

            container1.Register <ServiceA>(Reuse.Scoped);

            var container2 = container1.With(
                container1.Rules.WithFactorySelector(Rules.SelectLastRegisteredFactory()),
                null,
                RegistrySharing.CloneAndDropCache,
                null);

            var container2Scope = container2.OpenScope();

            var serviceB = new ServiceB();

            container2Scope.InjectPropertiesAndFields(serviceB);

            Assert.That(serviceB.ServiceA, Is.InstanceOf <Lazy <ServiceA> >());
            Assert.That(serviceB.ServiceA.Value, Is.Not.Null);
        }
Example #24
0
            public static new IServiceCollection ConfigureApi(Type apiType, IServiceCollection services)
            {
                var changeSetPreparer      = new TestChangeSetInitializer();
                var submitExecutor         = new TestSubmitExecutor();
                var queryExpressionSourcer = new TestQueryExpressionSourcer();

                ApiBase.ConfigureApi(apiType, services);
                services.AddService <IChangeSetInitializer>((sp, next) => changeSetPreparer);
                services.AddService <ISubmitExecutor>((sp, next) => submitExecutor);
                services.AddService <IQueryExpressionSourcer>((sp, next) => queryExpressionSourcer);
                var q1 = new ServiceB("q1Pre", "q1Post");
                var q2 = new ServiceB("q2Pre", "q2Post");

                services.AddService <IServiceB>((sp, next) => q1)
                .AddService <IServiceB>((sp, next) =>
                {
                    q2.InnerHandler = next;
                    return(q2);
                });

                return(services);
            }
Example #25
0
    static int Main(string[] args)
    {
        ServiceProvider provider = new ServiceCollection().BuildServiceProvider();

        ObjectFactory factory  = ActivatorUtilities.CreateFactory(typeof(ServiceA), Array.Empty <Type>());
        ServiceA      serviceA = factory(provider, null) as ServiceA;
        ServiceB      serviceB = ActivatorUtilities.CreateInstance(provider, typeof(ServiceB)) as ServiceB;
        ServiceC      serviceC = ActivatorUtilities.CreateInstance <ServiceC>(provider);
        ServiceD      serviceD = ActivatorUtilities.GetServiceOrCreateInstance(provider, typeof(ServiceD)) as ServiceD;
        ServiceE      serviceE = ActivatorUtilities.GetServiceOrCreateInstance <ServiceE>(provider);

        if (serviceA is null ||
            serviceB is null ||
            serviceC is null ||
            serviceD is null ||
            serviceE is null)
        {
            return(-1);
        }

        return(100);
    }
Example #26
0
    static int Main(string[] args)
    {
        ServiceProvider provider = new ServiceCollection().BuildServiceProvider();

        // ActivatorUtilities.CreateFactory fails due to https://github.com/mono/linker/issues/1398
        //ObjectFactory factory = ActivatorUtilities.CreateFactory(typeof(ServiceA), Array.Empty<Type>());
        //ServiceA serviceA = factory(provider, null) as ServiceA;
        ServiceB serviceB = ActivatorUtilities.CreateInstance(provider, typeof(ServiceB)) as ServiceB;
        ServiceC serviceC = ActivatorUtilities.CreateInstance <ServiceC>(provider);
        ServiceD serviceD = ActivatorUtilities.GetServiceOrCreateInstance(provider, typeof(ServiceD)) as ServiceD;
        ServiceE serviceE = ActivatorUtilities.GetServiceOrCreateInstance <ServiceE>(provider);

        if (//serviceA is null ||
            serviceB is null ||
            serviceC is null ||
            serviceD is null ||
            serviceE is null)
        {
            return(-1);
        }

        return(100);
    }
        public void IExtensionRegistryExtensions_RegisterAndRetrieve()
        {
            DefaultExtensionRegistry registry = new DefaultExtensionRegistry();

            // use the generic extension methods to register
            ServiceA serviceA = new ServiceA();
            ServiceB serviceB = new ServiceB();
            ServiceC serviceC = new ServiceC();
            registry.RegisterExtension<IMyService>(serviceA);
            registry.RegisterExtension<IMyService>(serviceB);
            registry.RegisterExtension<IMyService>(serviceC);

            IMyService[] services = registry.GetExtensions<IMyService>().ToArray();
            Assert.Equal(3, services.Length);
            Assert.True(services.Contains(serviceA));
            Assert.True(services.Contains(serviceB));
            Assert.True(services.Contains(serviceC));
        }
Example #28
0
 public ServiceDependencyAll(ServiceA sva, ServiceB svb, ServiceC svc)
 {
     Service_A = sva;
     Service_B = svb;
     Service_C = svc;
 }
Example #29
0
 public Facade()
 {
     _serviceA = new ServiceA();
     _serviceB = new ServiceB();
     _serviceC = new ServiceC();
 }
Example #30
0
 public IServiceB ProvideServiceB(ServiceB service)
 {
     return(service);
 }
 public IServiceB ProvideServiceB(ServiceB service) => service;
            public static new IServiceCollection ConfigureApi(Type apiType, IServiceCollection services)
            {
                var q1 = new ServiceB("q1Pre", "q1Post");
                var q2 = new ServiceB("q2Pre", "q2Post");
                services.AddService<IServiceB>((sp, next) => q1)
                    .AddService<IServiceB>((sp, next) =>
                    {
                        q2.InnerHandler = next;
                        return q2;
                    });

                services.AddScoped(apiType, apiType)
                    .AddScoped(typeof(ApiBase), apiType)
                    .AddScoped<ApiContext>();

                services.TryAddSingleton<ApiConfiguration>();

                return services;
            }
Example #33
0
 public DisposableServiceC(ServiceB serviceB)
     : base(serviceB)
 {
 }
Example #34
0
 public ServiceC(ServiceB serviceB)
 {
     ServiceB = serviceB;
 }
 public ServiceC(ServiceB serviceB)
 {
     ServiceB = serviceB;
 }