/// <summary> /// Invokes the message. /// </summary> /// <param name="msg">The message.</param> /// <returns>The result of invocation.</returns> public override IMessage Invoke(IMessage msg) { IConstructionCallMessage constructorCall = msg as IConstructionCallMessage; if (constructorCall != null) { if (this.target == null) { MethodInfo factoryMethodInfo = Utility.GetInheritedMethod(constructorCall.ActivationType, DynamicConstructionAttribute.InstantiateMethodName, new[] { typeof(Type), typeof(object[]) }); if (factoryMethodInfo == null) { throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "Cannot create an instance of type '{0}' because there is no '{1}' static method defined in its inheritance hierarchy. See '{2}' methods for an example of corresponding method signature.", constructorCall.ActivationType.AssemblyQualifiedName, DynamicConstructionAttribute.InstantiateMethodName, typeof(LiveTest).AssemblyQualifiedName)); } if (!DynamicConstructionAttribute.EnterInstantiationPhase()) { throw new InvalidOperationException("Error in instantiation workflow. Object is already in the middle of instantiation when another instance of the object is created."); } try { this.target = (LiveTest)factoryMethodInfo.Invoke(null, new object[] { constructorCall.ActivationType, constructorCall.Args }); } finally { DynamicConstructionAttribute.LeaveInstantiationPhase(); } } return(EnterpriseServicesHelper.CreateConstructionReturnMessage(constructorCall, (MarshalByRefObject)this.GetTransparentProxy())); } IMethodCallMessage methodCall = msg as IMethodCallMessage; if (methodCall != null) { methodCall = new MethodCall(methodCall); MethodCallEventArgs eventArgs = typeof(LiveTest).IsAssignableFrom(methodCall.MethodBase.DeclaringType) ? new MethodCallEventArgs(Interlocked.Increment(ref methodCallId), methodCall.MethodBase, methodCall.Args) : null; if (eventArgs != null) { this.target.OnBeforeMethodCall(this.target, eventArgs); } IMessage result = RemotingServices.GetRealProxy(this.target).Invoke(methodCall); if (eventArgs != null) { this.target.OnAfterMethodCall(this.target, eventArgs); } return(result); } throw new NotSupportedException("Operations other than constructor and method calls are not supported."); }
/// <summary> /// Event handler executed before each method call. /// </summary> /// <param name="sender">The sender.</param> /// <param name="args">The arguments.</param> protected virtual void OnBeforeMethodCall(object sender, MethodCallEventArgs args) { if (args == null) { throw new ArgumentNullException("args"); } if (this.InitializationManager != null) { this.InitializationManager.Initialize(args.MethodCallId, new TestInitializationContext(this, args.Method, args.Arguments)); } }
/// <summary> /// Handles method call event /// </summary> unsafe static partial void Behavior_HandleMethodCall(ISciterBehavior behavior, IntPtr he, IntPtr prms, ref bool handled) { var datantf = (METHOD_PARAMS *)prms; var methodId = (METHOD_PARAMS.BEHAVIOR_METHOD_IDENTIFIERS)datantf->methodID; switch (methodId) { case METHOD_PARAMS.BEHAVIOR_METHOD_IDENTIFIERS.XCALL: { var data = (XCALL_PARAMS *)datantf; var e = new ScriptingMethodCallEventArgs(Element.Create(he)) { Arguments = data->GetArgs(), MethodName = data->GetName() }; behavior.ProcessScriptingMethodCall(e); if (e.Handled) { data->result.SetValue(e.ReturnValue); } handled = e.Handled; } break; default: { var e = new MethodCallEventArgs(Element.Create(he)); behavior.ProcessMethodCall(e); handled = e.Handled; } break; } }
/// <summary> /// The routine called before test method call. /// </summary> /// <param name="sender">The sender.</param> /// <param name="args">The arguments.</param> protected override void OnBeforeMethodCall(object sender, MethodCallEventArgs args) { args.Arguments[0] = args.Arguments[0].ToString() + '*'; }
/// <summary> /// The routine called after test method call. /// </summary> /// <param name="sender">The sender.</param> /// <param name="args">The arguments.</param> protected override void OnAfterMethodCall(object sender, MethodCallEventArgs args) { Assert.Equal("testValue", CallContext.LogicalGetData("test1")); Assert.Equal("testValue", CallContext.LogicalGetData("test2")); }
/// <summary> /// The routine called before test method call. /// </summary> /// <param name="sender">The sender.</param> /// <param name="args">The arguments.</param> protected override void OnBeforeMethodCall(object sender, MethodCallEventArgs args) { CallContext.LogicalSetData("test1", "testValue"); }