public SyncCallback(string procedureUri, MethodInfoHelper methodInfoHelper, object[] arguments, IOperationResultExtractor <TResult> extractor)
{
mMethodInfoHelper = methodInfoHelper;
mLogger = LogProvider.GetLogger(typeof(SyncCallback <TResult>) + "." + procedureUri);
mArguments = arguments;
mExtractor = extractor;
}
private static InvokeAsyncDelegate <T> GetInvokeAsync <T>(MethodBase method, IOperationResultExtractor <T> extractor)
{
InvokeAsyncDelegate <T> result =
(proxy, cancellationToken, arguments) =>
proxy.InvokeAsync(method, extractor, cancellationToken, arguments);
return(result);
}
GetInvokeProgressiveAsync <T>(MethodBase method,
IOperationResultExtractor <T> extractor)
{
InvokeProgressiveAsyncDelegate <T> result =
(proxy, progress, cancellationToken, arguments) =>
proxy.InvokeProgressiveAsync(method, progress, cancellationToken, extractor, arguments);
return(result);
}
private T InvokeSync <T>(MethodBase method,
IOperationResultExtractor <T> valueExtractor,
params object[] arguments)
{
MethodInfo methodInfo = (MethodInfo)method;
return(mHandler.Invoke
(mInterceptor,
methodInfo,
valueExtractor,
arguments));
}
private Task <T> InvokeProgressiveAsync <T>
(MethodBase method,
IProgress <T> progress,
IOperationResultExtractor <T> resultExtractor,
params object[] arguments)
{
return(InvokeProgressiveAsync <T>
(method,
progress,
CancellationToken.None,
resultExtractor,
arguments));
}
private Task <T> InvokeAsync <T>(MethodBase method,
IOperationResultExtractor <T> valueExtractor,
CancellationToken cancellationToken,
params object[] arguments)
{
MethodInfo methodInfo = (MethodInfo)method;
return(mHandler.InvokeAsync
(mInterceptor,
methodInfo,
valueExtractor,
arguments,
cancellationToken));
}
private Task <T> InvokeProgressiveAsync <T>
(MethodBase method,
IProgress <T> progress,
IOperationResultExtractor <T> resultExtractor,
params object[] arguments)
{
MethodInfo methodInfo = (MethodInfo)method;
return(mHandler.InvokeProgressiveAsync
(mInterceptor,
methodInfo,
resultExtractor,
arguments,
progress));
}
public T Invoke <T>(ICalleeProxyInterceptor interceptor, MethodInfo method, IOperationResultExtractor <T> extractor, object[] arguments)
{
Type unwrapped = TaskExtensions.UnwrapReturnType(method.ReturnType);
SyncCallback <T> callback = InnerInvokeSync <T>(interceptor, method, extractor, arguments, unwrapped);
WaitForResult(callback);
Exception exception = callback.Exception;
if (exception != null)
{
throw exception;
}
return(callback.OperationResult);
}
public AsyncOperationCallback(IOperationResultExtractor <TResult> extractor)
{
mExtractor = extractor;
}
protected static InvokeProgressiveAsyncDelegate <T> GetInvokeProgressiveAsync <T>(MethodInfo method)
{
IOperationResultExtractor <T> extractor = GetExtractor <T>(method);
return(GetInvokeProgressiveAsync(method, extractor));
}
private Task <T> InvokeAsync <T>(MethodBase method,
IOperationResultExtractor <T> valueExtractor,
params object[] arguments)
{
return(InvokeAsync <T>(method, valueExtractor, CancellationToken.None, arguments));
}
public ProgressiveAsyncOperationCallback(IProgress <TResult> progress,
IOperationResultExtractor <TResult> extractor) :
base(extractor)
{
mProgress = progress;
}
public Task <T> InvokeProgressiveAsync <T>(ICalleeProxyInterceptor interceptor, MethodInfo method, IOperationResultExtractor <T> extractor, object[] arguments, IProgress <T> progress)
{
ProgressiveAsyncOperationCallback <T> asyncOperationCallback =
new ProgressiveAsyncOperationCallback <T>(progress, extractor);
Task <T> task = InnerInvokeAsync <T>(asyncOperationCallback, interceptor, method, arguments);
return(task);
}
public Task <T> InvokeAsync <T>(ICalleeProxyInterceptor interceptor, MethodInfo method, IOperationResultExtractor <T> extractor, object[] arguments)
{
AsyncOperationCallback <T> callback = new AsyncOperationCallback <T>(extractor);
Task <T> task = InnerInvokeAsync <T>(callback, interceptor, method, arguments);
return(task);
}
private SyncCallback <T> InnerInvokeSync <T>(ICalleeProxyInterceptor interceptor, MethodInfo method, IOperationResultExtractor <T> extractor, object[] arguments, Type unwrapped)
{
MethodInfoHelper methodInfoHelper = new MethodInfoHelper(method);
string procedureUri = interceptor.GetProcedureUri(method);
SyncCallback <T> syncCallback = new SyncCallback <T>(procedureUri, methodInfoHelper, arguments, extractor);
object[] argumentsToSend =
methodInfoHelper.GetInputArguments(arguments);
Invoke(interceptor, syncCallback, method, argumentsToSend);
return(syncCallback);
}
