public void Test_Constructor_Throws_When_Given_Null_Construction_Expression() { Assert.Throws <ArgumentNullException>(() => { LazyConstructorBinding <object> binding = new LazyConstructorBinding <object>(new IBinding[0], null); }); }
public void Test_Constructor_Throws_When_Given_Null_Dependencies() { Assert.Throws <ArgumentNullException>(() => { LazyConstructorBinding <object> binding = new LazyConstructorBinding <object>(null, bindings => new object()); }); }
public void Test_Resolve_Implementation_Builds_Expression() { var lazyBinding = new LazyConstructorBinding <ISample>(new IBinding[0], bindings => new Sample()); Assert.False(lazyBinding.IsBuilt); ISample sample = lazyBinding.Resolve(); Assert.IsType <Sample>(sample); Assert.True(lazyBinding.IsBuilt); }
public void Test_Resolve_Implementation_Handles_Non_Lazy_Bindings_Correctly() { IBinding <ISample> binding = new ConstructorBinding <ISample>(() => new Sample()); LazyConstructorBinding <IHasSample> lazyBinding = new LazyConstructorBinding <IHasSample>( new IBinding[0], bindings => new HasSample(binding.Resolve())); IHasSample sample = lazyBinding.Resolve(); Assert.IsType <HasSample>(sample); Assert.IsType <ConstructorBinding <IHasSample> >(lazyBinding.Constructor); }
public void Test_Resolve_Implementation_Flattens_Multiple_Lazy_Bindings() { LazyConstructorBinding <IHasSample> lazyBinding = new LazyConstructorBinding <IHasSample>(new IBinding[] { new LazyConstructorBinding <ISample>(new IBinding[0], bindings => new Sample()) }, bindings => new HasSample(((LazyConstructorBinding <ISample>)bindings[0]).Resolve())); IHasSample sample = lazyBinding.Resolve(); Assert.IsType <HasSample>(sample); Assert.IsType <ConstructorBinding <IHasSample> >(lazyBinding.Constructor); }
public void Test_Resolve_Implementation_Handles_Binding_Inside_Initializer() { IBinding <ISample> binding = new LazyConstructorBinding <ISample>(new IBinding[] { new LazyConstructorBinding <object>(new IBinding[0], bindings => new Sample()) }, bindings => new Sample { Obj = ((ILazyConstructorBinding <object>)bindings[0]).Resolve() }); ISample sample = binding.Resolve(); Assert.IsType <Sample>(sample); Assert.IsType <Sample>(((Sample)sample).Obj); }
/// <summary> /// Finishes the binding between the given <see cref="IBinding{TInterface}"/> and the type resolved by the given expression. /// </summary> /// <param name="binding">The binding that should be finished.</param> /// <param name="expression"> /// The expression that specifies how the value is retrieved. /// This is generally a <see cref="NewExpression"/>, however anything that can be translated into a <see cref="Func{TImplementer}"/> can be used. /// </param> /// <example> /// Declare a binding to a constructor-like function: /// /// <code> /// IBinding<TInterface> finalBinding = b.Select(type => new TImplementer()); /// IBinding<TInterface> finalBinding = from type in b select new TImplementer(); /// </code> /// </example> /// <returns> /// Returns a new <see cref="IBinding{TInterface}"/> that is able to resolve a value that implements the specified type when <see cref="IBinding{TInterface}.Resolve"/> is called. /// </returns> /// <exception cref="ArgumentException">Invalid Expression. The given expression must be a NewExpression. That is, the calling of a constructor.</exception> public static IBinding <TInterface> Select <TInterface, TImplementer>(this IBinding <TInterface> binding, [NotNull] Expression <Func <TInterface, TImplementer> > expression) where TImplementer : TInterface { if (expression == null) { throw new ArgumentNullException(nameof(expression)); } Expression constructorExpression = expression.Body; IBinding[] dependencies; Expression <Func <IBinding[], TInterface> > lazyExpression = constructorExpression.BuildLazyBindingExpression <TInterface>(out dependencies); LazyConstructorBinding <TInterface> b = new LazyConstructorBinding <TInterface>(dependencies, lazyExpression); return(Wrap(binding, b)); }