public void PropertyReflectionWillNotOverwriteAPreExistingPolicyForAProperty()
		{
			MockBuilderContext context = CreateContext();
			PropertySetterPolicy policy = new PropertySetterPolicy();
			policy.Properties.Add("Foo", new PropertySetterInfo("Foo", new ValueParameter(typeof(object), 12)));
			context.Policies.Set<IPropertySetterPolicy>(policy, typeof(MockRequiresNewObject), null);

			MockRequiresNewObject obj = (MockRequiresNewObject)context.HeadOfChain.BuildUp(context, typeof(MockRequiresNewObject), null, null);

			Assert.AreEqual(12, obj.Foo);
		}
Пример #2
0
        public void PropertyReflectionWillNotOverwriteAPreExistingPolicyForAProperty()
        {
            MockBuilderContext   context = CreateContext();
            PropertySetterPolicy policy  = new PropertySetterPolicy();

            policy.Properties.Add("Foo", new PropertySetterInfo("Foo", new ValueParameter(typeof(object), 12)));
            context.Policies.Set <IPropertySetterPolicy>(policy, typeof(MockRequiresNewObject), null);

            MockRequiresNewObject obj = (MockRequiresNewObject)context.HeadOfChain.BuildUp(context, typeof(MockRequiresNewObject), null, null);

            Assert.AreEqual(12, obj.Foo);
        }
		public void ThrowsIfPropertyInjectedIsReadOnly()
		{
			MockBuilderContext ctx = new MockBuilderContext();
			PropertySetterStrategy strategy = new PropertySetterStrategy();

			PropertySetterPolicy policy1 = new PropertySetterPolicy();
			policy1.Properties.Add("Bar", new PropertySetterInfo("Bar", new ValueParameter<string>("value for foo")));
			ctx.Policies.Set<IPropertySetterPolicy>(policy1, typeof(MockInjectionTarget), null);

			MockInjectionTarget target = new MockInjectionTarget();
			strategy.BuildUp<object>(ctx, target, null);
		}
        public void IncompatibleTypesThrow()
        {
            MockBuilderContext ctx = new MockBuilderContext();
            PropertySetterStrategy strategy = new PropertySetterStrategy();

            PropertySetterPolicy policy = new PropertySetterPolicy();
            policy.Properties.Add("Foo", new PropertySetterInfo("Foo", new ValueParameter<object>(new object())));
            ctx.Policies.Set<IPropertySetterPolicy>(policy, typeof(MockInjectionTarget), null);

            MockInjectionTarget target = new MockInjectionTarget();
            strategy.BuildUp<MockInjectionTarget>(ctx, target, null);
        }
		public void InjectionIsBasedOnConcreteTypeNotRequestedType()
		{
			MockBuilderContext ctx = new MockBuilderContext();
			PropertySetterStrategy strategy = new PropertySetterStrategy();

			PropertySetterPolicy policy1 = new PropertySetterPolicy();
			policy1.Properties.Add("Foo", new PropertySetterInfo("Foo", new ValueParameter<string>("value for foo")));
			ctx.Policies.Set<IPropertySetterPolicy>(policy1, typeof (MockInjectionTarget), null);

			MockInjectionTarget target = new MockInjectionTarget();
			strategy.BuildUp<object>(ctx, target, null);

			Assert.AreEqual("value for foo", target.Foo);
		}
Пример #6
0
        public void ThrowsIfPropertyInjectedIsReadOnly()
        {
            MockBuilderContext     ctx      = new MockBuilderContext();
            PropertySetterStrategy strategy = new PropertySetterStrategy();

            PropertySetterPolicy policy1 = new PropertySetterPolicy();

            policy1.Properties.Add("Bar", new PropertySetterInfo("Bar", new ValueParameter <string>("value for foo")));
            ctx.Policies.Set <IPropertySetterPolicy>(policy1, typeof(MockInjectionTarget), null);

            MockInjectionTarget target = new MockInjectionTarget();

            strategy.BuildUp <object>(ctx, target, null);
        }
Пример #7
0
        public void CanCreateObjectWithPropertyInjectionWithDefaultObjectBuilder()
        {
            Builder builder = new Builder();
            Locator locator = CreateLocator();

            PropertySetterPolicy policy = new PropertySetterPolicy();

            policy.Properties.Add("IntProp", new PropertySetterInfo("IntProp", new ValueParameter <int>(64)));
            builder.Policies.Set <IPropertySetterPolicy>(policy, typeof(PropertyObject), null);

            PropertyObject obj = builder.BuildUp <PropertyObject>(locator, null, null);

            Assert.AreEqual(64, obj.IntProp);
        }
