public string PostRequest(string method, List <string> rpcBody, out string returnCode)
{
RpcMethod = method;
foreach (var rpc in rpcBody)
{
RpcParameter += "," + rpc;
}
RpcParameter = RpcParameter.Substring(1);
RpcBody = "{\"jsonrpc\":\"2.0\",\"method\":\"" + RpcMethod + "\",\"params\":{\"rawtxs\":\"" + RpcParameter + "\"},\"id\":0}";
return(HttpHelper.PostResponse(RpcUrl, RpcBody, out returnCode));
}
public string PostRequest(string method, List <string> rpcBody, out string returnCode)
{
RpcMethod = method;
foreach (var rpc in rpcBody)
{
RpcParameter += "," + rpc;
}
RpcParameter = RpcParameter.Substring(1);
RpcBody = "{\"jsonrpc\":\"2.0\",\"method\":\"" + RpcMethod + "\",\"params\":{\"rawtxs\":\"" + RpcParameter + "\"},\"id\":0}";
Console.WriteLine("One thread rpc request generated successfully.");
return(HttpHelper.PostResponse(RpcUrl, RpcBody, out returnCode));
}
protected override IMessage Invoke(IMethodCallMessage mcall)
{
Marshaler marshaler = new Marshaler(site, NativeMarshalingConfiguration.Configuration);
foreach (Type type in proxiedType.Assembly.GetTypes())
{
marshaler.DefineCustomType(type.Name, type);
}
if (mcall.MethodBase == getHandleMethod)
{
return(GetHandle(mcall));
}
if (mcall.MethodBase == setHandleMethod)
{
return(SetHandle(mcall));
}
Initialize();
RpcStub stub;
if (!stubs.TryGetValue(mcall.MethodBase, out stub))
{
throw new InvalidOperationException(String.Format("cannot find stub for method '{0}'", mcall.MethodBase));
}
// marshal parameters
int n = stub.parameters.Length;
int actualsOffs = handleImplicit ? 1 : 0;
object[] actuals = new object[n + actualsOffs];
if (handleImplicit)
{
if (handle == null)
{
marshaler.TestAssumeFail(
"handle undefined for rpc interface '{0}' with implicit handle passing",
proxiedType);
}
IntPtr ptr = Marshal.StringToHGlobalUni(handle);
marshaler.MarkMemoryForDispose(ptr);
actuals[0] = ptr;
}
marshaler.EnterContext();
for (int i = 0; i < n; i++)
{
if (!stub.parameters[i].IsOut)
{
marshaler.DefineSymbol(mcall.GetArgName(i), mcall.Args[i]);
}
}
ParameterInfo[] parameterInfos = mcall.MethodBase.GetParameters();
for (int pass = 0; pass < 2; pass++)
{
for (int i = 0; i < n; i++)
{
if (pass == 0 && stub.parameters[i].HasDynamicExpression)
{
continue;
}
if (pass == 1 &&
!stub.parameters[i].HasDynamicExpression)
{
continue;
}
stub.parameters[i].AllocateMemoryRegion(marshaler, mcall.Args[i]);
RpcParameter rp = stub.parameters[i];
if (rp.marshallingRegion != null)
{
rp.marshallingRegion.TryReset();
}
if (!rp.IsOut &&
mcall.Args[i] != null)
{
object value = mcall.Args[i];
// Validate the value of the parameter.
if (this.needAutoValidate)
{
CheckParameter(parameterInfos[i], value, mcall, marshaler.SymbolStore);
}
marshaler.MarshalInto(rp.context, rp.marshallingRegion, mcall.Args[i]);
}
else
{
marshaler.EnterRegion(rp.marshallingRegion);
marshaler.Clear(marshaler.GetSize(rp.context, null));
marshaler.ExitRegion();
}
if (!rp.IsByRef)
{
actuals[i + actualsOffs] = rp.Get();
}
else
{
if (mcall.Args[i] == null && !rp.IsOut)
{
actuals[i + actualsOffs] = IntPtr.Zero;
}
else
{
actuals[i + actualsOffs] = rp.marshallingRegion.NativeMemory;
}
}
marshaler.DefineSymbol(mcall.GetArgName(i), actuals[i + actualsOffs]);
}
}
// call
object result;
try
{
result = stub.stubMethod.Invoke(null, actuals);
}
catch (TargetInvocationException e)
{
throw e.InnerException;
}
// marshal output parameters
object[] resultArgs = new object[n];
marshaler.IsProbingUnmarshaling = true;
for (int pass = 0; pass < 2; pass++)
{
for (int i = 0; i < n; i++)
{
RpcParameter rp = stub.parameters[i];
if (rp.marshallingRegion != null)
{
rp.marshallingRegion.TryReset();
}
if (rp.IsByRef)
{
object res = resultArgs[i] =
marshaler.UnmarshalFrom(rp.context, rp.marshallingRegion);
if (marshaler.IsProbingUnmarshaling == false)
{
RpcAdapterValidate(res, rp.context.Attributes, marshaler.SymbolStore);
if (rp.IsOut && marshaler.GetNativeType(rp.context) == typeof(IntPtr))
{
foreach (IntPtr ptr in marshaler.ForeignMemory)
{
if (ptr != IntPtr.Zero && rpcFreeMethod != null)
{
rpcFreeMethod.Invoke(null, new object[] { ptr });
}
}
}
}
marshaler.ForeignMemory.Clear();
if (!rp.IsByRef)
{
marshaler.DefineSymbol(mcall.GetArgName(i), rp.Get());
}
else
{
marshaler.DefineSymbol(mcall.GetArgName(i),
rp.marshallingRegion.NativeMemory);
}
}
else
{
resultArgs[i] = mcall.Args[i];
}
}
marshaler.IsProbingUnmarshaling = false;
}
if (stub.returnParameter.nativeType != typeof(void))
{
stub.returnParameter.AllocateMemoryRegion(marshaler, result);
stub.returnParameter.marshallingRegion.TryReset();
stub.returnParameter.Set(result);
result = marshaler.UnmarshalFrom(
stub.returnParameter.context,
stub.returnParameter.marshallingRegion);
RpcAdapterValidate(result, null, null);
}
marshaler.ExitContext();
marshaler.FreeMemory();
marshaler.Dispose();
marshaler = null;
CheckOperation(mcall);
ReturnMessage mret = new ReturnMessage(result, resultArgs, resultArgs.Length, mcall.LogicalCallContext, mcall);
return(mret);
}