public SendState(MessageProcessingHandler handler, CancellationToken token) { Debug.Assert(handler != null); _handler = handler; _token = token; }
/// <summary> /// Initializes a new instance of the CartClient class. /// </summary> /// <param name="adminBaseEndpoint">Admin endpoint</param> /// <param name="handler"></param> public CartClient(Uri adminBaseEndpoint, MessageProcessingHandler handler) : base(adminBaseEndpoint, handler) { }
protected internal sealed override Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) { if (request == null) { throw new ArgumentNullException(nameof(request), SR.net_http_handler_norequest); } // ProcessRequest() and ProcessResponse() are supposed to be fast, so we call ProcessRequest() on the same // thread SendAsync() was invoked to avoid context switches. However, if ProcessRequest() throws, we have // to catch the exception since the caller doesn't expect exceptions when calling SendAsync(): The // expectation is that the returned task will get faulted on errors, but the async call to SendAsync() // should complete. var tcs = new SendState(this, cancellationToken); try { HttpRequestMessage newRequestMessage = ProcessRequest(request, cancellationToken); Task <HttpResponseMessage> sendAsyncTask = base.SendAsync(newRequestMessage, cancellationToken); // We schedule a continuation task once the inner handler completes in order to trigger the response // processing method. ProcessResponse() is only called if the task wasn't canceled before. sendAsyncTask.ContinueWithStandard(tcs, (task, state) => { var sendState = (SendState)state; MessageProcessingHandler self = sendState._handler; CancellationToken token = sendState._token; if (task.IsFaulted) { sendState.TrySetException(task.Exception.GetBaseException()); return; } if (task.IsCanceled) { sendState.TrySetCanceled(); return; } if (task.Result == null) { sendState.TrySetException(ExceptionDispatchInfo.SetCurrentStackTrace(new InvalidOperationException(SR.net_http_handler_noresponse))); return; } try { HttpResponseMessage responseMessage = self.ProcessResponse(task.Result, token); sendState.TrySetResult(responseMessage); } catch (OperationCanceledException e) { // If ProcessResponse() throws an OperationCanceledException check whether it is related to // the cancellation token we received from the user. If so, cancel the Task. HandleCanceledOperations(token, sendState, e); } catch (Exception e) { sendState.TrySetException(e); } // We don't pass the cancellation token to the continuation task, since we want to get called even // if the operation was canceled: We'll set the Task returned to the user to canceled. Passing the // cancellation token here would result in the continuation task to not be called at all. I.e. we // would never complete the task returned to the caller of SendAsync(). }); } catch (OperationCanceledException e) { HandleCanceledOperations(cancellationToken, tcs, e); } catch (Exception e) { tcs.TrySetException(e); } return(tcs.Task); }
public CustomerServiceClient(Uri adminBaseEndpoint, MessageProcessingHandler handler) : base(adminBaseEndpoint, handler) { }
/// <summary> /// This constructor takes BearerMessageProcessingHandler which reads token as attach to each request /// </summary> /// <param name="baseEndpoint"></param> /// <param name="handler"></param> public HybridCloudAdminClient(Uri baseEndpoint, MessageProcessingHandler handler) : base(baseEndpoint, handler) { }
public DynamicPropertyServiceClient(Uri adminBaseEndpoint, MessageProcessingHandler handler) : base(adminBaseEndpoint, handler) { }
/// <summary> /// Initializes a new instance of the AdminManagementClient class. /// </summary> /// <param name="adminBaseEndpoint">Admin endpoint</param> /// <param name="token">Access token</param> public AdminManagementClient(Uri adminBaseEndpoint, MessageProcessingHandler handler) : base(adminBaseEndpoint, ManagementClientMediaType.Xml, handler) { }