public void ExpressionTarget_ResolvingByHelperShouldGoThroughActiveScope() { var targets = CreateTargetContainer(); targets.RegisterType <Disposable>(); //note - this expression is ultimately identical to using 'RegisterType' targets.RegisterExpression(() => new RequiresDisposable(ExpressionFunctions.Resolve <Disposable>())); var container = CreateContainer(targets); RequiresDisposable outerResult = null; RequiresDisposable innerResult = null; using (var scope = container.CreateScope()) { outerResult = scope.Resolve <RequiresDisposable>(); using (var childScope = scope.CreateScope()) { innerResult = childScope.Resolve <RequiresDisposable>(); } Assert.Equal(1, innerResult.DisposedCount); Assert.True(innerResult.Disposable.Disposed); } Assert.Equal(1, innerResult.DisposedCount); Assert.True(innerResult.Disposable.Disposed); Assert.Equal(1, outerResult.DisposedCount); Assert.True(outerResult.Disposable.Disposed); }
public void ExpressionTarget_LambdaShouldResolveViaHelperAndReturnAMethodCall() { //same as above, except not using the generic version var targets = CreateTargetContainer(); targets.RegisterType <ServiceWithFunctions>(); targets.RegisterExpression(() => ((ServiceWithFunctions)ExpressionFunctions.Resolve(typeof(ServiceWithFunctions))).GetChild(5)); var container = CreateContainer(targets); Assert.Equal(new ServiceWithFunctions().GetChild(5).Output, container.Resolve <ServiceChild>().Output); }
public void ShouldLocateViaHelperInParameterlessLambda() { // <example6> var container = new Container(); container.RegisterType <MyService, IMyService>(); container.RegisterExpression(() => new RequiresMyService(ExpressionFunctions.Resolve <IMyService>()) ); var result = container.Resolve <RequiresMyService>(); Assert.NotNull(result.Service); // </example6> }
public void ExpressionTarget_ExpressionShouldResolveViaHelper() { //testing that the ExpressionFunctions static works in a non-lambda //to do this we just use the body of a lambda var targets = CreateTargetContainer(); targets.RegisterType <ServiceWithFunctions>(); Expression <Func <ServiceChild> > f = () => ((ServiceWithFunctions)ExpressionFunctions.Resolve(typeof(ServiceWithFunctions))).GetChild(9); targets.RegisterExpression(f.Body, typeof(ServiceChild)); var container = CreateContainer(targets); Assert.Equal(new ServiceWithFunctions().GetChild(9).Output, container.Resolve <ServiceChild>().Output); }
public void ExpressionTarget_LambdaShouldResolveViaGenericHelperAndReturnAMethodCall() { //When you want to explicitly resolve something in an expression, but don't want to or can't //use a lambda argument, you can also use the Function.Resolve helper method. It does nothing //at run time (except throw an exception) but it instructs the target adapter to replace that //call with a ResolvedTarget, which is more efficient and flexible than simply emitting a //runtime call to the container's Resolve method. var targets = CreateTargetContainer(); targets.RegisterType <ServiceWithFunctions>(); targets.RegisterExpression(() => ExpressionFunctions.Resolve <ServiceWithFunctions>().GetChild(5)); var container = CreateContainer(targets); Assert.Equal(new ServiceWithFunctions().GetChild(5).Output, container.Resolve <ServiceChild>().Output); }