private object InvokeService(MethodCall methodCall, ProxyOperationRuntime operation) { object[] outs; object[] ins = operation.MapSyncInputs(methodCall, out outs); object ret = _serviceChannel.Call(operation.Action, operation.IsOneWay, operation, ins, outs); operation.MapSyncOutputs(methodCall, outs, ref ret); return(ret); }
IMethodReturnMessage InvokeBeginService(IMethodCallMessage methodCall, ProxyOperationRuntime operation) { AsyncCallback callback; object asyncState; object[] ins = operation.MapAsyncBeginInputs(methodCall, out callback, out asyncState); object ret = this.serviceChannel.BeginCall(operation.Action, operation.IsOneWay, operation, ins, callback, asyncState); return(CreateReturnMessage(ret, null, methodCall)); }
private ProxyOperationRuntime GetOperationByName(string methodName) { ProxyOperationRuntime op = _runtime.GetOperationByName(methodName); if (op == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException(SR.Format(SR.SFxMethodNotSupported1, methodName))); } return(op); }
object SendMessage(OperationDescription opDesc, string action, object[] ins, object[] outs) { ProxyOperationRuntime operationRuntime = channelBuilderSettings.ServiceChannel.ClientRuntime.GetRuntime().GetOperationByName(opDesc.Name); if (operationRuntime == null) { throw Fx.AssertAndThrow("Operation runtime should not be null"); } return(channelBuilderSettings.ServiceChannel.Call(action, opDesc.IsOneWay, operationRuntime, ins, outs)); }
private object InvokeBeginService(MethodCall methodCall, ProxyOperationRuntime operation) { AsyncCallback callback; object asyncState; object[] ins = operation.MapAsyncBeginInputs(methodCall, out callback, out asyncState); object ret = _serviceChannel.BeginCall(operation.Action, operation.IsOneWay, operation, ins, callback, asyncState); return(ret); }
private ProxyOperationRuntime GetOperationByName(string methodName) { ProxyOperationRuntime operationByName = this.runtime.GetOperationByName(methodName); if (operationByName == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException(System.ServiceModel.SR.GetString("SFxMethodNotSupported1", new object[] { methodName }))); } return(operationByName); }
private System.ServiceModel.Dispatcher.ProxyOperationRuntime GetOperationByName(string methodName) { ProxyOperationRuntime op = _runtime.GetOperationByName(methodName); if (op == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException(string.Format(SRServiceModel.SFxMethodNotSupported1, methodName))); } return(op); }
private object InvokeEndService(MethodCall methodCall, ProxyOperationRuntime operation) { IAsyncResult result; object[] outs; operation.MapAsyncEndInputs(methodCall, out result, out outs); object ret = _serviceChannel.EndCall(operation.Action, outs, result); operation.MapAsyncOutputs(methodCall, outs, ref ret); return(ret); }
private IMethodReturnMessage InvokeEndService(IMethodCallMessage methodCall, ProxyOperationRuntime operation) { IAsyncResult result; object[] objArray; operation.MapAsyncEndInputs(methodCall, out result, out objArray); object ret = this.serviceChannel.EndCall(operation.Action, objArray, result); object[] returnArgs = operation.MapAsyncOutputs(methodCall, objArray, ref ret); return(this.CreateReturnMessage(ret, returnArgs, methodCall)); }
protected IAsyncResult BeginInvoke(string methodName, object[] args, AsyncCallback callback, object state) { object[] destinationArray = new object[args.Length + 2]; Array.Copy(args, destinationArray, args.Length); destinationArray[destinationArray.Length - 2] = callback; destinationArray[destinationArray.Length - 1] = state; IMethodCallMessage methodCall = new MethodCallMessage <TChannel, T>(destinationArray); ProxyOperationRuntime operationByName = this.GetOperationByName(methodName); object[] ins = operationByName.MapAsyncBeginInputs(methodCall, out callback, out state); return(this.channel.BeginCall(operationByName.Action, operationByName.IsOneWay, operationByName, ins, callback, state)); }
private object InvokeService(MethodCall methodCall, ProxyOperationRuntime operation) { object[] ins = operation.MapSyncInputs(methodCall, out object[] outs); object ret; using (TaskHelpers.RunTaskContinuationsOnOurThreads()) { ret = _serviceChannel.CallAsync(operation.Action, operation.IsOneWay, operation, ins, outs).GetAwaiter().GetResult(); } operation.MapSyncOutputs(methodCall, outs, ref ret); return(ret); }
protected override void Execute(CodeActivityContext context) { Message inMessage = this.Message.Get(context); if (inMessage == null) { throw FxTrace.Exception.AsError(new InvalidOperationException(SR.NullReplyMessageContractMismatch)); } if (inMessage.IsFault) { FaultConverter faultConverter = FaultConverter.GetDefaultFaultConverter(inMessage.Version); Exception exception = DeserializeFault(inMessage, faultConverter); // We simply throw the exception throw FxTrace.Exception.AsError(exception); } else { object[] outObjects; if (this.parameters != null) { outObjects = new object[this.parameters.Count]; } else { outObjects = Constants.EmptyArray; } object returnValue = this.Formatter.DeserializeReply(inMessage, outObjects); if (this.Result != null) { this.Result.Set(context, returnValue); } if (parameters != null) { for (int i = 0; i < this.parameters.Count; i++) { OutArgument outArgument = this.parameters[i]; Fx.Assert(outArgument != null, "Parameter cannot be null"); object obj = outObjects[i]; if (obj == null) { obj = ProxyOperationRuntime.GetDefaultParameterValue(outArgument.ArgumentType); } outArgument.Set(context, obj); } } } }
protected IAsyncResult BeginInvoke(string methodName, object[] args, AsyncCallback callback, object state) { object[] inArgs = new object[args.Length + 2]; Array.Copy(args, inArgs, args.Length); inArgs[inArgs.Length - 2] = callback; inArgs[inArgs.Length - 1] = state; MethodCall methodCall = new MethodCall(inArgs); ProxyOperationRuntime op = GetOperationByName(methodName); object[] ins = op.MapAsyncBeginInputs(methodCall, out callback, out state); return(_channel.BeginCall(op.Action, op.IsOneWay, op, ins, callback, state)); }
public static Task <T> CreateGenericTask <T>(ServiceChannel channel, ProxyOperationRuntime operation, object[] inputParameters) { Func <IAsyncResult, T> endCallDelegate = (asyncResult) => { OperationContext originalOperationContext = OperationContext.Current; OperationContext.Current = asyncResult.AsyncState as OperationContext; try { return((T)channel.EndCall(operation.Action, ProxyOperationRuntime.EmptyArray, asyncResult)); } finally { OperationContext.Current = originalOperationContext; } }; return(Task <T> .Factory.FromAsync <ServiceChannel, ProxyOperationRuntime, object[]>(beginCallDelegate, endCallDelegate, channel, operation, inputParameters, OperationContext.Current)); }
protected override void Execute(NativeActivityContext context) { System.ServiceModel.Channels.Message message = null; try { object[] emptyArray; message = this.Message.Get(context); if ((this.parameters == null) || (this.parameters.Count == 0)) { emptyArray = System.ServiceModel.Activities.Constants.EmptyArray; } else { emptyArray = new object[this.parameters.Count]; } this.Formatter.DeserializeRequest(message, emptyArray); if (this.parameters != null) { for (int i = 0; i < this.parameters.Count; i++) { OutArgument argument = this.parameters[i]; object defaultParameterValue = emptyArray[i]; if (defaultParameterValue == null) { defaultParameterValue = ProxyOperationRuntime.GetDefaultParameterValue(argument.ArgumentType); } argument.Set(context, defaultParameterValue); } } } finally { if (this.CloseMessage && (message != null)) { message.Close(); } this.Message.Set(context, null); System.Activities.NoPersistHandle handle = (this.NoPersistHandle == null) ? null : this.NoPersistHandle.Get(context); if (handle != null) { handle.Exit(context); } } }
protected object EndInvoke(string methodName, object[] args, IAsyncResult result) { object[] objArray2; object[] destinationArray = new object[args.Length + 1]; Array.Copy(args, destinationArray, args.Length); destinationArray[destinationArray.Length - 1] = result; IMethodCallMessage methodCall = new MethodCallMessage <TChannel, T>(destinationArray); ProxyOperationRuntime operationByName = this.GetOperationByName(methodName); operationByName.MapAsyncEndInputs(methodCall, out result, out objArray2); object ret = this.channel.EndCall(operationByName.Action, objArray2, result); object[] sourceArray = operationByName.MapAsyncOutputs(methodCall, objArray2, ref ret); if (sourceArray != null) { Array.Copy(sourceArray, args, args.Length); } return(ret); }
static Task CreateTask(ServiceChannel channel, ProxyOperationRuntime operation, object[] inputParameters) { Action <IAsyncResult> endCallDelegate = (asyncResult) => { Fx.Assert(asyncResult != null, "'asyncResult' MUST NOT be NULL."); OperationContext originalOperationContext = OperationContext.Current; OperationContext.Current = asyncResult.AsyncState as OperationContext; try { channel.EndCall(operation.Action, ProxyOperationRuntime.EmptyArray, asyncResult); } finally { OperationContext.Current = originalOperationContext; } }; return(Task.Factory.FromAsync(beginCallDelegate, endCallDelegate, channel, operation, inputParameters, OperationContext.Current)); }
protected override void Execute(CodeActivityContext context) { object[] emptyArray; System.ServiceModel.Channels.Message inMessage = this.Message.Get(context); if (inMessage == null) { throw System.ServiceModel.Activities.FxTrace.Exception.AsError(new InvalidOperationException(System.ServiceModel.Activities.SR.NullReplyMessageContractMismatch)); } if (inMessage.IsFault) { FaultConverter defaultFaultConverter = FaultConverter.GetDefaultFaultConverter(inMessage.Version); Exception exception = this.DeserializeFault(inMessage, defaultFaultConverter); throw System.ServiceModel.Activities.FxTrace.Exception.AsError(exception); } if (this.parameters != null) { emptyArray = new object[this.parameters.Count]; } else { emptyArray = System.ServiceModel.Activities.Constants.EmptyArray; } object obj2 = this.Formatter.DeserializeReply(inMessage, emptyArray); if (this.Result != null) { this.Result.Set(context, obj2); } if (this.parameters != null) { for (int i = 0; i < this.parameters.Count; i++) { OutArgument argument = this.parameters[i]; object defaultParameterValue = emptyArray[i]; if (defaultParameterValue == null) { defaultParameterValue = ProxyOperationRuntime.GetDefaultParameterValue(argument.ArgumentType); } argument.Set(context, defaultParameterValue); } } }
private static Task CreateTask(ServiceChannel channel, ProxyOperationRuntime operation, object[] inputParameters) { TaskCompletionSource <object> tcs = new TaskCompletionSource <object>(); bool completedCallback = false; Action <IAsyncResult> endCallDelegate = (asyncResult) => { Contract.Assert(asyncResult != null, "'asyncResult' MUST NOT be NULL."); completedCallback = true; OperationContext originalOperationContext = OperationContext.Current; OperationContext.Current = asyncResult.AsyncState as OperationContext; try { channel.EndCall(operation.Action, Array.Empty <object>(), asyncResult); tcs.TrySetResult(null); } catch (Exception e) { tcs.TrySetException(e); } finally { OperationContext.Current = originalOperationContext; } }; try { IAsyncResult ar = ServiceChannel.BeginCall(channel, operation, inputParameters, new AsyncCallback(endCallDelegate), OperationContext.Current); if (ar.CompletedSynchronously && !completedCallback) { endCallDelegate(ar); } } catch (Exception e) { tcs.TrySetException(e); } return(tcs.Task); }
protected object EndInvoke(string methodName, object[] args, IAsyncResult result) { object[] inArgs = new object[args.Length + 1]; Array.Copy(args, inArgs, args.Length); inArgs[inArgs.Length - 1] = result; MethodCall methodCall = new MethodCall(inArgs); ProxyOperationRuntime op = GetOperationByName(methodName); object[] outs; op.MapAsyncEndInputs(methodCall, out result, out outs); object ret = _channel.EndCall(op.Action, outs, result); object[] retArgs = op.MapAsyncOutputs(methodCall, outs, ref ret); if (retArgs != null) { Fx.Assert(retArgs.Length == inArgs.Length, "retArgs.Length should be equal to inArgs.Length"); Array.Copy(retArgs, args, args.Length); } return(ret); }
private static Task CreateTask(ServiceChannel channel, ProxyOperationRuntime operation, object[] inputParameters) { TaskCompletionSource <object> tcs = new TaskCompletionSource <object>(); Action <Task <object>, object> completeCallDelegate = (antecedent, obj) => { var tcsObj = obj as TaskCompletionSource <object>; Contract.Assert(tcsObj != null); if (antecedent.IsFaulted) { tcsObj.TrySetException(antecedent.Exception.InnerException); } else if (antecedent.IsCanceled) { tcsObj.TrySetCanceled(); } else { tcsObj.TrySetResult(antecedent.Result); } }; try { channel.CallAsync(operation.Action, operation.IsOneWay, operation, inputParameters, Array.Empty <object>()).ContinueWith(completeCallDelegate, tcs); } #pragma warning disable CA1031 // Do not catch general exception types - copying all exceptions to TaskCompeletionSource catch (Exception e) { tcs.TrySetException(e); } #pragma warning restore CA1031 // Do not catch general exception types return(tcs.Task); }
private MethodData GetMethodData(MethodCall methodCall) { MethodBase method = methodCall.MethodBase; if (_methodDataCache.TryGetMethodData(method, out MethodData methodData)) { return(methodData); } bool canCacheMessageData; Type declaringType = method.DeclaringType; if (declaringType == typeof(object) && method == typeof(object).GetMethod("GetType")) { canCacheMessageData = true; methodData = new MethodData(method, MethodType.GetType); } else if (declaringType.IsAssignableFrom(_serviceChannel.GetType())) { canCacheMessageData = true; methodData = new MethodData(method, MethodType.Channel); } else { ProxyOperationRuntime operation = _proxyRuntime.GetOperation(method, methodCall.Args, out canCacheMessageData); if (operation == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException(SR.Format(SR.SFxMethodNotSupportedOnCallback1, method.Name))); } MethodType methodType; if (operation.IsTaskCall(methodCall)) { methodType = MethodType.TaskService; } else if (operation.IsSyncCall(methodCall)) { methodType = MethodType.Service; } else if (operation.IsBeginCall(methodCall)) { methodType = MethodType.BeginService; } else { methodType = MethodType.EndService; } methodData = new MethodData(method, methodType, operation); } if (canCacheMessageData) { _methodDataCache.SetMethodData(methodData); } return(methodData); }
public MethodData(MethodBase methodBase, MethodType methodType, ProxyOperationRuntime operation) { MethodBase = methodBase; MethodType = methodType; Operation = operation; }
private object InvokeTaskService(MethodCall methodCall, ProxyOperationRuntime operation) { Task task = TaskCreator.CreateTask(_serviceChannel, methodCall, operation); return(task); }
MethodData GetMethodData(IMethodCallMessage methodCall) { MethodBase method = methodCall.MethodBase; MethodData methodData; if (methodDataCache.TryGetMethodData(method, out methodData)) { return(methodData); } bool canCacheMessageData; Type declaringType = method.DeclaringType; if (declaringType == typeof(object)) { MethodType methodType; if (methodCall.MethodBase == typeof(object).GetMethod("GetType")) { methodType = MethodType.GetType; } else { methodType = MethodType.Object; } canCacheMessageData = true; methodData = new MethodData(method, methodType); } else if (declaringType.IsInstanceOfType(this.serviceChannel)) { canCacheMessageData = true; methodData = new MethodData(method, MethodType.Channel); } else { ProxyOperationRuntime operation = this.proxyRuntime.GetOperation(method, methodCall.Args, out canCacheMessageData); if (operation == null) { if (this.serviceChannel.Factory != null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException(SR.GetString(SR.SFxMethodNotSupported1, method.Name))); } else { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException(SR.GetString(SR.SFxMethodNotSupportedOnCallback1, method.Name))); } } MethodType methodType; if (operation.IsTaskCall(methodCall)) { methodType = MethodType.TaskService; } else if (operation.IsSyncCall(methodCall)) { methodType = MethodType.Service; } else if (operation.IsBeginCall(methodCall)) { methodType = MethodType.BeginService; } else { methodType = MethodType.EndService; } methodData = new MethodData(method, methodType, operation); } if (canCacheMessageData) { methodDataCache.SetMethodData(methodData); } return(methodData); }
static Task CreateGenericTask(ServiceChannel channel, ProxyOperationRuntime operation, object[] inputParameters) { Func <ServiceChannel, ProxyOperationRuntime, object[], Task> createTaskDelegate = GetOrCreateTaskDelegate(operation.TaskTResult); return(createTaskDelegate(channel, operation, inputParameters)); }
IMessage InvokeTaskService(IMethodCallMessage methodCall, ProxyOperationRuntime operation) { Task task = TaskCreator.CreateTask(this.serviceChannel, methodCall, operation); return(CreateReturnMessage(task, null, methodCall)); }
public MethodData(System.Reflection.MethodBase methodBase, System.ServiceModel.Channels.ServiceChannelProxy.MethodType methodType, ProxyOperationRuntime operation) { this.methodBase = methodBase; this.methodType = methodType; this.operation = operation; }
private MethodData GetMethodData(IMethodCallMessage methodCall) { MethodData data; MethodBase methodBase = methodCall.MethodBase; if (!this.methodDataCache.TryGetMethodData(methodBase, out data)) { bool flag; System.Type declaringType = methodBase.DeclaringType; if (declaringType == typeof(object)) { MethodType getType; if (methodCall.MethodBase == typeof(object).GetMethod("GetType")) { getType = MethodType.GetType; } else { getType = MethodType.Object; } flag = true; data = new MethodData(methodBase, getType); } else if (declaringType.IsInstanceOfType(this.serviceChannel)) { flag = true; data = new MethodData(methodBase, MethodType.Channel); } else { MethodType service; ProxyOperationRuntime operation = this.proxyRuntime.GetOperation(methodBase, methodCall.Args, out flag); if (operation == null) { if (this.serviceChannel.Factory != null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException(System.ServiceModel.SR.GetString("SFxMethodNotSupported1", new object[] { methodBase.Name }))); } throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException(System.ServiceModel.SR.GetString("SFxMethodNotSupportedOnCallback1", new object[] { methodBase.Name }))); } if (operation.IsSyncCall(methodCall)) { service = MethodType.Service; } else if (operation.IsBeginCall(methodCall)) { service = MethodType.BeginService; } else { service = MethodType.EndService; } data = new MethodData(methodBase, service, operation); } if (flag) { this.methodDataCache.SetMethodData(data); } } return(data); }
public static Task CreateTask(ServiceChannel channel, MethodCall methodCall, ProxyOperationRuntime operation) { if (operation.TaskTResult == ServiceReflector.VoidType) { return(CreateTask(channel, operation, methodCall.Args)); } return(CreateGenericTask(channel, operation, methodCall.Args)); }