public void supply_defaults_by_generic_in_a_bunch()
        {
            var container = new Container(x =>
            {
                x.For<IWidget>().Use<BWidget>();
                x.For<IService>().Use<AService>();
            });

            // SAMPLE: explicit-defaults-with-nested-closure
            var widget = new BWidget();
            var service = new BService();

            var guyWithWidgetAndService = container
                .With(x =>
                {
                    x.With<IWidget>(widget);
                    x.With<IService>(service);
                })
                .GetInstance<GuyWithWidgetAndService>();

            guyWithWidgetAndService
                .Widget.ShouldBeTheSameAs(widget);

            guyWithWidgetAndService
                .Service.ShouldBeTheSameAs(service);
            // ENDSAMPLE
        }
        public void supply_defaults_with_args()
        {
            var container = new Container(x =>
            {
                x.For<IWidget>().Use<BWidget>();
                x.For<IService>().Use<AService>();
            });

            // SAMPLE: explicit-use-explicit-args
            var widget = new BWidget();
            var service = new BService();

            var args = new ExplicitArguments();
            args.Set<IWidget>(widget);
            args.Set<IService>(service);

            var guyWithWidgetAndService = container
                .GetInstance<GuyWithWidgetAndService>(args);

            guyWithWidgetAndService
                .Widget.ShouldBeTheSameAs(widget);

            guyWithWidgetAndService
                .Service.ShouldBeTheSameAs(service);
            // ENDSAMPLE
        }
        public void supply_defaults_by_generic()
        {
            // SAMPLE: explicit-arg-container
            var container = new Container(x =>
            {
                x.For<IWidget>().Use<BWidget>();
                x.For<IService>().Use<AService>();
            });
            // ENDSAMPLE

            // SAMPLE: explicit-fluent-interface
            var widget = new BWidget();
            var service = new BService();

            var guyWithWidgetAndService = container
                .With<IWidget>(widget)
                .With<IService>(service)
                .GetInstance<GuyWithWidgetAndService>();

            guyWithWidgetAndService
                .Widget.ShouldBeTheSameAs(widget);

            guyWithWidgetAndService
                .Service.ShouldBeTheSameAs(service);
            // ENDSAMPLE
        }
        public void supply_defaults_by_generic_in_a_bunch()
        {
            var container = new Container(x =>
            {
                x.For <IWidget>().Use <BWidget>();
                x.For <IService>().Use <AService>();
            });

            // SAMPLE: explicit-defaults-with-nested-closure
            var widget  = new BWidget();
            var service = new BService();

            var guyWithWidgetAndService = container
                                          .With(x =>
            {
                x.With <IWidget>(widget);
                x.With <IService>(service);
            })
                                          .GetInstance <GuyWithWidgetAndService>();

            guyWithWidgetAndService
            .Widget.ShouldBeTheSameAs(widget);

            guyWithWidgetAndService
            .Service.ShouldBeTheSameAs(service);
            // ENDSAMPLE
        }
        public void supply_defaults_with_args()
        {
            var container = new Container(x =>
            {
                x.For <IWidget>().Use <BWidget>();
                x.For <IService>().Use <AService>();
            });

            // SAMPLE: explicit-use-explicit-args
            var widget  = new BWidget();
            var service = new BService();

            var args = new ExplicitArguments();

            args.Set <IWidget>(widget);
            args.Set <IService>(service);

            var guyWithWidgetAndService = container
                                          .GetInstance <GuyWithWidgetAndService>(args);

            guyWithWidgetAndService
            .Widget.ShouldBeTheSameAs(widget);

            guyWithWidgetAndService
            .Service.ShouldBeTheSameAs(service);
            // ENDSAMPLE
        }
        public void supply_defaults_by_generic()
        {
            // SAMPLE: explicit-arg-container
            var container = new Container(x =>
            {
                x.For <IWidget>().Use <BWidget>();
                x.For <IService>().Use <AService>();
            });
            // ENDSAMPLE

            // SAMPLE: explicit-fluent-interface
            var widget  = new BWidget();
            var service = new BService();

            var guyWithWidgetAndService = container
                                          .With <IWidget>(widget)
                                          .With <IService>(service)
                                          .GetInstance <GuyWithWidgetAndService>();

            guyWithWidgetAndService
            .Widget.ShouldBeTheSameAs(widget);

            guyWithWidgetAndService
            .Service.ShouldBeTheSameAs(service);
            // ENDSAMPLE
        }
    public void BWidgetTest()
    {
        BWidget myOtherWidget = new BWidget()
        {
            Parent = new AWidget()
        };

        myOtherWidget.Pay();
        myOtherWidget.Parent.Slap();
    }
    public void BWidgetTestThroughIWidget()
    {
        IWidget myOtherWidget = new BWidget()
        {
            Parent = new AWidget()
        };

        myOtherWidget.Behave();
        myOtherWidget.Parent.Behave();
    }
Beispiel #9
0
        public void supply_defaults_by_generic()
        {
            var container = new Container(x => {
                x.For <IWidget>().Use <BWidget>();
                x.For <IService>().Use <AService>();
            });

            var widget  = new BWidget();
            var service = new BService();

            var guyWithWidgetAndService = container
                                          .With <IWidget>(widget)
                                          .With <IService>(service)
                                          .GetInstance <GuyWithWidgetAndService>();

            guyWithWidgetAndService
            .Widget.ShouldBeTheSameAs(widget);

            guyWithWidgetAndService
            .Service.ShouldBeTheSameAs(service);
        }
        public void supply_defaults_by_generic()
        {
            var container = new Container(x => {
                x.For<IWidget>().Use<BWidget>();
                x.For<IService>().Use<AService>();
            });

            var widget = new BWidget();
            var service = new BService();

            var guyWithWidgetAndService = container
                .With<IWidget>(widget)
                .With<IService>(service)
                .GetInstance<GuyWithWidgetAndService>();

            guyWithWidgetAndService
                .Widget.ShouldBeTheSameAs(widget);

            guyWithWidgetAndService
                .Service.ShouldBeTheSameAs(service);
        }
Beispiel #11
0
        public void inject_scoping_with_nested_container(bool replace)
        {
            var container = new Container(_ =>
            {
                _.Injectable <IWidget>();
            });

            var rootWidget = new AWidget();

            container.Inject(typeof(IWidget), rootWidget, replace);

            var nestedWidget = new BWidget();

            var nested = container.GetNestedContainer();

            nested.Inject <IWidget>(nestedWidget);

            container.GetInstance <IWidget>()
            .ShouldBeSameAs(rootWidget);

            nested.GetInstance <IWidget>()
            .ShouldBeSameAs(nestedWidget);
        }