public void TryResolve_WithAttrInjection_AttrMarkedProperiesGetInjected()
        {
            MvxSingleton.ClearAllSingletons();
            var options = new MvxIocOptions
            {
                PropertyInjectorOptions = new MvxPropertyInjectorOptions()
                {
                    InjectIntoProperties = MvxPropertyInjection.MvxInjectInterfaceProperties
                }
            };
            var instance = MvxSimpleIoCContainer.Initialize(options);

            Mvx.RegisterType <IA, A>();
            Mvx.RegisterType <IB, B>();
            Mvx.RegisterType <IC, C>();

            IA  a;
            var result = Mvx.TryResolve(out a);

            Assert.IsTrue(result);
            Assert.IsNotNull(a);
            Assert.IsInstanceOf <A>(a);
            var castA = (A)a;

            Assert.IsNotNull(castA.B);
            Assert.IsInstanceOf <B>(castA.B);
            Assert.IsNull(castA.C);
            Assert.IsNull(castA.BNever);
            Assert.IsNull(castA.CNever);
        }
        public void TryResolve_WithFullInjection_AllInterfaceProperiesGetInjected()
        {
            MvxSingleton.ClearAllSingletons();
            var options = new MvxIocOptions
            {
                PropertyInjectorOptions = new MvxPropertyInjectorOptions()
                {
                    InjectIntoProperties = MvxPropertyInjection.AllInterfaceProperties
                }
            };
            var instance = MvxIoCProvider.Initialize(options);

            Mvx.IoCProvider.RegisterType <IA, A>();
            Mvx.IoCProvider.RegisterType <IB, B>();
            Mvx.IoCProvider.RegisterType <IC, C>();

            IA  a;
            var result = Mvx.IoCProvider.TryResolve(out a);

            Assert.True(result);
            Assert.NotNull(a);
            Assert.IsType <A>(a);
            var castA = (A)a;

            Assert.NotNull(castA.B);
            Assert.IsType <B>(castA.B);
            Assert.NotNull(castA.C);
            Assert.IsType <C>(castA.C);
            Assert.Null(castA.BNever);
            Assert.Null(castA.CNever);
        }
Пример #3
0
        protected override IMvxIocOptions CreateIocOptions()
        {
            var options = new MvxIocOptions
            {
                PropertyInjectorOptions = MvxPropertyInjectorOptions.MvxInject
            };

            return(options);
        }
Пример #4
0
        public void TryResolve_CircularButSafeDynamicWithOptionOff_ReturnsTrue()
        {
            COdd.FirstTime = true;
            MvxSingleton.ClearAllSingletons();
            var options = new MvxIocOptions()
            {
                TryToDetectDynamicCircularReferences = false
            };
            var instance = MvxSimpleIoCContainer.Initialize(options);

            Mvx.RegisterType <IA, A>();
            Mvx.RegisterType <IB, B>();
            Mvx.RegisterType <IC, COdd>();

            IA  a;
            var result = Mvx.TryResolve(out a);

            Assert.IsTrue(result);
            Assert.IsNotNull(a);
        }
Пример #5
0
        protected virtual void ClearAll()
        {
            // fake set up of the IoC
            MvxSingleton.ClearAllSingletons();
            var withInject = new MvxPropertyInjectorOptions()
            {
                InjectIntoProperties          = MvxPropertyInjection.MvxInjectInterfaceProperties,
                ThrowIfPropertyInjectionFails = true
            };
            var options = new MvxIocOptions {
                PropertyInjectorOptions = withInject
            };

            _ioc = MvxSimpleIoCContainer.Initialize(options);
            _ioc.RegisterSingleton(_ioc);
            InitializeTrace();
            InitializeSingletonCache();
            InitializeMvxSettings();
            MvxTrace.Initialize();
            AdditionalSetup();
        }