Пример #8
0
        public void IncompatibleTypesThrow()
        {
            MockBuilderContext     ctx      = new MockBuilderContext();
            PropertySetterStrategy strategy = new PropertySetterStrategy();

            PropertySetterPolicy policy = new PropertySetterPolicy();

            policy.Properties.Add("Foo", new PropertySetterInfo("Foo", new ValueParameter <object>(new object())));
            ctx.Policies.Set <IPropertySetterPolicy>(policy, typeof(MockInjectionTarget), null);

            MockInjectionTarget target = new MockInjectionTarget();

            strategy.BuildUp <MockInjectionTarget>(ctx, target, null);
        }
Пример #9
0
        public void BuilderCanTakeTransientPolicies()
        {
            Builder builder = new Builder();
            Locator locator = CreateLocator();
            PolicyList policies = new PolicyList();

            PropertySetterPolicy policy = new PropertySetterPolicy();
            policy.Properties.Add("IntProp", new PropertySetterInfo("IntProp", new ValueParameter<int>(96)));
            policies.Set<IPropertySetterPolicy>(policy, typeof(PropertyObject), null);

            PropertyObject obj = builder.BuildUp<PropertyObject>(locator, null, null, policies);

            Assert.AreEqual(96, obj.IntProp);
        }
Пример #10
0
        public void BuilderCanTakeTransientPolicies()
        {
            Builder    builder  = new Builder();
            Locator    locator  = CreateLocator();
            PolicyList policies = new PolicyList();

            PropertySetterPolicy policy = new PropertySetterPolicy();

            policy.Properties.Add("IntProp", new PropertySetterInfo("IntProp", new ValueParameter <int>(96)));
            policies.Set <IPropertySetterPolicy>(policy, typeof(PropertyObject), null);

            PropertyObject obj = builder.BuildUp <PropertyObject>(locator, null, null, policies);

            Assert.AreEqual(96, obj.IntProp);
        }
Пример #11
0
        public void CanInjectValuesIntoProperties()
        {
            Builder builder = new Builder();
            Locator locator = CreateLocator();

            PropertySetterPolicy policy = new PropertySetterPolicy();

            policy.Properties.Add("StringProperty", new PropertySetterInfo("StringProperty", new ValueParameter <string>("Bar is here")));
            builder.Policies.Set <IPropertySetterPolicy>(policy, typeof(SimpleObject), null);

            SimpleObject sm = builder.BuildUp <SimpleObject>(locator, null, null);

            Assert.IsNotNull(sm);
            Assert.AreEqual("Bar is here", sm.StringProperty);
        }
Пример #12
0
        public void InjectionIsBasedOnConcreteTypeNotRequestedType()
        {
            MockBuilderContext     ctx      = new MockBuilderContext();
            PropertySetterStrategy strategy = new PropertySetterStrategy();

            PropertySetterPolicy policy1 = new PropertySetterPolicy();

            policy1.Properties.Add("Foo", new PropertySetterInfo("Foo", new ValueParameter <string>("value for foo")));
            ctx.Policies.Set <IPropertySetterPolicy>(policy1, typeof(MockInjectionTarget), null);

            MockInjectionTarget target = new MockInjectionTarget();

            strategy.BuildUp <object>(ctx, target, null);

            Assert.AreEqual("value for foo", target.Foo);
        }
        public void SetsPropertyInPolicy()
        {
            Spy.PropertyValue = null;
            object             obj     = new object();
            MockBuilderContext context = new MockBuilderContext();

            context.Strategies.Add(new PropertySetterStrategy());
            PropertySetterPolicy policy = new PropertySetterPolicy();

            policy.Properties.Add(new ReflectionPropertySetterInfo(typeof(Spy).GetProperty("Property"), new ValueParameter <object>(obj)));
            context.Policies.Set <IPropertySetterPolicy>(policy, typeof(Spy));

            context.ExecuteBuildUp(typeof(Spy), new Spy());

            Assert.AreSame(obj, Spy.PropertyValue);
        }
Пример #14
0
        private void ProcessProperties(BuildRuleElement buildRule, Type buildType)
        {
            if (buildRule.Property == null)
            {
                return;
            }

            PropertySetterPolicy policy = new PropertySetterPolicy();

            foreach (PropertyElement prop in buildRule.Property)
            {
                policy.Properties.Add(prop.Name,
                                      new PropertySetterInfo(prop.Name, GetParameterFromConfigParam(prop.Item)));
            }

            builder.Policies.Set <IPropertySetterPolicy>(policy, buildType, null);
        }
