public void FileReceiver_ReceivingCompletedEvent(ReceiveResult result, string message, string title)
{
if (result == ReceiveResult.Completed)
{
MessageBox.Show(message, title, MessageBoxButtons.OK, MessageBoxIcon.Information);
}
else if (result == ReceiveResult.FileIgnoredByUser)
{
MessageBox.Show(message, title, MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
else if (result == ReceiveResult.Cancelled)
{
MessageBox.Show(message, title, MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
else if (result == ReceiveResult.CannotReceived)
{
MessageBox.Show(message, title, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
progressBarReceiveFile.Value = 0;
btnReceiveFile.Text = Translator.GetStringFromResource("btnReceiveFile");
labelReceivedProgress.Text = string.Empty;
progressBarReceiveFile.Visible = false;
btnSelectSaveLocation.Enabled = true;
txtReceiveIpAdress.Enabled = true;
txtReceivePort.Enabled = true;
txtSaveLocation.Enabled = true;
}
private void CollectLocks(MsmqQueue lockQueue)
{
ReceiveResult result = ReceiveResult.MessageReceived;
while (result == ReceiveResult.MessageReceived)
{
using (MsmqMessageLookupId message = new MsmqMessageLookupId())
{
try
{
result = lockQueue.TryPeek(message, TimeSpan.FromSeconds(0));
if (result == ReceiveResult.MessageReceived)
{
lockQueue.TryMoveMessage(message.lookupId.Value, this.mainQueueForMove, MsmqTransactionMode.None);
}
}
catch (MsmqException ex)
{
// we will retry the collection in the next cleanup round
MsmqDiagnostics.ExpectedException(ex);
result = ReceiveResult.Unknown;
}
}
}
}
public override IResult Execute()
{
#region Code for sending command to remote system
PacketElements CommandPacketElems = new PacketElements();
CommandPacketElems.ActualCommand = Command;
long HeaderValue = long.Parse(ConfigurationSettings.AppSettings["CommandHeader"]);
CommandPacketElems.Header = HeaderValue;
PackCommand CommandPckt = new PackCommand();
CommandPckt.PacketElements = CommandPacketElems;
TransmitCommand SendCmd = new TransmitCommand();
SendCmd.DataPacket = CommandPckt.CommandPack;
SendCmd.RemoteSystemName = NetParams.RemoteSystemName;
SendCmd.SendCommand();
#endregion
#region Code for receiving result from remote system
ReceiveResult ReceiveData = new ReceiveResult();
ResultPacketElement ResultElements = ReceiveData.GetResultPacket();
IResult Result = new ExecutionResult();
if (ResultElements.Header == int.Parse(ConfigurationSettings.AppSettings["ResultHeader"]))
{
Result = ResultElements.ActualResult;
}
else
{
throw(new ApplicationException("Corrupted Result"));
}
#endregion
return(Result);
}
private void Action(object obj)
{
var cancellationToken = (CancellationToken)obj;
while (!cancellationToken.IsCancellationRequested)
{
var result = new ReceiveResult();
try
{
using (var connection = new OracleConnection(this.ConnectionString))
{
using (var queue = new OracleAQQueue(this.workQueue, connection, OracleAQMessageType.Xml))
{
connection.Open();
this.SetupClientInfo(connection);
queue.Listen(null);
result = this.TryReceive(queue);
}
}
}
finally
{
if (result.Message != null)
{
this.endProcessMessage(result.Message, result.Exception);
}
}
this.circuitBreaker.Success();
}
}
private ReceiveResult TryReceive(OracleAQQueue queue)
{
var result = new ReceiveResult();
using (var ts = new TransactionScope(TransactionScopeOption.Required, this.transactionOptions))
{
queue.Connection.EnlistTransaction(Transaction.Current);
result.Message = this.Receive(queue);
try
{
if (result.Message == null || this.tryProcessMessage(result.Message))
{
// NOTE: We explicitly calling Dispose so that we force any exception to not bubble,
// eg Concurrency/Deadlock exception.
ts.Complete();
ts.Dispose();
}
}
catch (Exception ex)
{
result.Exception = ex;
}
return(result);
}
}
public void OnFinalResult(string result)
{
resultText.text = result;
// clickBttn();
if (this.modelkey.Equals("q"))
{
MyInteractionManager im = GameObject.Find("GameManager").GetComponent <MyInteractionManager> ();
bool correct = im.questionManager(this.question, result);
if (correct)
{
im.globalScore += 5;
Destroy(this.target);
}
return;
}
ReceiveResult r = new ReceiveResult();
r.setModel(this.modelkey);
r.setVoiceType(this.voiceType);
r.Start();
r.setAnswer(result);
//Button btn = GameObject.Find("apibtn").GetComponent<Button>();
//btn.onClick.Invoke();
r.active();
}
private void Update()
{
diceVelocity = rb.velocity;
if (rolled && rb.angularVelocity == Vector3.zero && rb.velocity == Vector3.zero)
{
Vector3 smallestAngleVector = new Vector3();
float smallestAngle = 180;
foreach (var vector in ListCrossVectors)
{
var rotation = transform.rotation;
var csna = rotation * vector;
var dg = Vector3.Angle(new Vector3(0, 1, 0), rotation * vector);
if (Vector3.Angle(new Vector3(0, 1, 0), rotation * vector) < smallestAngle)
{
smallestAngle = Vector3.Angle(new Vector3(0, 1, 0), rotation * vector);
smallestAngleVector = vector;
}
}
inactiveDuration += Time.deltaTime;
if (inactiveDuration > inactiveConfirmDelay)
{
rolled = false;
Debug.Log("Roll result: " + (ListCrossVectors.IndexOf(smallestAngleVector) + 1).ToString());
ReceiveResult.Invoke(this, ListCrossVectors.IndexOf(smallestAngleVector) + 1);
}
}
else
{
inactiveDuration = 0;
}
}
// This is only called when the scene loads.
void Start()
{
result = GameObject.Find("Main Camera").GetComponent <ReceiveResult>();
// Strictly for debugging to test a few words!
if (isDebug)
{
StartCoroutine(Process("fr", "en", "Bonsoir"));
}
}
/// <summary>
/// Consumes a message on a daemon thread using a blocking receive call
/// (traced with the <see cref="IIncomingMessageReceiveTracer"/> and <see cref="IIncomingMessageProcessTracer"/>)
/// The Dynatrace tag is transported along with the message
/// </summary>
public static void ConsumerDaemonExample()
{
string serverEndpoint = "messageserver.example.com:1234";
string topic = "my-topic";
IMessagingSystemInfo messagingSystemInfo = SampleApplication.OneAgentSdk
.CreateMessagingSystemInfo(MessageSystemVendor.KAFKA, topic, MessageDestinationType.TOPIC, ChannelType.TCP_IP, serverEndpoint);
IIncomingMessageReceiveTracer receiveTracer = SampleApplication.OneAgentSdk.TraceIncomingMessageReceive(messagingSystemInfo);
receiveTracer.Start();
try
{
// blocking call until message is available:
ReceiveResult receiveResult = MyMessagingSystem.ReceiveMessage();
Message message = receiveResult.Message;
IIncomingMessageProcessTracer processTracer = SampleApplication.OneAgentSdk.TraceIncomingMessageProcess(messagingSystemInfo);
// retrieve Dynatrace tag created using the outgoing message tracer to link both sides together:
if (message.Headers.ContainsKey(OneAgentSdkConstants.DYNATRACE_MESSAGE_PROPERTYNAME))
{
processTracer.SetDynatraceByteTag(message.Headers[OneAgentSdkConstants.DYNATRACE_MESSAGE_PROPERTYNAME]);
}
// start processing:
processTracer.Start();
processTracer.SetCorrelationId(message.CorrelationId); // optional
processTracer.SetVendorMessageId(receiveResult.VendorMessageId); // optional
try
{
ProcessMessage(message); // do the work ...
}
catch (Exception e)
{
processTracer.Error(e);
// handle or rethrow
throw e;
}
finally
{
processTracer.End();
}
}
catch (Exception e)
{
receiveTracer.Error(e);
// handle or rethrow
throw e;
}
finally
{
receiveTracer.End();
}
}
/// <summary>
///
/// </summary>
/// <exception cref="IOException"/>
/// <exception cref="SocketException"/>
//[DebuggerStepThrough]
public static Exception ToException(this ReceiveResult receiveResult)
{
if (receiveResult.SocketError != SocketError.Success)
{
return(new SocketException((int)receiveResult.SocketError));
}
else
{
return(new IOException("Unexpected connection closed during read."));
}
}
public void Shutdown()
{
ReceiveResult result = RequestAndReceive(new Request {
Kind = RequestKind.Shutdown
}, TimeSpan.FromSeconds(1));
if (result.Timeout)
{
Kill();
}
_process.Dispose();
}
public override bool Receive(int suggestedBufferLength, TimeSpan timeout, out ReceiveResult receiveResult)
{
if (m_RecvMemoryOwner == null)
{
m_RecvMemoryOwner = MemoryPool.Rent(suggestedBufferLength);
m_RecvSAEA.SetBuffer(m_RecvMemoryOwner.Memory);
m_RecvSAEA.RemoteEndPoint = s_AnyEndPoint;
var pending = false;
try
{
pending = Socket.ReceiveFromAsync(m_RecvSAEA);
}
catch (SocketException ex)
{
WrapAndThrowSocketException(ex);
}
if (pending && !m_RecvSAEA.Wait(timeout))
{
receiveResult = default;
return(false);
}
}
else
{
if (!m_RecvSAEA.Wait(timeout) == false)
{
receiveResult = default;
return(false);
}
}
try
{
CheckSocketError(m_RecvSAEA.SocketError);
var remoteEndPoint = m_RecvSAEA.RemoteEndPoint as IPEndPoint ?? throw new InvalidOperationException();
receiveResult = new(remoteEndPoint,
packetMemoryOwner : m_RecvMemoryOwner,
packetLength : m_RecvSAEA.BytesTransferred);
return(true);
}
finally
{
m_RecvMemoryOwner = null;
m_RecvSAEA.Reset();
}
}
private void ReceivingFileFinished(ReceiveResult result, string message, string title)
{
IsFileReceiving = false;
ElapsedTime.Stop();
ProgressChangedInvoker.Enabled = false;
totalReceived = 0;
fileSize = 0;
IsListening = false;
ReceivingCompletedEvent?.Invoke(this, new ReceivingCompletedEventArgs(result, message, title));
}
void OnCompletion(int error, bool completedSynchronously)
{
Exception completionException = null;
this.receiveResult = ReceiveResult.MessageReceived;
try
{
if (error != 0)
{
if (error == UnsafeNativeMethods.MQ_ERROR_IO_TIMEOUT)
{
this.receiveResult = ReceiveResult.Timeout;
}
else if (error == UnsafeNativeMethods.MQ_ERROR_OPERATION_CANCELLED)
{
this.receiveResult = ReceiveResult.OperationCancelled;
}
else
{
if (IsReceiveErrorDueToInsufficientBuffer(error))
{
this.message.Unpin();
message.GrowBuffers();
StartReceive(completedSynchronously);
return;
}
else if (IsErrorDueToStaleHandle(error))
{
this.msmqQueue.HandleIsStale(this.handle);
}
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MsmqException(SR.GetString(SR.MsmqReceiveError, MsmqError.GetErrorString(error)), error));
}
}
}
catch (Exception e)
{
if (e is NullReferenceException || e is SEHException)
{
throw;
}
completionException = e;
}
this.message.Unpin();
Complete(completedSynchronously, completionException);
}
public ActionResult <ReceiveResult> Receive([FromHeader] string requestToken)
{
var result = new ReceiveResult();
try
{
result.Addresses = _walletService.Receive(requestToken);
result.Message = "Valid receive addresses";
result.Success = true;
}
catch (Exception e)
{
result.Message = e.Message;
result.Success = false;
}
return(result);
}
public void FileReceiver_ListenCompletedEvent(ReceiveResult result)
{
if (result == ReceiveResult.RequestAccepted)
{
labelReceivedProgress.Text = Translator.GetStringFromResource("FileRequestHasCame");
}
else if (result == ReceiveResult.ListeningCancelled)
{
//Controller.FileReceiver = null;
btnReceiveFile.Text = Translator.GetStringFromResource("btnReceiveFile");
labelReceivedProgress.Text = Translator.GetStringFromResource("FileWaitingWasCancelled");
btnSelectSaveLocation.Enabled = true;
txtReceiveIpAdress.Enabled = true;
txtReceivePort.Enabled = true;
txtSaveLocation.Enabled = true;
}
}
public RunSeparatelyResults RunPair(ProgramPair pair, TimeSpan timeout)
{
ReceiveResult result =
RequestAndReceive(new Request
{
Kind = RequestKind.RunPair,
Pair = pair,
}, timeout);
if (result.Ended)
{
return(new RunSeparatelyResults(RunSeparatelyResultsKind.Crash, null, result.Stderr));
}
if (result.Timeout)
{
return(new RunSeparatelyResults(RunSeparatelyResultsKind.Timeout, null, null));
}
return(new RunSeparatelyResults(RunSeparatelyResultsKind.Success, result.Response.RunPairResult, null));
}
public int parsePacket(out uint remoteIpAddress, out ushort remotePort)
{
Thread.Yield();
int packetLength = 0;
remoteIpAddress = 0;
remotePort = 0;
ReceiveResult result = new ReceiveResult();
lock (_receivedPackets)
{
if (_receivedPackets.Count > 0)
{
result = _receivedPackets.Dequeue();
}
else
{
return(packetLength);
}
}
if (result.RemoteEndPoint != null)
{
var ep = result.RemoteEndPoint;
var bytes = ep.Address.GetAddressBytes();
remoteIpAddress = BitConverter.ToUInt32(bytes, 0);
remotePort = (ushort)ep.Port;
}
if (result.Buffer != null)
{
packetLength = result.Buffer.Length;
}
_receiveQueue.Clear();
_receiveQueue.Enqueue(result.Buffer, 0, packetLength);
return(packetLength);
}
private void handleClient(object obj)
{
try
{
var client = obj as UdpClient;
int count;
while (_treadActive)
{
if (client.Available > 0)
{
// int length = buffer.Length - _receiveQueue.Length;
IPEndPoint remoteEP = new IPEndPoint(IPAddress.Any, 0);
byte[] buffer = client.Receive(ref remoteEP);
count = buffer.Length;
if (count > 0)
{
ReceiveResult result = new ReceiveResult(buffer, remoteEP);
lock (_receivedPackets)
{
_receivedPackets.Enqueue(result);
}
}
}
// prevent high CPU usage
Thread.Sleep(10);
}
}
catch (Exception e)
{
setExceptionMessage(e);
}
finally
{
_mreHandleClient.Set();
}
}
private ReceiveResult TryReceive(OracleAQQueue queue)
{
var result = new ReceiveResult();
using (var ts = new TransactionScope(TransactionScopeOption.Required, this.transactionOptions))
{
queue.Connection.EnlistTransaction(Transaction.Current);
result.Message = this.Receive(queue);
try
{
if (result.Message == null || this.tryProcessMessage(result.Message))
{
// NOTE: We explicitly calling Dispose so that we force any exception to not bubble,
// eg Concurrency/Deadlock exception.
ts.Complete();
ts.Dispose();
}
}
catch (Exception ex)
{
result.Exception = ex;
}
return result;
}
}
private async void ReceiveFile()
{
try
{
ReceiveResult returnReceiveResult = ReceiveResult.CannotReceived;
string returnMessage = string.Empty;
string returnMessageTitle = string.Empty;
byte[] fileInfoByte = new byte[INFO_BUFFER];
await Task.Run(async() =>
{
await NetworkStream.ReadAsync(fileInfoByte, 0, (int)INFO_BUFFER);
});
ReceivedFileInfo FileInfo = ReadFileInfoFromByte(fileInfoByte);
fileSize = FileInfo.FileSize;
string questionMessageBody = Translator.GetStringFromResource(MessageCodes.ReceiverAskForReceiveFile.ToString(), FileInfo.FileName, FileInfo.FileSize.formatSize());
string questionMessageTitle = Translator.GetStringFromResource(MessageCodes.ReceiverAskForReceiveFileTitle.ToString());
if (MessageBox.Show(questionMessageBody, questionMessageTitle, MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.No)
{
returnReceiveResult = ReceiveResult.FileIgnoredByUser;
returnMessage = Translator.GetStringFromResource(MessageCodes.ReceiverFileRejectedByUser.ToString());
returnMessageTitle = Translator.GetStringFromResource(MessageCodes.ReceiverFileRejectedByUserTitle.ToString());
ReceivingFileFinished(returnReceiveResult, returnMessage, returnMessageTitle);
return;
}
using (FileStream fstream = new FileStream(ReceiveSaveLocation + @"\" + FileInfo.FileName, FileMode.Create, FileAccess.ReadWrite))
{
byte[] buff = new byte[RECEIVE_BUFFER];
int buffered = 0;
ReceivingFileStarted();
await Task.Run(async() =>
{
if (!NetworkStream.CanRead)
{
returnReceiveResult = ReceiveResult.CannotReceived;
returnMessage = Translator.GetStringFromResource(MessageCodes.ReceiverCouldntReadStream.ToString());
returnMessageTitle = Translator.GetStringFromResource(MessageCodes.ReceiverCouldntReadStreamTitle.ToString());
return;
}
while ((buffered = await NetworkStream.ReadAsync(buff, 0, buff.Length)) > 0)
{
if (CancelFileReceiving)
{
returnReceiveResult = ReceiveResult.Cancelled;
returnMessage = Translator.GetStringFromResource(MessageCodes.ReceiverCancelledByUser.ToString());
returnMessageTitle = Translator.GetStringFromResource(MessageCodes.ReceiverCancelledByUserTitle.ToString());
return;
}
await fstream.WriteAsync(buff, 0, buffered);
totalReceived += buffered;
}
if (totalReceived < FileInfo.FileSize)
{
returnReceiveResult = ReceiveResult.CannotReceived;
returnMessage = Translator.GetStringFromResource(MessageCodes.ReceiverFailed.ToString());
returnMessageTitle = Translator.GetStringFromResource(MessageCodes.ReceiverFailedTitle.ToString());
return;
}
returnReceiveResult = ReceiveResult.Completed;
returnMessage = Translator.GetStringFromResource(MessageCodes.ReceiverCompleted.ToString());
returnMessageTitle = Translator.GetStringFromResource(MessageCodes.ReceiverCompletedTitle.ToString());
});
ReceivingFileFinished(returnReceiveResult, returnMessage, returnMessageTitle);
}
}
catch (IOException ex)
{
var errcode = ex.InnerException as Win32Exception;
if (errcode != null && errcode.ErrorCode == 10054)
{
ReceivingFileFinished(ReceiveResult.CannotReceived, Translator.GetStringFromResource(MessageCodes.ReceiverIOException10054.ToString()), Translator.GetStringFromResource(MessageCodes.ReceiverIOException10054Title.ToString()));
}
else
{
ReceivingFileFinished(ReceiveResult.CannotReceived, Translator.GetStringFromResource(MessageCodes.ReceiverIOException.ToString()), Translator.GetStringFromResource(MessageCodes.ReceiverIOExceptionTitle.ToString()));
}
}
catch (Exception exception)
{
ReceivingFileFinished(ReceiveResult.CannotReceived, Translator.GetStringFromResource(MessageCodes.ReceiverException.ToString(), exception.Message), Translator.GetStringFromResource(MessageCodes.ReceiverExceptionTitle.ToString()));
}
finally
{
Dispose();
}
}
private void ListenFinished(ReceiveResult result)
{
ListenCompletedEvent.Invoke(result);
}
/// <summary>
/// Produces a message (traced with the <see cref="IOutgoingMessageTracer"/>) and consumes it
/// (traced with the <see cref="IIncomingMessageReceiveTracer"/> and <see cref="IIncomingMessageProcessTracer"/>)
/// The Dynatrace tag is transported along with the message
/// </summary>
public static void ProducerConsumerExample()
{
string serverEndpoint = "messageserver.example.com:1234";
string topic = "my-topic";
IMessagingSystemInfo messagingSystemInfo = SampleApplication.OneAgentSdk
.CreateMessagingSystemInfo(MessageSystemVendor.KAFKA, topic, MessageDestinationType.TOPIC, ChannelType.TCP_IP, serverEndpoint);
IOutgoingMessageTracer outgoingTracer = SampleApplication.OneAgentSdk.TraceOutgoingMessage(messagingSystemInfo);
outgoingTracer.Start();
try
{
Message message = new Message
{
CorrelationId = "my-correlation-id-1234" // optional, determined by application
};
// transport the Dynatrace tag along with the message to allow the outgoing message tracer to be linked
// together with the message processing tracer on the receiving side
message.Headers[OneAgentSdkConstants.DYNATRACE_MESSAGE_PROPERTYNAME] = outgoingTracer.GetDynatraceByteTag();
SendResult result = MyMessagingSystem.SendMessage(message);
outgoingTracer.SetCorrelationId(message.CorrelationId); // optional
outgoingTracer.SetVendorMessageId(result.VendorMessageId); // optional
}
catch (Exception e)
{
outgoingTracer.Error(e);
// handle or rethrow
throw e;
}
finally
{
outgoingTracer.End();
}
// represents server side processing
Thread server = new Thread(() =>
{
IIncomingMessageReceiveTracer receiveTracer = SampleApplication.OneAgentSdk.TraceIncomingMessageReceive(messagingSystemInfo);
receiveTracer.Start();
try
{
// blocking call until message is available:
ReceiveResult receiveResult = MyMessagingSystem.ReceiveMessage();
Message message = receiveResult.Message;
IIncomingMessageProcessTracer processTracer = SampleApplication.OneAgentSdk.TraceIncomingMessageProcess(messagingSystemInfo);
// retrieve Dynatrace tag created using the outgoing message tracer to link both sides together:
if (message.Headers.ContainsKey(OneAgentSdkConstants.DYNATRACE_MESSAGE_PROPERTYNAME))
{
processTracer.SetDynatraceByteTag(message.Headers[OneAgentSdkConstants.DYNATRACE_MESSAGE_PROPERTYNAME]);
}
// start processing:
processTracer.Start();
processTracer.SetCorrelationId(message.CorrelationId); // optional
processTracer.SetVendorMessageId(receiveResult.VendorMessageId); // optional
try
{
ProcessMessage(message); // do the work ...
}
catch (Exception e)
{
processTracer.Error(e);
// handle or rethrow
throw e;
}
finally
{
processTracer.End();
}
}
catch (Exception e)
{
receiveTracer.Error(e);
// handle or rethrow
throw e;
}
finally
{
receiveTracer.End();
}
});
server.Start();
server.Join();
}
public abstract bool Receive(int suggestedBufferLength, TimeSpan timeout, out ReceiveResult receiveResult);
/// <summary>
/// Starts an asynchronous socket read operation
/// </summary>
/// <param name="buffer">
/// The socket receive buffer
/// </param>
/// <param name="callback">
/// Asynchronous completion delegate
/// </param>
/// <param name="state">
/// Asynchronous completion delegate parameter
/// </param>
/// <returns>
/// The asynchronous completion token
/// </returns>
public IAsyncResult BeginReceive(
ArraySegment<Byte> buffer,
AsyncCallback callback,
Object state)
{
try
{
AsyncResult result = new AsyncResult(callback, state);
ReceiveResult recvResult = new ReceiveResult()
{
Buffer = buffer,
Endpoint = GetReceiveEndpoint(),
AsyncResult = result
};
this.socket.BeginReceiveFrom(
buffer.Array,
buffer.Offset,
buffer.Count,
SocketFlags.None,
ref recvResult.Endpoint,
this.OnReceiveFrom,
recvResult
);
return result;
}
catch (SocketException e)
{
throw MapException(e);
}
}
void OnCompletion(int error, bool completedSynchronously)
{
Exception completionException = null;
this.receiveResult = ReceiveResult.MessageReceived;
try
{
if (error != 0)
{
if (error == UnsafeNativeMethods.MQ_ERROR_IO_TIMEOUT)
{
this.receiveResult = ReceiveResult.Timeout;
}
else if (error == UnsafeNativeMethods.MQ_ERROR_OPERATION_CANCELLED)
{
this.receiveResult = ReceiveResult.OperationCancelled;
}
else
{
if (IsReceiveErrorDueToInsufficientBuffer(error))
{
this.message.Unpin();
message.GrowBuffers();
StartReceive(completedSynchronously);
return;
}
else if (IsErrorDueToStaleHandle(error))
{
this.msmqQueue.HandleIsStale(this.handle);
}
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MsmqException(SR.GetString(SR.MsmqReceiveError, MsmqError.GetErrorString(error)), error));
}
}
}
catch (Exception e)
{
if (e is NullReferenceException || e is SEHException)
throw;
completionException = e;
}
this.message.Unpin();
Complete(completedSynchronously, completionException);
}
private void Action(object obj)
{
var cancellationToken = (CancellationToken)obj;
while (!cancellationToken.IsCancellationRequested)
{
var result = new ReceiveResult();
try
{
using (var connection = new OracleConnection(this.ConnectionString))
{
using (var queue = new OracleAQQueue(this.workQueue, connection, OracleAQMessageType.Xml))
{
connection.Open();
this.SetupClientInfo(connection);
queue.Listen(null);
result = this.TryReceive(queue);
}
}
}
finally
{
if (result.Message != null)
{
this.endProcessMessage(result.Message, result.Exception);
}
}
this.circuitBreaker.Success();
}
}
