public override object Invoke(__arglist) { ArgIterator ai = new ArgIterator(__arglist); ObjectTypeHandle[] args = new ObjectTypeHandle[ai.GetRemainingCount()]; while (ai.GetRemainingCount() > 0) { int idx = args.Length - ai.GetRemainingCount(); object arg = TypedReference.ToObject(ai.GetNextArg()); args[idx] = AdapterTools.Marshal(arg); } var res = Delegate.InvokeMember("Invoke", ref args, new bool[args.Length]); ai = new ArgIterator(__arglist); while (ai.GetRemainingCount() > 0) { int idx = args.Length - ai.GetRemainingCount(); ObjectHandle arg = args[idx]; var tr = ai.GetNextArg(); if (__reftype(tr).IsByRef) { tr.SetValue(arg.Unwrap()); } } if (res != null) { return(res.Unwrap()); } else { return(null); } }
private void RegisterMarshaller(TaskMarshaller marshaller) { Task.ContinueWith( t => { if (t.IsFaulted) { marshaller.SetException(t.Exception.InnerExceptions.ToArray()); } else if (t.IsCanceled) { marshaller.SetCanceled(); } else if (t.IsCompleted) { if (ResultType != null) { marshaller.SetResult(AdapterTools.Marshal(((dynamic)t).Result)); } else { marshaller.SetResult(null); } } } ); }
private bool Try(CallSiteBinder binder, object[] args, out object result) { ObjectHandle[] argHandles = AdapterTools.Marshal(args); var binding = new BindingInfo(binder); var resHandle = Adapter.InvokeMember(binding, ref argHandles); AdapterTools.Unmarshal(argHandles).CopyTo(args, 0); result = AdapterTools.Unmarshal(resHandle); return(true); }
private bool Try(CallSiteBinder binder, string member, object[] args, out object result) { ObjectTypeHandle[] argHandles = AdapterTools.Marshal(args); BindingInfo binding = new BindingInfo(binder); const CSharpArgumentInfoFlags flagsRefOrOut = CSharpArgumentInfoFlags.IsRef | CSharpArgumentInfoFlags.IsOut; ObjectTypeHandle resHandle; try{ resHandle = Adapter.InvokeMember(member, ref argHandles, binding.ArgumentFlags.Skip(1).Select(f => (f & flagsRefOrOut) != 0).ToArray()); }catch (MissingMethodException) { result = null; return(false); } AdapterTools.Unmarshal(argHandles).CopyTo(args, 0); result = AdapterTools.Unmarshal(resHandle); return(true); }
public override IMessage Invoke(IMessage msg) { IMethodCallMessage msgCall = (IMethodCallMessage)msg; var oArgs = msgCall.Args; var args = AdapterTools.Marshal(oArgs); try{ var ret = Adapter.InvokeMember(msgCall.MethodBase, ref args); oArgs = AdapterTools.Unmarshal(args); return(new ReturnMessage(AdapterTools.Unmarshal(ret), oArgs, oArgs.Length, msgCall.LogicalCallContext, msgCall)); }catch (TargetInvocationException e) { return(new ReturnMessage(e.InnerException, msgCall)); }catch (Exception e) { return(new ReturnMessage(e, msgCall)); } }
public ObjectHandle InvokeMember(BindingInfo binding, ref ObjectHandle[] args) { object[] oArgs = AdapterTools.Unmarshal(args); var binder = binding.CreateBinder(); object[] argsObj = new object[args.Length + 1]; argsObj[0] = Value; oArgs.CopyTo(argsObj, 1); Expression dynExpr; object ret; const CSharpArgumentInfoFlags flagsRefOrOut = CSharpArgumentInfoFlags.IsRef | CSharpArgumentInfoFlags.IsOut; var argsConst = Expression.Constant(argsObj); var argsExp = argsObj.Select((o, i) => (binding.ArgumentFlags[i] & flagsRefOrOut) != 0?(Expression)Expression.ArrayAccess(argsConst, Expression.Constant(i)):Expression.Constant(o)); try{ if ((binding.Flags & CSharpBinderFlags.ResultDiscarded) != 0) { dynExpr = Expression.Dynamic(binder, typeof(void), argsExp); Expression.Lambda <Action>(dynExpr).Compile().Invoke(); ret = null; } else { dynExpr = Expression.Dynamic(binder, typeof(object), argsExp); ret = Expression.Lambda <Func <object> >(dynExpr).Compile().Invoke(); } }catch (TargetInvocationException e) { throw e.InnerException; } for (int i = 0; i < binding.ArgumentFlags.Length; i++) { if ((binding.ArgumentFlags[i] & flagsRefOrOut) == 0) { argsObj[i] = null; } } Array.Copy(argsObj, 1, oArgs, 0, oArgs.Length); args = AdapterTools.Marshal(oArgs); return(AdapterTools.Marshal(ret)); }
/// <summary> /// Invokes a method on the stored instance. An array of <see cref="ObjectTypeHandle"/> must be used to pass the arguments. /// </summary> /// <param name="method">The method reference to invoke on the instance.</param> /// <param name="args">The arguments to invoke the method with.</param> /// <returns>The return value of the method invocation.</returns> public ObjectTypeHandle InvokeMember(MethodBase method, ref ObjectTypeHandle[] args) { object[] oArgs = AdapterTools.Unmarshal(args); object ret; try{ ret = method.Invoke(Value, oArgs); }catch (TargetInvocationException e) { throw e.InnerException; } var pars = method.GetParameters(); for (int i = 0; i < pars.Length; i++) { if (!pars[i].ParameterType.IsByRef) { oArgs[i] = null; } } args = AdapterTools.Marshal(oArgs); return(AdapterTools.Marshal(ret)); }