Пример #15
0
        /// <summary>
        /// Used when the creator of a root <see cref="WorkItem"/> needs to ensure that the WorkItem
        /// has properly built itself (so its dependencies get injected properly).
        /// </summary>
        protected internal void BuildUp()
        {
            // We use Guid.NewGuid() to generate a dummy ID, so that the WorkItem buildup sequence can
            // run (the WorkItem is already located with the null ID, which marks it as a service, so
            // the SingletonStrategy would short circuit and not do the build-up).

            Type   type        = GetType();
            string temporaryID = Guid.NewGuid().ToString();
            PropertySetterPolicy propPolicy = new PropertySetterPolicy();

            propPolicy.Properties.Add("Parent", new PropertySetterInfo("Parent", new ValueParameter(typeof(WorkItem), null)));

            PolicyList policies = new PolicyList();

            policies.Set <ISingletonPolicy>(new SingletonPolicy(false), type, temporaryID);
            policies.Set <IPropertySetterPolicy>(propPolicy, type, temporaryID);

            builder.BuildUp(locator, type, temporaryID, this, policies);
        }
Пример #16
0
        public void TransientPoliciesOverrideBuilderPolicies()
        {
            Builder    builder  = new Builder();
            Locator    locator  = CreateLocator();
            PolicyList policies = new PolicyList();

            PropertySetterPolicy builderPolicy = new PropertySetterPolicy();

            builderPolicy.Properties.Add("IntProp", new PropertySetterInfo("IntProp", new ValueParameter <int>(11)));
            builder.Policies.Set <IPropertySetterPolicy>(builderPolicy, typeof(PropertyObject), null);

            PropertySetterPolicy transientPolicy = new PropertySetterPolicy();

            transientPolicy.Properties.Add("IntProp", new PropertySetterInfo("IntProp", new ValueParameter <int>(22)));
            policies.Set <IPropertySetterPolicy>(transientPolicy, typeof(PropertyObject), null);

            PropertyObject obj = builder.BuildUp <PropertyObject>(locator, null, null, policies);

            Assert.AreEqual(22, obj.IntProp);
        }
Пример #17
0
        /// <summary>
        /// See <see cref="ReflectionStrategy{T}.AddParametersToPolicy"/> for more information.
        /// </summary>
        protected override void AddParametersToPolicy(IBuilderContext context, Type typeToBuild, string idToBuild,
                                                      IReflectionMemberInfo <PropertyInfo> member,
                                                      IEnumerable <IParameter> parameters)
        {
            PropertySetterPolicy result =
                context.Policies.Get <IPropertySetterPolicy>(typeToBuild, idToBuild) as PropertySetterPolicy;

            if (result == null)
            {
                result = new PropertySetterPolicy();
                context.Policies.Set <IPropertySetterPolicy>(result, typeToBuild, idToBuild);
            }

            foreach (IParameter parameter in parameters)
            {
                if (!result.Properties.ContainsKey(member.Name))
                {
                    result.Properties.Add(member.Name, new PropertySetterInfo(member.MemberInfo, parameter));
                }
            }
        }
        public void AddingObjectTwiceOnlyInjectsDependenciesOnce()
        {
            TestableManagedObjectCollection <object> collection = CreateManagedObjectCollection();

            MockDataObject obj = new MockDataObject();

            PropertySetterPolicy policy1 = new PropertySetterPolicy();

            policy1.Properties.Add("IntProperty", new PropertySetterInfo("IntProperty", new ValueParameter <int>(19)));
            collection.Builder.Policies.Set <IPropertySetterPolicy>(policy1, typeof(MockDataObject), "Foo");

            PropertySetterPolicy policy2 = new PropertySetterPolicy();

            policy2.Properties.Add("IntProperty", new PropertySetterInfo("IntProperty", new ValueParameter <int>(36)));
            collection.Builder.Policies.Set <IPropertySetterPolicy>(policy2, typeof(MockDataObject), "Bar");

            collection.Add(obj, "Foo");
            Assert.AreEqual(19, obj.IntProperty);

            collection.Add(obj, "Bar");
            Assert.AreEqual(19, obj.IntProperty);
        }
