public void AsyncProcessRequest(IClientChannelSinkStack sinkStack, IMessage msg, ITransportHeaders requestHeaders, Stream requestStream)
{
// add message Uri to headers
var mcm = (IMethodCallMessage)msg;
requestHeaders[CommonTransportKeys.RequestUri] = mcm.Uri;
// send data (FIXME: 1) add reliability, 2) handle exceptions)
var transport = new UdpTransport(UdpClient);
transport.Write(requestHeaders, requestStream, ServerEndpoint);
// if the call is not one-way, schedule an async call
if (!RemotingServices.IsOneWay(mcm.MethodBase))
{
ThreadPool.QueueUserWorkItem((s) =>
{
try
{
ITransportHeaders responseHeaders;
Stream responseStream;
IPEndPoint remote;
transport.Read(out responseHeaders, out responseStream, out remote);
sinkStack.AsyncProcessResponse(responseHeaders, responseStream);
}
catch (Exception ex)
{
sinkStack.DispatchException(ex);
}
});
}
}
/// <summary>
/// Processes an asynchronous request.
/// </summary>
/// <param name="sinkStack">Channel sink stack</param>
/// <param name="msg">Message to processed</param>
/// <param name="headers">Transport headers</param>
/// <param name="stream">Request stream</param>
public void AsyncProcessRequest(IClientChannelSinkStack sinkStack, IMessage msg, ITransportHeaders headers, Stream stream)
{
stream = CreateEnvelope(stream, headers);
sinkStack.Push(this, null);
_nextSink.AsyncProcessRequest(sinkStack, msg, headers, stream);
}
public void AsyncProcessRequest(IClientChannelSinkStack sinkStack, IMessage msg,
ITransportHeaders headers, Stream stream)
{
// перенаправляем вызов следующему приемнику в стеке
sinkStack.Push(this, null);
_nextSink.AsyncProcessRequest(sinkStack, msg, headers, stream);
}
public void AsyncProcessRequest(IClientChannelSinkStack sinkStack, IMessage msg,
ITransportHeaders headers, Stream stream)
{
// never gets called, this sink is always first
sinkStack.Push(this, null);
_nextSink.AsyncProcessRequest(sinkStack, msg, headers, stream);
}
public void AsyncProcessRequest(
IClientChannelSinkStack sinkStack_in,
IMessage msg_in,
ITransportHeaders headers_in,
Stream stream_in
) {
#region encrypt...
headers_in[EncryptionHelper.X_ENCRYPT] = "1";
headers_in[EncryptionHelper.X_CLIENTID] = this.clientid_;
stream_in
= EncryptionHelper.Encrypt(
stream_in,
false,
this.keyspath_,
this.clientid_
);
#endregion
sinkStack_in.Push(this, null);
this.nextchannelsink_.AsyncProcessRequest(
sinkStack_in,
msg_in,
headers_in,
stream_in
);
}
public void AsyncProcessRequest (IClientChannelSinkStack sinkStack, IMessage msg,
ITransportHeaders headers, Stream requestStream)
{
TcpConnection connection = null;
bool isOneWay = RemotingServices.IsOneWay (((IMethodMessage)msg).MethodBase);
try
{
if (headers == null) headers = new TransportHeaders();
headers [CommonTransportKeys.RequestUri] = ((IMethodMessage)msg).Uri;
// Sends the stream using a connection from the pool
// and creates a WorkItem that will wait for the
// response of the server
connection = TcpConnectionPool.GetConnection (_host, _port);
TcpMessageIO.SendMessageStream (connection.Stream, requestStream, headers, connection.Buffer);
connection.Stream.Flush ();
if (!isOneWay)
{
sinkStack.Push (this, connection);
ThreadPool.QueueUserWorkItem (new WaitCallback(ReadAsyncTcpMessage), sinkStack);
}
else
connection.Release();
}
catch
{
if (connection != null) connection.Release();
if (!isOneWay) throw;
}
}
public void AsyncProcessRequest(IClientChannelSinkStack sinkStack, IMessage msg, ITransportHeaders headers, Stream requestStream)
{
ITransportHeaders headers2;
Stream stream;
AsyncCallback callback = new AsyncCallback(this.AsyncFinishedCallback);
new AsyncMessageDelegate(this.AsyncProcessMessage).BeginInvoke(msg, headers, requestStream, out headers2, out stream, sinkStack, callback, null);
}
public void AsyncProcessRequest (IClientChannelSinkStack sinkStack,
IMessage msg,
ITransportHeaders headers,
Stream stream)
{
// should never be called; we're a message transport
throw new NotSupportedException();
}
public void AsyncProcessRequest(
IClientChannelSinkStack sinkStack,
IMessage msg,
ITransportHeaders headers,
Stream stream)
{
throw new Exception("not implemented");
}
public void AsyncProcessRequest (IClientChannelSinkStack sinkStack,
IMessage msg,
ITransportHeaders headers,
Stream stream)
{
AsyncSendMessageStreamDelegate asmd = new AsyncSendMessageStreamDelegate (AsyncSendMessageStream);
asmd.BeginInvoke (sinkStack, msg, headers, stream, null, null);
}
public void AsyncProcessRequest (IClientChannelSinkStack sinkStack,
IMessage msg,
ITransportHeaders headers,
Stream stream)
{
// never called because the formatter sink is
// always the first in the chain
throw new NotSupportedException("BinaryClientFormatterSink must be the first sink in the IClientChannelSink chain");
}
public void AsyncProcessRequest(IClientChannelSinkStack sinkStack, IMessage msg, ITransportHeaders headers, Stream stream)
{
if (stream.Length > int.MaxValue)
throw new NotImplementedException("TcpEx Channel can only accept messages up to int.MaxValue in size."); // TODO: FixMe
Connection connection = PrepareRequest(msg, ref headers);
Guid msgGuid = Guid.NewGuid();
Manager.BeginReadMessage(msgGuid, connection, new AsyncCallback(ProcessResponse), sinkStack);
Message.Send(connection, msgGuid, headers, stream);
}
public void AsyncProcessRequest(
IClientChannelSinkStack sinkStack,
IMessage msg,
ITransportHeaders headers,
Stream stream)
{
// Push this onto the sink stack.
sinkStack.Push(this, null);
// Send the request to the client.
_next.AsyncProcessRequest(sinkStack, msg, headers, stream);
}
void IClientChannelSink.AsyncProcessRequest(IClientChannelSinkStack sinkStack,
IMessage msg, ITransportHeaders headers, Stream stream)
{
// process request
object state = null;
ProcessRequest(msg, headers, ref stream, ref state);
// push to stack (to get a call to handle response)
// and forward to the next
sinkStack.Push(this, state);
this.nextClientChannelSink.AsyncProcessRequest(sinkStack, msg, headers, stream);
}
public void AsyncProcessRequest(IClientChannelSinkStack sinkStack, IMessage msg, ITransportHeaders headers, Stream stream)
{
TcpClientSocketHandler handler = this.SendRequestWithRetry(msg, headers, stream);
if (handler.OneWayRequest)
{
handler.ReturnToCache();
}
else
{
handler.DataArrivedCallback = new WaitCallback(this.ReceiveCallback);
handler.DataArrivedCallbackState = sinkStack;
handler.BeginReadMessage();
}
}
public void AsyncProcessRequest (IClientChannelSinkStack sinkStack, IMessage msg,
ITransportHeaders headers, Stream requestStream)
{
bool isOneWay = RemotingServices.IsOneWay (((IMethodMessage)msg).MethodBase);
HttpWebRequest request = CreateRequest (headers);
using (Stream targetStream = request.GetRequestStream ()) {
CopyStream (requestStream, targetStream, 1024);
}
if (!isOneWay) {
sinkStack.Push (this, request);
request.BeginGetResponse (new AsyncCallback (AsyncProcessResponseCallback), sinkStack);
}
}
/// <summary>
/// Verarbeitet eine Anfragenachricht asynchron.
/// </summary>
/// <param name="sinkStack">Senkenstapel</param>
/// <param name="msg">Remoting-Nachricht</param>
/// <param name="headers">Anfrage-Header-Auflistung</param>
/// <param name="stream">Anfrage-Datenstrom</param>
public void AsyncProcessRequest(IClientChannelSinkStack sinkStack, IMessage msg, ITransportHeaders headers, Stream stream)
{
// Asynchroner Verarbeitungsstatus
AsyncProcessingState state = null;
lock (_lockObject)
{
// Asynchronen Verarbeitungsstatus erzeugen
state = new AsyncProcessingState(msg, headers, ref stream, new Guid());
//Methode aufrufen die Verarbeitung übernimmt
DoProcessMessageBefore(msg, headers, stream);
}
// Aktuelle Senke auf den Senkenstapel legen (Damit ggf. die Verarbeitung der Antwort später asynchron aufgerufen werden kann)
sinkStack.Push(this, state);
// Nächste Kanalsenke aufrufen
_next.AsyncProcessRequest(sinkStack, msg, headers, stream);
}
public void AsyncProcessRequest(
IClientChannelSinkStack sinkStack_in,
IMessage msg_in,
ITransportHeaders headers_in,
Stream stream_in
) {
#region compress...
headers_in[CompressionHelper.X_COMPRESS] = "1";
stream_in
= CompressionHelper.GetCompressedStreamCopy(
stream_in
);
#endregion
sinkStack_in.Push(this, null);
this.nextchannelsink_.AsyncProcessRequest(
sinkStack_in,
msg_in,
headers_in,
stream_in
);
}
public void AsyncProcessRequest(IClientChannelSinkStack sinkStack, IMessage msg, ITransportHeaders headers, Stream stream)
{
Stream compStream;
Stream origStream = stream;
long origPos = stream.Position;
if ((checkedCompress && serverCanCompress) || (!checkedCompress && assumeCompress)) {
headers[CompressionHelper.CompressKey] = CompressionHelper.CompressedFlag;
compStream = CompressionHelper.CompressStream(stream);
sinkStack.Push(this, new RequestState(origStream, origPos, true, msg, headers));
}
else {
headers[CompressionHelper.CompressKey] = CompressionHelper.CompressRequest;
compStream = stream;
sinkStack.Push(this, null);
}
try {
_next.AsyncProcessRequest(sinkStack, msg, headers, compStream);
}
catch (Exception) {
}
}
void IClientChannelSink.AsyncProcessRequest(IClientChannelSinkStack sinkStack, System.Runtime.Remoting.Messaging.IMessage msg, ITransportHeaders headers, System.IO.Stream stream)
{
nextSink.AsyncProcessRequest(sinkStack, msg, headers, stream);
}
public void AsyncProcessRequest(IClientChannelSinkStack sinkStack, IMessage msgReq, ITransportHeaders headers, Stream stream)
{
// scope state
string strQueuePath = null;
string strObjectUri = null;
Message outMsg = null;
MessageQueueTransaction mqtx = new MessageQueueTransaction();
try
{
#region pre-processor (mapping url address)
// split into the queuepath and endpoint
strObjectUri = ParseLogicalUrl(m_LogicalUri, out strQueuePath);
// update Uri property
msgReq.Properties[MSMQChannelProperties.ObjectUri] = strObjectUri;
// pass TransportHeaders to the receiver
if(m_Sender.AllowHeaders == true)
{
headers["__RequestUri"] = strObjectUri;
msgReq.Properties["__RequestHeaders"] = headers;
}
#endregion
#region send a remoting message
// set the destination queue
m_OutQueue.Path = strQueuePath;
// create a message
outMsg = new Message(msgReq, new BinaryMessageFormatter());
// option: timeout to pick-up a message (receive message)
int intTimeToBeReceived = m_Sender.TimeToBeReceived;
if(intTimeToBeReceived > 0)
outMsg.TimeToBeReceived = TimeSpan.FromSeconds(intTimeToBeReceived);
// option: timeout to reach destination queue (send message)
int intTimeToReachQueue = m_Sender.TimeToReachQueue;
if(intTimeToReachQueue > 0)
outMsg.TimeToReachQueue = TimeSpan.FromSeconds(intTimeToReachQueue);
// option: notify a negative receive on the client/server side
if(m_Sender.AdminQueuePath != MSMQChannelDefaults.EmptyStr)
{
// acknowledge type (mandatory)
outMsg.AcknowledgeType = AcknowledgeTypes.NegativeReceive | AcknowledgeTypes.NotAcknowledgeReachQueue;
// admin queue for a time-expired messages
outMsg.AdministrationQueue = m_Sender.AdminQueue;
}
// message label
string label = string.Format("{0}/{1}, url={2}", Convert.ToString(msgReq.Properties["__TypeName"]).Split(',')[0],
Convert.ToString(msgReq.Properties["__MethodName"]), strObjectUri);
//// Send message based on the transaction context
//if(ContextUtil.IsInTransaction == true)
//{
// // we are already in the transaction - automatic (DTC) transactional message
// m_OutQueue.Send(outMsg, label, MessageQueueTransactionType.Automatic);
//}
//else
//{
// this is a single transactional message
mqtx.Begin();
m_OutQueue.Send(outMsg, label, mqtx);
mqtx.Commit();
//}
#endregion
}
catch(Exception ex)
{
string strError = string.Format("[{0}]MSMQClientTransportSink.AsyncProcessRequest error = {1}, queuepath={2},",
m_Sender.ChannelName, ex.Message, strQueuePath);
m_Sender.WriteLogMsg(strError, EventLogEntryType.Error);
throw new Exception(strError);
}
finally
{
#region clean-up
if(mqtx.Status == MessageQueueTransactionStatus.Pending)
{
mqtx.Abort();
Trace.WriteLine(string.Format("[{0}]MSMQClientTransportSink.AsyncProcessRequest Aborted, msgId = {1}", m_Sender.ChannelName, outMsg.Id));
}
if(outMsg != null)
outMsg.Dispose();
#endregion
}
}
} // ProcessMessage
public void AsyncProcessRequest(IClientChannelSinkStack sinkStack, IMessage msg,
ITransportHeaders headers, Stream stream)
{
InternalRemotingServices.RemotingTrace("TcpClientTransportSink::AsyncProcessRequest");
TcpClientSocketHandler clientSocket =
SendRequestWithRetry(msg, headers, stream);
if (clientSocket.OneWayRequest)
{
clientSocket.ReturnToCache();
}
else
{
// do an async read on the reply
clientSocket.DataArrivedCallback = new WaitCallback(this.ReceiveCallback);
clientSocket.DataArrivedCallbackState = sinkStack;
clientSocket.BeginReadMessage();
}
} // AsyncProcessRequest
public void AsyncProcessRequest(IClientChannelSinkStack sinkStack, IMessage msg,
ITransportHeaders headers, Stream stream)
{
throw new NotImplementedException();
}
public void AsyncProcessRequest(IClientChannelSinkStack sinkStack, IMessage msg,
ITransportHeaders headers, Stream requestStream)
{
InternalRemotingServices.RemotingTrace("IpcClientTransportSink::AsyncProcessRequest");
ITransportHeaders responseHeaders;
Stream responseStream;
// Invoke ProcessMessage asynchronously. This should be improved
// by using Datagram message
AsyncCallback callback = new AsyncCallback(this.AsyncFinishedCallback);
AsyncMessageDelegate async = new AsyncMessageDelegate(this.AsyncProcessMessage);
async.BeginInvoke(msg, headers, requestStream , out responseHeaders,
out responseStream, sinkStack, callback, null);
} // AsyncProcessRequest
internal AsyncHttpClientRequestState(
HttpClientTransportSink transportSink,
IClientChannelSinkStack sinkStack,
IMessage msg,
ITransportHeaders headers,
Stream stream,
int retryCount)
{
_transportSink = transportSink;
SinkStack = sinkStack;
_msg = msg;
_requestHeaders = headers;
RequestStream = stream;
_retryCount = retryCount;
if (RequestStream.CanSeek)
_initialStreamPosition = RequestStream.Position;
} // AsyncHttpClientRequestState
public void AsyncProcessRequest(IClientChannelSinkStack sinkStack, IMessage msg, ITransportHeaders headers, Stream stream)
{
this.nextSink.AsyncProcessRequest(sinkStack, msg, headers, stream);
}
/// <summary>
/// Requests asynchronous processing of a method call on the current sink.
/// </summary>
/// <param name="sinkStack">A stack of channel sinks that called this sink.</param>
/// <param name="msg">The message to process.</param>
/// <param name="headers">The headers to add to the outgoing message heading to the server.</param>
/// <param name="stream">The stream headed to the transport sink.</param>
public void AsyncProcessRequest(IClientChannelSinkStack sinkStack, IMessage msg,
ITransportHeaders headers, Stream stream)
{
ITransportContext iTransportContext = this.ITransportContext;
if (!GenuineUtility.CheckUrlOnConnectivity(this._recipientUri))
{
// get the transport context from the Uri Storage
iTransportContext = UriStorage.GetTransportContext(this._recipientUri);
if (iTransportContext == null)
{
iTransportContext = this.ITransportContext;
}
}
Message message = Message.CreateOutcomingMessage(iTransportContext, msg, headers, stream, false);
message.Recipient = iTransportContext.KnownHosts[this._recipientUri];
IMethodMessage iMethodMessage = (IMethodMessage)msg;
message.IsOneWay = RemotingServices.IsOneWay(iMethodMessage.MethodBase);
// LOG: put down the log record
BinaryLogWriter binaryLogWriter = this.ITransportContext.BinaryLogWriter;
if (binaryLogWriter != null && binaryLogWriter[LogCategory.MessageProcessing] > 0)
{
binaryLogWriter.WriteMessageCreatedEvent("GenuineTcpClientTransportSink.AsyncProcessRequest",
LogMessageType.MessageCreated, null, message, true, message.Recipient,
this.ITransportContext.BinaryLogWriter[LogCategory.MessageProcessing] > 1 ? message.Stream : null,
msg.Properties["__Uri"] as string, BinaryLogWriter.ParseInvocationMethod(msg.Properties["__MethodName"] as string, msg.Properties["__TypeName"] as string),
GenuineUtility.CurrentThreadId, Thread.CurrentThread.Name, null, -1, -1, null, -1, null,
"Asynchronous .NET Remoting invocaiton is being initiated.");
message.ITransportHeaders[Message.TransportHeadersInvocationTarget] = msg.Properties["__Uri"] as string;
message.ITransportHeaders[Message.TransportHeadersMethodName] = BinaryLogWriter.ParseInvocationMethod(msg.Properties["__MethodName"] as string, msg.Properties["__TypeName"] as string);
binaryLogWriter.WriteEvent(LogCategory.MessageProcessing, "GenuineTcpClientTransportSink.AsyncProcessRequest",
LogMessageType.MessageRequestInvoking, null, message, message.Recipient,
null,
GenuineUtility.CurrentThreadId, Thread.CurrentThread.Name,
null, null, -1,
GenuineUtility.TickCount, 0, 0, null, null, null, null,
"The .NET Remoting asynchronous invocation is being initiated.");
}
// register the response handler
AsyncSinkStackResponseProcessor asyncSinkStackResponseProcessor = null;
if (!message.IsOneWay)
{
asyncSinkStackResponseProcessor = new AsyncSinkStackResponseProcessor(iTransportContext, message, sinkStack);
iTransportContext.IIncomingStreamHandler.RegisterResponseProcessor(message.MessageId, asyncSinkStackResponseProcessor);
}
try
{
// and try to send the message
iTransportContext.ConnectionManager.Send(message);
}
catch (Exception ex)
{
asyncSinkStackResponseProcessor.DispatchException(ex);
throw;
}
}
public void AsyncProcessRequest(IClientChannelSinkStack sinkStack, IMessage msg, ITransportHeaders headers, Stream stream)
{
headers[CommonTransportKeys.RequestUri] = ((IMethodCallMessage)msg).Uri;
// connect
NamedPipeClient client = new NamedPipeClient(pipeName);
NamedPipeSocket socket = client.Connect();
IpcTransport t = new IpcTransport(socket);
t.Write(headers, stream);
// schedule an async call
if (!RemotingServices.IsOneWay(((IMethodCallMessage)msg).MethodBase))
{
new AsyncResponse(AsyncHandler).BeginInvoke(sinkStack, t, null, null);
}
}
void IClientChannelSink.AsyncProcessRequest(IClientChannelSinkStack sinkStack, IMessage msg, ITransportHeaders headers, System.IO.Stream stream)
{
nextSink.AsyncProcessRequest(sinkStack, msg, headers, stream);
}
} // ProcessMessage
public void AsyncProcessRequest(IClientChannelSinkStack sinkStack, IMessage msg,
ITransportHeaders headers, Stream stream)
{
// Send the webrequest, headers, request stream, and retry count.
AsyncHttpClientRequestState asyncRequestState =
new AsyncHttpClientRequestState(this, sinkStack, msg, headers, stream, 1);
asyncRequestState.StartRequest();
} // AsyncProcessRequest
public void AsyncProcessRequest(IClientChannelSinkStack sinkStack, IMessage msg,
ITransportHeaders headers, Stream stream1)
{
sinkStack.Push(this, null);
nextSink1.AsyncProcessRequest(sinkStack, msg, headers, stream1);
}
} // ProcessMessage
private IClientChannelSinkStack AsyncProcessMessage(IMessage msg,
ITransportHeaders requestHeaders, Stream requestStream,
out ITransportHeaders responseHeaders, out Stream responseStream,
IClientChannelSinkStack sinkStack)
{
ProcessMessage(msg, requestHeaders, requestStream, out responseHeaders, out responseStream);
return sinkStack;
}
/// <summary>
/// Initializes an instance of the AsyncSinkStackResponseProcessor class.
/// </summary>
/// <param name="iTransportContext">The Transport Context.</param>
/// <param name="message">Source message.</param>
/// <param name="iClientChannelSinkStack">The client channel sink stack.</param>
public AsyncSinkStackResponseProcessor(ITransportContext iTransportContext, Message message, IClientChannelSinkStack iClientChannelSinkStack)
{
this._iTransportContext = iTransportContext;
this._message = message;
this._iClientChannelSinkStack = iClientChannelSinkStack;
}
public void AsyncProcessRequest(IClientChannelSinkStack sinkStack, IMessage requestMsg, ITransportHeaders requestHeaders, Stream requestStream)
{
// UNDONE:
throw new NotImplementedException();
}
public void AsyncProcessRequest(IClientChannelSinkStack myClientChannelSinkStack, IMessage msg,
ITransportHeaders headers, Stream stream)
{
}
internal AsyncResponseHandler(IClientChannelSinkStack sinkStack)
{
_sinkStack = sinkStack;
}
} // ProcessMessage
/// <include file='doc\BinaryFormatterSinks.uex' path='docs/doc[@for="BinaryClientFormatterSink.AsyncProcessRequest"]/*' />
public void AsyncProcessRequest(IClientChannelSinkStack sinkStack, IMessage msg,
ITransportHeaders headers, Stream stream)
{
// should never be called, this sink is always first
throw new NotSupportedException();
} // AsyncProcessRequest
void AsyncHandler(IClientChannelSinkStack sinkStack, IpcTransport transport)
{
try
{
// get the response headers and the response stream from the server
ITransportHeaders responseHeaders;
Stream responseStream;
transport.Read(out responseHeaders, out responseStream);
transport.Close();
sinkStack.AsyncProcessResponse(responseHeaders, responseStream);
}
catch (Exception ex)
{
sinkStack.DispatchException(ex);
}
}
public void AsyncProcessRequest(IClientChannelSinkStack sinkStack, IMessage msgReq, ITransportHeaders headers, Stream stream)
{
// scope state
string strQueuePath = null;
string strObjectUri = null;
Message outMsg = null;
MessageQueueTransaction mqtx = new MessageQueueTransaction();
try
{
#region pre-processor (mapping url address)
// split into the queuepath and endpoint
strObjectUri = ParseLogicalUrl(m_LogicalUri, out strQueuePath);
// update Uri property
msgReq.Properties[MSMQChannelProperties.ObjectUri] = strObjectUri;
// pass TransportHeaders to the receiver
if (m_Sender.AllowHeaders == true)
{
headers["__RequestUri"] = strObjectUri;
msgReq.Properties["__RequestHeaders"] = headers;
}
#endregion
#region send a remoting message
// set the destination queue
m_OutQueue.Path = strQueuePath;
// create a message
outMsg = new Message(msgReq, new BinaryMessageFormatter());
// option: timeout to pick-up a message (receive message)
int intTimeToBeReceived = m_Sender.TimeToBeReceived;
if (intTimeToBeReceived > 0)
{
outMsg.TimeToBeReceived = TimeSpan.FromSeconds(intTimeToBeReceived);
}
// option: timeout to reach destination queue (send message)
int intTimeToReachQueue = m_Sender.TimeToReachQueue;
if (intTimeToReachQueue > 0)
{
outMsg.TimeToReachQueue = TimeSpan.FromSeconds(intTimeToReachQueue);
}
// option: notify a negative receive on the client/server side
if (m_Sender.AdminQueuePath != MSMQChannelDefaults.EmptyStr)
{
// acknowledge type (mandatory)
outMsg.AcknowledgeType = AcknowledgeTypes.NegativeReceive | AcknowledgeTypes.NotAcknowledgeReachQueue;
// admin queue for a time-expired messages
outMsg.AdministrationQueue = m_Sender.AdminQueue;
}
// message label
string label = string.Format("{0}/{1}, url={2}", Convert.ToString(msgReq.Properties["__TypeName"]).Split(',')[0],
Convert.ToString(msgReq.Properties["__MethodName"]), strObjectUri);
//// Send message based on the transaction context
//if(ContextUtil.IsInTransaction == true)
//{
// // we are already in the transaction - automatic (DTC) transactional message
// m_OutQueue.Send(outMsg, label, MessageQueueTransactionType.Automatic);
//}
//else
//{
// this is a single transactional message
mqtx.Begin();
m_OutQueue.Send(outMsg, label, mqtx);
mqtx.Commit();
//}
#endregion
}
catch (Exception ex)
{
string strError = string.Format("[{0}]MSMQClientTransportSink.AsyncProcessRequest error = {1}, queuepath={2},",
m_Sender.ChannelName, ex.Message, strQueuePath);
m_Sender.WriteLogMsg(strError, EventLogEntryType.Error);
throw new Exception(strError);
}
finally
{
#region clean-up
if (mqtx.Status == MessageQueueTransactionStatus.Pending)
{
mqtx.Abort();
Trace.WriteLine(string.Format("[{0}]MSMQClientTransportSink.AsyncProcessRequest Aborted, msgId = {1}", m_Sender.ChannelName, outMsg.Id));
}
if (outMsg != null)
{
outMsg.Dispose();
}
#endregion
}
}
