private async void OnMethodExecution(MethodExecution <TMarshal> methodExecution)
{
var resultTask = methodExecutor.Execute(methodExecution);
MethodResult <TMarshal> methodResult;
if (resultTask.IsCompleted)
{
methodResult = resultTask.Result;
}
else
{
methodResult = await resultTask.ConfigureAwait(false);
}
connection.Send(new RpcRequest <TMarshal>()
{
MethodResult = methodResult
});
}
public async Task <MethodResult <TMarshal> > Execute(MethodExecution <TMarshal> methodExcecution)
{
var result = new MethodResult <TMarshal>
{
ExecutionId = methodExcecution.ExecutionId
};
if (!objects.TryGetValue(methodExcecution.ObjectId, out var objectDescriptor))
{
result.Error = "Invalid object.";
return(result);
}
if (!objectDescriptor.Methods.TryGetValue(methodExcecution.MethodId, out var methodDescriptor))
{
result.Error = "Invalid function.";
return(result);
}
if (methodDescriptor.ParameterCount > 0 && methodDescriptor.ParameterCount != methodExcecution.Parameters.Length)
{
result.Error = "Parameter count mismatch.";
return(result);
}
var parameters = methodDescriptor.Parameters.ToArray();
var actualParameters = methodExcecution.Parameters.ToList();
var parameterBindings = parameters.Select((t, i) => new Binding <TMarshal>
{
TargetType = t.Type,
Value = actualParameters[i]
})
.ToList();
var boundParameters = parameterBindings.Select(this.BindToNet).ToList();
var parameterTypes = boundParameters.Count > 0 ? boundParameters.Select(p => p?.GetType()).ToArray() : new Type[] { };
for (var i = 0; i < parameterTypes.Length; i++)
{
if ((parameterTypes[i] != null || parameters[i].Type.IsValueType) && !parameters[i].Type.IsAssignableFrom(parameterTypes[i]))
{
result.Error = "Parameter mismatch.";
return(result);
}
}
try
{
var executeResult = methodDescriptor.Execute(objectDescriptor.Object, boundParameters.ToArray());
object actualResult = null;
if (executeResult is Task)
{
await(executeResult as Task).ConfigureAwait(false);
if (executeResult.GetType().IsGenericType)
{
actualResult = executeResult.GetType().GetProperty(nameof(Task <object> .Result))?.GetValue(executeResult);
}
}
else
{
actualResult = executeResult;
}
result.Result = this.BindToWire(actualResult, methodDescriptor.ReturnValueAttribute);
result.Success = true;
}
catch (TargetInvocationException e)
{
Log.ErrorException("Execute", e);
result.Error = e.InnerException?.Message;
}
catch (Exception e)
{
Log.ErrorException("Execute", e);
result.Error = e.Message;
}
return(result);
}
public MethodExecutionTest_Execute()
{
this.mockInstance = new MockClass();
this.methodExecution = new MethodExecution(mockInstance);
}