Пример #19
0
        public void CanInjectMultiplePropertiesIncludingCreatedObjects()
        {
            Builder builder = new Builder();
            Locator locator = CreateLocator();

            ConstructorPolicy policy = new ConstructorPolicy();

            policy.AddParameter(new ValueParameter <int>(15));
            builder.Policies.Set <ICreationPolicy>(policy, typeof(SimpleObject), null);

            PropertySetterPolicy policy1 = new PropertySetterPolicy();

            policy1.Properties.Add("StringProperty", new PropertySetterInfo("StringProperty", new ValueParameter <string>("Bar is here")));
            policy1.Properties.Add("SimpleObject", new PropertySetterInfo("SimpleObject", new CreationParameter(typeof(SimpleObject))));
            builder.Policies.Set <IPropertySetterPolicy>(policy1, typeof(ComplexObject), null);

            ComplexObject co = builder.BuildUp <ComplexObject>(locator, null, null);

            Assert.IsNotNull(co);
            Assert.IsNotNull(co.SimpleObject);
            Assert.AreEqual("Bar is here", co.StringProperty);
            Assert.AreEqual(15, co.SimpleObject.IntParam);
        }
Пример #20
0
        public void CanCreateObjectWithPropertyInjectionWithDefaultObjectBuilder()
        {
            Builder builder = new Builder();
            Locator locator = CreateLocator();

            PropertySetterPolicy policy = new PropertySetterPolicy();
            policy.Properties.Add("IntProp", new PropertySetterInfo("IntProp", new ValueParameter<int>(64)));
            builder.Policies.Set<IPropertySetterPolicy>(policy, typeof(PropertyObject), null);

            PropertyObject obj = builder.BuildUp<PropertyObject>(locator, null, null);

            Assert.AreEqual(64, obj.IntProp);
        }
Пример #21
0
        public void TransientPoliciesOverrideBuilderPolicies()
        {
            Builder builder = new Builder();
            Locator locator = CreateLocator();
            PolicyList policies = new PolicyList();

            PropertySetterPolicy builderPolicy = new PropertySetterPolicy();
            builderPolicy.Properties.Add("IntProp", new PropertySetterInfo("IntProp", new ValueParameter<int>(11)));
            builder.Policies.Set<IPropertySetterPolicy>(builderPolicy, typeof(PropertyObject), null);

            PropertySetterPolicy transientPolicy = new PropertySetterPolicy();
            transientPolicy.Properties.Add("IntProp", new PropertySetterInfo("IntProp", new ValueParameter<int>(22)));
            policies.Set<IPropertySetterPolicy>(transientPolicy, typeof(PropertyObject), null);

            PropertyObject obj = builder.BuildUp<PropertyObject>(locator, null, null, policies);

            Assert.AreEqual(22, obj.IntProp);
        }
        public void LCGInjectionIsFaster()
        {
            Locator locator = new Locator();
            BuilderBase <BuilderStage> builder = new BuilderBase <BuilderStage>();

            builder.Strategies.AddNew <ConstructorReflectionStrategy>(BuilderStage.PreCreation);
            builder.Strategies.AddNew <CreationStrategy>(BuilderStage.Creation);
            builder.Strategies.AddNew <PropertySetterStrategy>(BuilderStage.Initialization);

            PropertySetterPolicy policy = new PropertySetterPolicy();

            policy.Properties.Add("B", new PropertySetterInfo("B", new CreationParameter(typeof(Bar))));
            builder.Policies.Set <IPropertySetterPolicy>(policy, typeof(Foo), null);

            long ticks = 0;

            for (int i = 0; i < iterations; i++)
            {
                Stopwatch watch = new Stopwatch();
                watch.Start();
                Foo a = builder.BuildUp <Foo>(locator, null, null);
                Assert.IsNotNull(a.B);
                watch.Stop();

                if (i % 100 == 0)
                {
                    GC.Collect();
                }

                ticks += watch.ElapsedTicks;
            }

            long avg = ticks / iterations;

            locator = new Locator();
            builder = new BuilderBase <BuilderStage>();
            builder.Strategies.AddNew <ConstructorReflectionStrategy>(BuilderStage.PreCreation);
            builder.Strategies.AddNew <CreationStrategy>(BuilderStage.Creation);
            builder.Strategies.AddNew <PropertySetterStrategy>(BuilderStage.Initialization);

            policy = new PropertySetterPolicy();
            policy.Properties.Add("B", new FastPropertySetterInfo("B", new CreationParameter(typeof(Bar))));
            builder.Policies.Set <IPropertySetterPolicy>(policy, typeof(Foo), null);

            ticks = 0;

            for (int i = 0; i < iterations; i++)
            {
                Stopwatch watch = new Stopwatch();
                watch.Start();
                Foo a = builder.BuildUp <Foo>(locator, null, null);
                Assert.IsNotNull(a.B);
                watch.Stop();

                if (i % 100 == 0)
                {
                    GC.Collect();
                }

                ticks += watch.ElapsedTicks;
            }

            long avg2 = ticks / iterations;

            Console.WriteLine("{0} vs {1}", avg, avg2);

            Assert.IsTrue(avg2 < avg);
        }