void PrepareRequest(Message message) { RequestReplyCorrelator.PrepareRequest(message); if (this.requiresManualReplyAddressing) { if (this.localAddress != null) { message.Headers.ReplyTo = this.LocalAddress; } else { message.Headers.ReplyTo = EndpointAddress.AnonymousAddress; } } if (this.webHeaderCollection != null && this.webHeaderCollection.Count > 0) { object prop = null; HttpRequestMessageProperty rmp = null; if (message.Properties.TryGetValue(HttpRequestMessageProperty.Name, out prop)) { rmp = prop as HttpRequestMessageProperty; } else { rmp = new HttpRequestMessageProperty(); message.Properties.Add(HttpRequestMessageProperty.Name, rmp); } if (rmp != null && rmp.Headers != null) { rmp.Headers.Add(this.webHeaderCollection); } } }
private void PrepareRequest(Message nextMessage, RequestSecurityToken rst) { if ((rst != null) && !rst.IsReadOnly) { rst.Message = nextMessage; } RequestReplyCorrelator.PrepareRequest(nextMessage); if (this.RequiresManualReplyAddressing) { nextMessage.Headers.ReplyTo = EndpointAddress.AnonymousAddress; } }
void PrepareRequest(Message nextMessage, RequestSecurityToken rst) { if (rst != null && !rst.IsReadOnly) { rst.Message = nextMessage; } RequestReplyCorrelator.PrepareRequest(nextMessage); if (this.RequiresManualReplyAddressing) { // if we are on HTTP, we need to explicitly add a reply-to header for interop nextMessage.Headers.ReplyTo = EndpointAddress.AnonymousAddress; } }
public async Task <Message> RequestAsync(Message message, CancellationToken token) { RequestReplyCorrelator.PrepareRequest(message); AsyncDuplexRequest duplexRequest = new AsyncDuplexRequest(this); lock (ThisLock) { RequestStarting(message, duplexRequest); } await _channel.SendAsync(message, token); return(await duplexRequest.WaitForReplyAsync(token)); }
private void PrepareRequest(Message message) { RequestReplyCorrelator.PrepareRequest(message); if (this.requiresManualReplyAddressing) { if (this.localAddress != null) { message.Headers.ReplyTo = this.LocalAddress; } else { message.Headers.ReplyTo = EndpointAddress.AnonymousAddress; } } }
public IAsyncResult BeginRequest(Message message, TimeSpan timeout, AsyncCallback callback, object state) { IAsyncResult result2; bool flag = false; AsyncDuplexRequest request = null; try { RequestReplyCorrelator.PrepareRequest(message); request = new AsyncDuplexRequest(message, this, timeout, callback, state); lock (this.ThisLock) { this.RequestStarting(message, request); } IAsyncResult sendResult = this.channel.BeginSend(message, timeout, Fx.ThunkCallback(new AsyncCallback(this.SendCallback)), request); if (sendResult.CompletedSynchronously) { request.FinishedSend(sendResult, true); } this.EnsurePumping(); flag = true; result2 = request; } finally { lock (this.ThisLock) { if (flag) { request.EnableCompletion(); } else { this.RequestCompleting(request); } } } return(result2); }
public async Task <Message> RequestAsync(Message message, CancellationToken token) { AsyncDuplexRequest duplexRequest = null; bool optimized = false; RequestReplyCorrelator.PrepareRequest(message); lock (ThisLock) { if (!Pumping) { optimized = true; syncPumpEnabled = true; } if (!optimized) { duplexRequest = new AsyncDuplexRequest(this); } RequestStarting(message, duplexRequest); } if (optimized) { UniqueId messageId = message.Headers.MessageId; try { await channel.SendAsync(message, token); //if (DiagnosticUtility.ShouldUseActivity && // ServiceModelActivity.Current != null && // ServiceModelActivity.Current.ActivityType == ActivityType.ProcessAction) //{ // ServiceModelActivity.Current.Suspend(); //} for (;;) { var result = await channel.TryReceiveAsync(token); if (!result.Success) { // TODO: Derive CancellationToken to attach timeout throw TraceUtility.ThrowHelperError(GetReceiveTimeoutException(TimeSpan.Zero), message); } if (result.Result == null) { AbortRequests(); return(null); } if (result.Result.Headers.RelatesTo == messageId) { ThrowIfInvalidReplyIdentity(result.Result); return(result.Result); } else if (!HandleRequestAsReply(result.Result)) { // SFx drops a message here //if (DiagnosticUtility.ShouldTraceInformation) //{ // EndpointDispatcher dispatcher = null; // if (this.ChannelHandler != null && this.ChannelHandler.Channel != null) // { // dispatcher = this.ChannelHandler.Channel.EndpointDispatcher; // } // TraceUtility.TraceDroppedMessage(reply, dispatcher); //} result.Result.Close(); } } } finally { lock (ThisLock) { RequestCompleting(null); syncPumpEnabled = false; if (pending > 0) { EnsurePumping(); } } } } else { await channel.SendAsync(message, token); EnsurePumping(); return(await duplexRequest.WaitForReplyAsync(token)); } }
public Message Request(Message message, TimeSpan timeout) { SyncDuplexRequest request = null; bool flag = false; RequestReplyCorrelator.PrepareRequest(message); lock (this.ThisLock) { if (!this.Pumping) { flag = true; this.syncPumpEnabled = true; } if (!flag) { request = new SyncDuplexRequest(this); } this.RequestStarting(message, request); } if (flag) { TimeoutHelper helper = new TimeoutHelper(timeout); UniqueId messageId = message.Headers.MessageId; try { this.channel.Send(message, helper.RemainingTime()); if ((DiagnosticUtility.ShouldUseActivity && (ServiceModelActivity.Current != null)) && (ServiceModelActivity.Current.ActivityType == ActivityType.ProcessAction)) { ServiceModelActivity.Current.Suspend(); } while (true) { Message message2; TimeSpan span = helper.RemainingTime(); if (!this.channel.TryReceive(span, out message2)) { throw TraceUtility.ThrowHelperError(this.GetReceiveTimeoutException(timeout), message); } if (message2 == null) { this.AbortRequests(); return(null); } if (message2.Headers.RelatesTo == messageId) { this.ThrowIfInvalidReplyIdentity(message2); return(message2); } if (!this.HandleRequestAsReply(message2)) { if (DiagnosticUtility.ShouldTraceInformation) { EndpointDispatcher endpointDispatcher = null; if ((this.ChannelHandler != null) && (this.ChannelHandler.Channel != null)) { endpointDispatcher = this.ChannelHandler.Channel.EndpointDispatcher; } TraceUtility.TraceDroppedMessage(message2, endpointDispatcher); } message2.Close(); } } } finally { lock (this.ThisLock) { this.RequestCompleting(null); this.syncPumpEnabled = false; if (this.pending > 0) { this.EnsurePumping(); } } } } TimeoutHelper helper2 = new TimeoutHelper(timeout); this.channel.Send(message, helper2.RemainingTime()); this.EnsurePumping(); return(request.WaitForReply(helper2.RemainingTime())); }