protected unsafe int ReceiveByLookupIdCoreDtcTransacted(MsmqQueueHandle handle, long lookupId, NativeMsmqMessage message, MsmqTransactionMode transactionMode, int action) { IDtcTransaction dtcTransaction = GetNativeTransaction(transactionMode); IntPtr nativePropertiesPointer = message.Pin(); try { if (dtcTransaction != null) { try { return(UnsafeNativeMethods.MQReceiveMessageByLookupId(handle, lookupId, action, nativePropertiesPointer, null, IntPtr.Zero, dtcTransaction)); } finally { Marshal.ReleaseComObject(dtcTransaction); } } else { return(UnsafeNativeMethods.MQReceiveMessageByLookupId(handle, lookupId, action, nativePropertiesPointer, null, IntPtr.Zero, (IntPtr)GetTransactionConstant(transactionMode))); } } finally { message.Unpin(); } }
private int ReceiveCoreDtcTransacted(MsmqQueueHandle handle, NativeMsmqMessage message, TimeSpan timeout, MsmqTransactionMode transactionMode, int action) { int num2; IDtcTransaction nativeTransaction = this.GetNativeTransaction(transactionMode); int num = TimeoutHelper.ToMilliseconds(timeout); IntPtr properties = message.Pin(); try { if (nativeTransaction != null) { try { return(UnsafeNativeMethods.MQReceiveMessage(handle.DangerousGetHandle(), num, action, properties, null, IntPtr.Zero, IntPtr.Zero, nativeTransaction)); } finally { Marshal.ReleaseComObject(nativeTransaction); } } num2 = UnsafeNativeMethods.MQReceiveMessage(handle.DangerousGetHandle(), num, action, properties, null, IntPtr.Zero, IntPtr.Zero, (IntPtr)this.GetTransactionConstant(transactionMode)); } finally { message.Unpin(); } return(num2); }
protected int ReceiveByLookupIdCoreDtcTransacted(MsmqQueueHandle handle, long lookupId, NativeMsmqMessage message, MsmqTransactionMode transactionMode, int action) { int num; IDtcTransaction nativeTransaction = this.GetNativeTransaction(transactionMode); IntPtr properties = message.Pin(); try { if (nativeTransaction != null) { try { return(UnsafeNativeMethods.MQReceiveMessageByLookupId(handle, lookupId, action, properties, null, IntPtr.Zero, nativeTransaction)); } finally { Marshal.ReleaseComObject(nativeTransaction); } } num = UnsafeNativeMethods.MQReceiveMessageByLookupId(handle, lookupId, action, properties, null, IntPtr.Zero, (IntPtr)this.GetTransactionConstant(transactionMode)); } finally { message.Unpin(); } return(num); }
unsafe int ReceiveCoreDtcTransacted(MsmqQueueHandle handle, NativeMsmqMessage message, TimeSpan timeout, MsmqTransactionMode transactionMode, int action) { IDtcTransaction dtcTransaction = GetNativeTransaction(transactionMode); int timeoutInMilliseconds = TimeoutHelper.ToMilliseconds(timeout); IntPtr nativePropertiesPointer = message.Pin(); try { if (dtcTransaction != null) { try { return(UnsafeNativeMethods.MQReceiveMessage(handle.DangerousGetHandle(), timeoutInMilliseconds, action, nativePropertiesPointer, null, IntPtr.Zero, IntPtr.Zero, dtcTransaction)); } finally { Marshal.ReleaseComObject(dtcTransaction); } } else { return(UnsafeNativeMethods.MQReceiveMessage(handle.DangerousGetHandle(), timeoutInMilliseconds, action, nativePropertiesPointer, null, IntPtr.Zero, IntPtr.Zero, (IntPtr)GetTransactionConstant(transactionMode))); } } finally { message.Unpin(); } }
public void Send(NativeMsmqMessage message, MsmqTransactionMode transactionMode) { int error = 0; if (this.RequiresDtcTransaction(transactionMode)) { error = this.SendDtcTransacted(message, transactionMode); } else { MsmqQueueHandle handle = this.GetHandle(); IntPtr properties = message.Pin(); try { error = UnsafeNativeMethods.MQSendMessage(handle, properties, (IntPtr)this.GetTransactionConstant(transactionMode)); } finally { message.Unpin(); } } if (error != 0) { if (IsErrorDueToStaleHandle(error)) { this.HandleIsStale(this.handle); } throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MsmqException(System.ServiceModel.SR.GetString("MsmqSendError", new object[] { MsmqError.GetErrorString(error) }), error)); } }
int SendDtcTransacted(NativeMsmqMessage message, MsmqTransactionMode transactionMode) { IDtcTransaction dtcTransaction = GetNativeTransaction(transactionMode); MsmqQueueHandle handle = GetHandle(); IntPtr nativePropertiesPointer = message.Pin(); try { if (dtcTransaction != null) { try { return(UnsafeNativeMethods.MQSendMessage(handle, nativePropertiesPointer, dtcTransaction)); } finally { Marshal.ReleaseComObject(dtcTransaction); } } else { return(UnsafeNativeMethods.MQSendMessage(handle, nativePropertiesPointer, (IntPtr)GetTransactionConstant(transactionMode))); } } finally { message.Unpin(); } }
private int SendDtcTransacted(NativeMsmqMessage message, MsmqTransactionMode transactionMode) { int num; IDtcTransaction nativeTransaction = this.GetNativeTransaction(transactionMode); MsmqQueueHandle handle = this.GetHandle(); IntPtr properties = message.Pin(); try { if (nativeTransaction != null) { try { return(UnsafeNativeMethods.MQSendMessage(handle, properties, nativeTransaction)); } finally { Marshal.ReleaseComObject(nativeTransaction); } } num = UnsafeNativeMethods.MQSendMessage(handle, properties, (IntPtr)this.GetTransactionConstant(transactionMode)); } finally { message.Unpin(); } return(num); }
private ReceiveResult TryReceiveInternal(NativeMsmqMessage message, TimeSpan timeout, MsmqTransactionMode transactionMode, int action) { TimeoutHelper helper = new TimeoutHelper(timeout); MsmqQueueHandle handle = this.GetHandle(); while (true) { int error = this.ReceiveCore(handle, message, helper.RemainingTime(), transactionMode, action); if (error == 0) { return(ReceiveResult.MessageReceived); } if (!IsReceiveErrorDueToInsufficientBuffer(error)) { if (error == -1072824293) { return(ReceiveResult.Timeout); } if (error == -1072824312) { return(ReceiveResult.OperationCancelled); } if (error == -1072824313) { return(ReceiveResult.OperationCancelled); } if (IsErrorDueToStaleHandle(error)) { this.HandleIsStale(handle); } throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MsmqException(System.ServiceModel.SR.GetString("MsmqReceiveError", new object[] { MsmqError.GetErrorString(error) }), error)); } message.GrowBuffers(); } }
public void Send(NativeMsmqMessage message, MsmqTransactionMode transactionMode) { int error = 0; if (RequiresDtcTransaction(transactionMode)) { error = SendDtcTransacted(message, transactionMode); } else { MsmqQueueHandle handle = GetHandle(); IntPtr nativePropertiesPointer = message.Pin(); try { error = UnsafeNativeMethods.MQSendMessage(handle, nativePropertiesPointer, (IntPtr)GetTransactionConstant(transactionMode)); } finally { message.Unpin(); } } if (error != 0) { if (IsErrorDueToStaleHandle(error)) { HandleIsStale(handle); } throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MsmqException(SR.GetString(SR.MsmqSendError, MsmqError.GetErrorString(error)), error)); } }
unsafe void StartReceive(bool synchronously) { bool useCompletionPort; try { this.handle = this.msmqQueue.GetHandleForAsync(out useCompletionPort); } catch (MsmqException ex) { OnCompletion(ex.ErrorCode, synchronously); return; } if (null != nativeOverlapped) { Fx.Assert("---- in StartReceive"); } IntPtr nativePropertiesPointer = this.message.Pin(); nativeOverlapped = new Overlapped(0, 0, IntPtr.Zero, this).UnsafePack(onPortedCompletion, this.message.GetBuffersForAsync()); int error; try { if (useCompletionPort) { error = msmqQueue.ReceiveCoreAsync(this.handle, nativePropertiesPointer, this.timeoutHelper.RemainingTime(), this.action, nativeOverlapped, null); } else { if (onNonPortedCompletion == null) { onNonPortedCompletion = new UnsafeNativeMethods.MQReceiveCallback(OnNonPortedCompletion); } error = msmqQueue.ReceiveCoreAsync(this.handle, nativePropertiesPointer, this.timeoutHelper.RemainingTime(), this.action, nativeOverlapped, onNonPortedCompletion); } } catch (ObjectDisposedException ex) { // if Close ----s with the async Receive, it is possible that SafeHandle will throw ObjectDisposedException // the behavior should be same as if operation was just cancelled (the channel will return no message) MsmqDiagnostics.ExpectedException(ex); error = UnsafeNativeMethods.MQ_ERROR_OPERATION_CANCELLED; } if (error != 0) { if (error != UnsafeNativeMethods.MQ_INFORMATION_OPERATION_PENDING) { Overlapped.Free(nativeOverlapped); nativeOverlapped = null; GC.SuppressFinalize(this); OnCompletion(error, synchronously); } } }
unsafe int TryRelockMessage(long lookupId) { int retCode = 0; ITransaction internalTrans; using (MsmqEmptyMessage message = new MsmqEmptyMessage()) { IntPtr nativePropertiesPointer = message.Pin(); try { // don't want other threads receiving the message we want to relock lock (this.receiveLock) { MsmqQueueHandle handle = GetHandle(); TransactionLookupEntry entry; lock (this.internalStateLock) { if (!this.lockMap.TryGetValue(lookupId, out entry)) { // should never get here return(retCode); } if (entry.MsmqInternalTransaction == null) { retCode = UnsafeNativeMethods.MQBeginTransaction(out internalTrans); if (retCode != 0) { return(retCode); } retCode = UnsafeNativeMethods.MQReceiveMessageByLookupId(handle, lookupId, UnsafeNativeMethods.MQ_LOOKUP_RECEIVE_CURRENT, nativePropertiesPointer, null, IntPtr.Zero, internalTrans); if (retCode != 0) { BOID boid = new BOID(); internalTrans.Abort( ref boid, // pboidReason 0, // fRetaining 0 // fAsync ); return(retCode); } entry.MsmqInternalTransaction = internalTrans; } } } } finally { message.Unpin(); } } return(retCode); }
static bool IsCompletionPortSupported(MsmqQueueHandle handle) { // if it's a kernel handle, then it supports completion ports int flags; #pragma warning suppress 56523 return(UnsafeNativeMethods.GetHandleInformation(handle, out flags) != 0); }
protected void HandleIsStale(MsmqQueueHandle handle) { lock (this.ThisLock) { if (this.handle == handle) { this.CloseQueue(); } } }
unsafe int ReceiveCoreAsync(MsmqQueueHandle handle, IntPtr nativePropertiesPointer, TimeSpan timeout, int action, NativeOverlapped *nativeOverlapped, UnsafeNativeMethods.MQReceiveCallback receiveCallback) { int timeoutInMilliseconds = TimeoutHelper.ToMilliseconds(timeout); return(UnsafeNativeMethods.MQReceiveMessage(handle, timeoutInMilliseconds, action, nativePropertiesPointer, nativeOverlapped, receiveCallback, IntPtr.Zero, (IntPtr)UnsafeNativeMethods.MQ_NO_TRANSACTION)); }
protected MsmqQueueHandle GetHandle() { lock (this.ThisLock) { if (this.handle == null) { this.handle = this.OpenQueue(); } return(this.handle); } }
public virtual void CloseQueue() { if (this.handle != null) { this.CloseQueue(this.handle); this.handle = null; this.isBoundToCompletionPort = false; this.isAsyncEnabled = false; MsmqDiagnostics.QueueClosed(this.formatName); } }
private int TryRelockMessage(long lookupId) { int num = 0; using (MsmqEmptyMessage message = new MsmqEmptyMessage()) { IntPtr properties = message.Pin(); try { lock (this.receiveLock) { MsmqQueueHandle handle = base.GetHandle(); lock (this.internalStateLock) { TransactionLookupEntry entry; if (this.lockMap.TryGetValue(lookupId, out entry)) { ITransaction transaction; if (entry.MsmqInternalTransaction != null) { return(num); } num = UnsafeNativeMethods.MQBeginTransaction(out transaction); if (num != 0) { return(num); } num = UnsafeNativeMethods.MQReceiveMessageByLookupId(handle, lookupId, 0x40000020, properties, null, IntPtr.Zero, transaction); if (num != 0) { BOID pboidReason = new BOID(); transaction.Abort(ref pboidReason, 0, 0); return(num); } entry.MsmqInternalTransaction = transaction; } return(num); } return(num); } return(num); } finally { message.Unpin(); } } return(num); }
private unsafe void StartReceive(bool synchronously) { bool flag; int num; try { this.handle = this.msmqQueue.GetHandleForAsync(out flag); } catch (MsmqException exception) { this.OnCompletion(exception.ErrorCode, synchronously); return; } NativeOverlapped *nativeOverlapped = this.nativeOverlapped; IntPtr nativePropertiesPointer = this.message.Pin(); this.nativeOverlapped = new Overlapped(0, 0, IntPtr.Zero, this).UnsafePack(onPortedCompletion, this.message.GetBuffersForAsync()); try { if (flag) { num = this.msmqQueue.ReceiveCoreAsync(this.handle, nativePropertiesPointer, this.timeoutHelper.RemainingTime(), this.action, this.nativeOverlapped, null); } else { if (onNonPortedCompletion == null) { onNonPortedCompletion = new UnsafeNativeMethods.MQReceiveCallback(MsmqQueue.TryReceiveAsyncResult.OnNonPortedCompletion); } num = this.msmqQueue.ReceiveCoreAsync(this.handle, nativePropertiesPointer, this.timeoutHelper.RemainingTime(), this.action, this.nativeOverlapped, onNonPortedCompletion); } } catch (ObjectDisposedException exception2) { MsmqDiagnostics.ExpectedException(exception2); num = -1072824312; } if ((num != 0) && (num != 0x400e0006)) { Overlapped.Free(this.nativeOverlapped); this.nativeOverlapped = null; GC.SuppressFinalize(this); this.OnCompletion(num, synchronously); } }
private int TryMoveMessageDtcTransacted(long lookupId, MsmqQueueHandle sourceQueueHandle, MsmqQueueHandle destinationQueueHandle, MsmqTransactionMode transactionMode) { IDtcTransaction nativeTransaction = this.GetNativeTransaction(transactionMode); if (nativeTransaction != null) { try { return(UnsafeNativeMethods.MQMoveMessage(sourceQueueHandle, destinationQueueHandle, lookupId, nativeTransaction)); } finally { Marshal.ReleaseComObject(nativeTransaction); } } return(UnsafeNativeMethods.MQMoveMessage(sourceQueueHandle, destinationQueueHandle, lookupId, (IntPtr)this.GetTransactionConstant(transactionMode))); }
public MoveReceiveResult TryMoveMessage(long lookupId, MsmqQueue destinationQueue, MsmqTransactionMode transactionMode) { MsmqQueueHandle sourceQueueHandle = GetHandle(); MsmqQueueHandle destinationQueueHandle = destinationQueue.GetHandle(); int error; try { if (RequiresDtcTransaction(transactionMode)) { error = TryMoveMessageDtcTransacted(lookupId, sourceQueueHandle, destinationQueueHandle, transactionMode); } else { error = UnsafeNativeMethods.MQMoveMessage(sourceQueueHandle, destinationQueueHandle, lookupId, (IntPtr)GetTransactionConstant(transactionMode)); } } catch (ObjectDisposedException ex) { MsmqDiagnostics.ExpectedException(ex); return(MoveReceiveResult.Succeeded); } if (error != 0) { if (error == UnsafeNativeMethods.MQ_ERROR_MESSAGE_NOT_FOUND) { return(MoveReceiveResult.MessageNotFound); } else if (error == UnsafeNativeMethods.MQ_ERROR_MESSAGE_LOCKED_UNDER_TRANSACTION) { return(MoveReceiveResult.MessageLockedUnderTransaction); } else if (IsErrorDueToStaleHandle(error)) { HandleIsStale(sourceQueueHandle); destinationQueue.HandleIsStale(destinationQueueHandle); } throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MsmqException(SR.GetString(SR.MsmqSendError, MsmqError.GetErrorString(error)), error)); } return(MoveReceiveResult.Succeeded); }
public MoveReceiveResult TryReceiveByLookupId(long lookupId, NativeMsmqMessage message, MsmqTransactionMode transactionMode, int action) { MsmqQueueHandle handle = GetHandle(); int error = 0; while (true) { try { error = ReceiveByLookupIdCore(handle, lookupId, message, transactionMode, action); } catch (ObjectDisposedException ex) { // ---- with Close MsmqDiagnostics.ExpectedException(ex); return(MoveReceiveResult.Succeeded); } if (0 == error) { return(MoveReceiveResult.Succeeded); } if (IsReceiveErrorDueToInsufficientBuffer(error)) { message.GrowBuffers(); continue; } else if (UnsafeNativeMethods.MQ_ERROR_MESSAGE_NOT_FOUND == error) { return(MoveReceiveResult.MessageNotFound); } else if (UnsafeNativeMethods.MQ_ERROR_MESSAGE_LOCKED_UNDER_TRANSACTION == error) { return(MoveReceiveResult.MessageLockedUnderTransaction); } else if (IsErrorDueToStaleHandle(error)) { HandleIsStale(handle); } throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MsmqException(SR.GetString(SR.MsmqReceiveError, MsmqError.GetErrorString(error)), error)); } }
unsafe int ReceiveByLookupIdCore(MsmqQueueHandle handle, long lookupId, NativeMsmqMessage message, MsmqTransactionMode transactionMode, int action) { if (RequiresDtcTransaction(transactionMode)) { return(ReceiveByLookupIdCoreDtcTransacted(handle, lookupId, message, transactionMode, action)); } else { IntPtr nativePropertiesPointer = message.Pin(); try { return(UnsafeNativeMethods.MQReceiveMessageByLookupId(handle, lookupId, action, nativePropertiesPointer, null, IntPtr.Zero, (IntPtr)GetTransactionConstant(transactionMode))); } finally { message.Unpin(); } } }
private int ReceiveByLookupIdCore(MsmqQueueHandle handle, long lookupId, NativeMsmqMessage message, MsmqTransactionMode transactionMode, int action) { int num; if (this.RequiresDtcTransaction(transactionMode)) { return(this.ReceiveByLookupIdCoreDtcTransacted(handle, lookupId, message, transactionMode, action)); } IntPtr properties = message.Pin(); try { num = UnsafeNativeMethods.MQReceiveMessageByLookupId(handle, lookupId, action, properties, null, IntPtr.Zero, (IntPtr)this.GetTransactionConstant(transactionMode)); } finally { message.Unpin(); } return(num); }
public override ReceiveResult TryReceive(NativeMsmqMessage message, TimeSpan timeout, MsmqTransactionMode transactionMode) { // ignore the transactionMode TimeoutHelper timeoutHelper = new TimeoutHelper(timeout); MsmqQueueHandle handle = GetHandle(); while (true) { int error = PeekLockCore(handle, (MsmqInputMessage)message, timeoutHelper.RemainingTime()); if (error == 0) { return(ReceiveResult.MessageReceived); } if (IsReceiveErrorDueToInsufficientBuffer(error)) { message.GrowBuffers(); continue; } else if (error == UnsafeNativeMethods.MQ_ERROR_IO_TIMEOUT) { return(ReceiveResult.Timeout); } else if (error == UnsafeNativeMethods.MQ_ERROR_OPERATION_CANCELLED) { return(ReceiveResult.OperationCancelled); } else if (error == UnsafeNativeMethods.MQ_ERROR_INVALID_HANDLE) { // should happen only if racing with Close return(ReceiveResult.OperationCancelled); } else if (IsErrorDueToStaleHandle(error)) { HandleIsStale(handle); } throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MsmqException(SR.GetString(SR.MsmqReceiveError, MsmqError.GetErrorString(error)), error)); } }
unsafe int ReceiveCore(MsmqQueueHandle handle, NativeMsmqMessage message, TimeSpan timeout, MsmqTransactionMode transactionMode, int action) { if (RequiresDtcTransaction(transactionMode)) { return(ReceiveCoreDtcTransacted(handle, message, timeout, transactionMode, action)); } else { int timeoutInMilliseconds = TimeoutHelper.ToMilliseconds(timeout); IntPtr nativePropertiesPointer = message.Pin(); try { return(UnsafeNativeMethods.MQReceiveMessage(handle.DangerousGetHandle(), timeoutInMilliseconds, action, nativePropertiesPointer, null, IntPtr.Zero, IntPtr.Zero, (IntPtr)GetTransactionConstant(transactionMode))); } finally { message.Unpin(); } } }
MsmqQueueHandle GetHandleForAsync(out bool useCompletionPort) { lock (this.ThisLock) { if (this.handle == null) { this.handle = OpenQueue(); } if (!this.isAsyncEnabled) { if (IsCompletionPortSupported(this.handle)) { ThreadPool.BindHandle(this.handle); this.isBoundToCompletionPort = true; } this.isAsyncEnabled = true; } useCompletionPort = this.isBoundToCompletionPort; return this.handle; } }
private MsmqQueueHandle GetHandleForAsync(out bool useCompletionPort) { lock (this.ThisLock) { if (this.handle == null) { this.handle = this.OpenQueue(); } if (!this.isAsyncEnabled) { if (IsCompletionPortSupported(this.handle)) { ThreadPool.BindHandle(this.handle); this.isBoundToCompletionPort = true; } this.isAsyncEnabled = true; } useCompletionPort = this.isBoundToCompletionPort; return(this.handle); } }
private int ReceiveCore(MsmqQueueHandle handle, NativeMsmqMessage message, TimeSpan timeout, MsmqTransactionMode transactionMode, int action) { int num2; if (this.RequiresDtcTransaction(transactionMode)) { return(this.ReceiveCoreDtcTransacted(handle, message, timeout, transactionMode, action)); } int num = TimeoutHelper.ToMilliseconds(timeout); IntPtr properties = message.Pin(); try { num2 = UnsafeNativeMethods.MQReceiveMessage(handle.DangerousGetHandle(), num, action, properties, null, IntPtr.Zero, IntPtr.Zero, (IntPtr)this.GetTransactionConstant(transactionMode)); } finally { message.Unpin(); } return(num2); }
public MoveReceiveResult TryMoveMessage(long lookupId, MsmqQueue destinationQueue, MsmqTransactionMode transactionMode) { int num; MsmqQueueHandle sourceQueueHandle = this.GetHandle(); MsmqQueueHandle handle = destinationQueue.GetHandle(); try { if (this.RequiresDtcTransaction(transactionMode)) { num = this.TryMoveMessageDtcTransacted(lookupId, sourceQueueHandle, handle, transactionMode); } else { num = UnsafeNativeMethods.MQMoveMessage(sourceQueueHandle, handle, lookupId, (IntPtr)this.GetTransactionConstant(transactionMode)); } } catch (ObjectDisposedException exception) { MsmqDiagnostics.ExpectedException(exception); return(MoveReceiveResult.Succeeded); } switch (num) { case 0: return(MoveReceiveResult.Succeeded); case -1072824184: return(MoveReceiveResult.MessageNotFound); case -1072824164: return(MoveReceiveResult.MessageLockedUnderTransaction); } if (IsErrorDueToStaleHandle(num)) { this.HandleIsStale(sourceQueueHandle); destinationQueue.HandleIsStale(handle); } throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MsmqException(System.ServiceModel.SR.GetString("MsmqSendError", new object[] { MsmqError.GetErrorString(num) }), num)); }
public void MarkMessageRejected(long lookupId) { MsmqQueueHandle handle = this.GetHandle(); int error = 0; try { error = UnsafeNativeMethods.MQMarkMessageRejected(handle, lookupId); } catch (ObjectDisposedException exception) { MsmqDiagnostics.ExpectedException(exception); } if (error != 0) { if (IsErrorDueToStaleHandle(error)) { this.HandleIsStale(handle); } throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MsmqException(System.ServiceModel.SR.GetString("MsmqSendError", new object[] { MsmqError.GetErrorString(error) }), error)); } }
public MoveReceiveResult TryReceiveByLookupId(long lookupId, NativeMsmqMessage message, MsmqTransactionMode transactionMode, int action) { MsmqQueueHandle handle = this.GetHandle(); int error = 0; while (true) { try { error = this.ReceiveByLookupIdCore(handle, lookupId, message, transactionMode, action); } catch (ObjectDisposedException exception) { MsmqDiagnostics.ExpectedException(exception); return(MoveReceiveResult.Succeeded); } if (error == 0) { return(MoveReceiveResult.Succeeded); } if (!IsReceiveErrorDueToInsufficientBuffer(error)) { if (-1072824184 == error) { return(MoveReceiveResult.MessageNotFound); } if (-1072824164 == error) { return(MoveReceiveResult.MessageLockedUnderTransaction); } if (IsErrorDueToStaleHandle(error)) { this.HandleIsStale(handle); } throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MsmqException(System.ServiceModel.SR.GetString("MsmqReceiveError", new object[] { MsmqError.GetErrorString(error) }), error)); } message.GrowBuffers(); } }
protected unsafe int ReceiveByLookupIdCoreDtcTransacted(MsmqQueueHandle handle, long lookupId, NativeMsmqMessage message, MsmqTransactionMode transactionMode, int action) { IDtcTransaction dtcTransaction = GetNativeTransaction(transactionMode); IntPtr nativePropertiesPointer = message.Pin(); try { if (dtcTransaction != null) { try { return UnsafeNativeMethods.MQReceiveMessageByLookupId(handle, lookupId, action, nativePropertiesPointer, null, IntPtr.Zero, dtcTransaction); } finally { Marshal.ReleaseComObject(dtcTransaction); } } else { return UnsafeNativeMethods.MQReceiveMessageByLookupId(handle, lookupId, action, nativePropertiesPointer, null, IntPtr.Zero, (IntPtr)GetTransactionConstant(transactionMode)); } } finally { message.Unpin(); } }
public unsafe static extern int MQMarkMessageRejected(MsmqQueueHandle handle, long lookupId);
unsafe int ReceiveCoreDtcTransacted(MsmqQueueHandle handle, NativeMsmqMessage message, TimeSpan timeout, MsmqTransactionMode transactionMode, int action) { IDtcTransaction dtcTransaction = GetNativeTransaction(transactionMode); int timeoutInMilliseconds = TimeoutHelper.ToMilliseconds(timeout); IntPtr nativePropertiesPointer = message.Pin(); try { if (dtcTransaction != null) { try { return UnsafeNativeMethods.MQReceiveMessage(handle.DangerousGetHandle(), timeoutInMilliseconds, action, nativePropertiesPointer, null, IntPtr.Zero, IntPtr.Zero, dtcTransaction); } finally { Marshal.ReleaseComObject(dtcTransaction); } } else { return UnsafeNativeMethods.MQReceiveMessage(handle.DangerousGetHandle(), timeoutInMilliseconds, action, nativePropertiesPointer, null, IntPtr.Zero, IntPtr.Zero, (IntPtr)GetTransactionConstant(transactionMode)); } } finally { message.Unpin(); } }
unsafe int ReceiveByLookupIdCore(MsmqQueueHandle handle, long lookupId, NativeMsmqMessage message, MsmqTransactionMode transactionMode, int action) { if (RequiresDtcTransaction(transactionMode)) { return ReceiveByLookupIdCoreDtcTransacted(handle, lookupId, message, transactionMode, action); } else { IntPtr nativePropertiesPointer = message.Pin(); try { return UnsafeNativeMethods.MQReceiveMessageByLookupId(handle, lookupId, action, nativePropertiesPointer, null, IntPtr.Zero, (IntPtr)GetTransactionConstant(transactionMode)); } finally { message.Unpin(); } } }
public static extern int MQMoveMessage(MsmqQueueHandle sourceQueueHandle, MsmqQueueHandle destinationQueueHandle, long lookupId, IDtcTransaction transaction);
unsafe int ReceiveCore(MsmqQueueHandle handle, NativeMsmqMessage message, TimeSpan timeout, MsmqTransactionMode transactionMode, int action) { if (RequiresDtcTransaction(transactionMode)) { return ReceiveCoreDtcTransacted(handle, message, timeout, transactionMode, action); } else { int timeoutInMilliseconds = TimeoutHelper.ToMilliseconds(timeout); IntPtr nativePropertiesPointer = message.Pin(); try { return UnsafeNativeMethods.MQReceiveMessage(handle.DangerousGetHandle(), timeoutInMilliseconds, action, nativePropertiesPointer, null, IntPtr.Zero, IntPtr.Zero, (IntPtr)GetTransactionConstant(transactionMode)); } finally { message.Unpin(); } } }
public virtual void CloseQueue() { if (this.handle != null) { CloseQueue(this.handle); this.handle = null; this.isBoundToCompletionPort = false; this.isAsyncEnabled = false; MsmqDiagnostics.QueueClosed(this.formatName); } }
public static extern int MQOpenQueue(string formatName, int access, int shareMode, out MsmqQueueHandle handle);
protected MsmqQueueHandle GetHandle() { lock (this.ThisLock) { if (this.handle == null) { this.handle = OpenQueue(); } return this.handle; } }
protected void HandleIsStale(MsmqQueueHandle handle) { lock (this.ThisLock) { if (this.handle == handle) { CloseQueue(); } } }
public unsafe static extern int MQReceiveMessageByLookupId(MsmqQueueHandle handle, long lookupId, int action, IntPtr properties, NativeOverlapped* nativeOverlapped, IntPtr receiveCallback, IDtcTransaction transaction);
public unsafe static extern int MQReceiveMessage(MsmqQueueHandle handle, int timeout, int action, IntPtr properties, NativeOverlapped* nativeOverlapped, MQReceiveCallback receiveCallback, IntPtr cursorHandle, IntPtr transaction);
public static extern int MQSendMessage(MsmqQueueHandle handle, IntPtr properties, IDtcTransaction transaction);
int TryMoveMessageDtcTransacted(long lookupId, MsmqQueueHandle sourceQueueHandle, MsmqQueueHandle destinationQueueHandle, MsmqTransactionMode transactionMode) { IDtcTransaction dtcTransaction = GetNativeTransaction(transactionMode); if (dtcTransaction != null) { try { return UnsafeNativeMethods.MQMoveMessage(sourceQueueHandle, destinationQueueHandle, lookupId, dtcTransaction); } finally { Marshal.ReleaseComObject(dtcTransaction); } } else { return UnsafeNativeMethods.MQMoveMessage(sourceQueueHandle, destinationQueueHandle, lookupId, (IntPtr)GetTransactionConstant(transactionMode)); } }
unsafe int PeekLockCore(MsmqQueueHandle handle, MsmqInputMessage message, TimeSpan timeout) { int retCode = 0; ITransaction internalTrans; TimeoutHelper timeoutHelper = new TimeoutHelper(timeout); IntPtr nativePropertiesPointer = message.Pin(); try { bool receivedMessage = false; while (!receivedMessage) { retCode = UnsafeNativeMethods.MQBeginTransaction(out internalTrans); if (retCode != 0) { return retCode; } int timeoutInMilliseconds = TimeoutHelper.ToMilliseconds(timeoutHelper.RemainingTime()); // no timeout interval if timeout has been set to 0 otherwise a minimum of 100 int timeoutIntervalInMilliseconds = (timeoutInMilliseconds == 0) ? 0 : 100; // receive until timeout but let go of receive lock for other contenders periodically while (true) { lock (this.receiveLock) { retCode = UnsafeNativeMethods.MQReceiveMessage(handle.DangerousGetHandle(), timeoutIntervalInMilliseconds, UnsafeNativeMethods.MQ_ACTION_RECEIVE, nativePropertiesPointer, null, IntPtr.Zero, IntPtr.Zero, internalTrans); if (retCode == UnsafeNativeMethods.MQ_ERROR_IO_TIMEOUT) { // keep trying until we timeout timeoutInMilliseconds = TimeoutHelper.ToMilliseconds(timeoutHelper.RemainingTime()); if (timeoutInMilliseconds == 0) { return retCode; } } else if (retCode != 0) { BOID boid = new BOID(); internalTrans.Abort( ref boid, // pboidReason 0, // fRetaining 0 // fAsync ); return retCode; // we don't need to release the ITransaction as MSMQ does not increment the ref counter // in MQBeginTransaction } else { // we got a message within the specified time out break; } } } TransactionLookupEntry entry; lock (this.internalStateLock) { if (!this.lockMap.TryGetValue(message.LookupId.Value, out entry)) { this.lockMap.Add(message.LookupId.Value, new TransactionLookupEntry(message.LookupId.Value, internalTrans)); receivedMessage = true; } else { // this was a message that was in the process of being handed off // from some app trans to some internal MSMQ transaction // and we grabbed it before the Abort() could finish // need to be a good citizen and finish that Abort() job for it entry.MsmqInternalTransaction = internalTrans; } } } } finally { message.Unpin(); } return retCode; }
unsafe void StartReceive(bool synchronously) { bool useCompletionPort; try { this.handle = this.msmqQueue.GetHandleForAsync(out useCompletionPort); } catch (MsmqException ex) { OnCompletion(ex.ErrorCode, synchronously); return; } if (null != nativeOverlapped) { Fx.Assert("---- in StartReceive"); } IntPtr nativePropertiesPointer = this.message.Pin(); nativeOverlapped = new Overlapped(0, 0, IntPtr.Zero, this).UnsafePack(onPortedCompletion, this.message.GetBuffersForAsync()); int error; try { if (useCompletionPort) { error = msmqQueue.ReceiveCoreAsync(this.handle, nativePropertiesPointer, this.timeoutHelper.RemainingTime(), this.action, nativeOverlapped, null); } else { if (onNonPortedCompletion == null) { onNonPortedCompletion = new UnsafeNativeMethods.MQReceiveCallback(OnNonPortedCompletion); } error = msmqQueue.ReceiveCoreAsync(this.handle, nativePropertiesPointer, this.timeoutHelper.RemainingTime(), this.action, nativeOverlapped, onNonPortedCompletion); } } catch (ObjectDisposedException ex) { // if Close ----s with the async Receive, it is possible that SafeHandle will throw ObjectDisposedException // the behavior should be same as if operation was just cancelled (the channel will return no message) MsmqDiagnostics.ExpectedException(ex); error = UnsafeNativeMethods.MQ_ERROR_OPERATION_CANCELLED; } if (error != 0) { if (error != UnsafeNativeMethods.MQ_INFORMATION_OPERATION_PENDING) { Overlapped.Free(nativeOverlapped); nativeOverlapped = null; GC.SuppressFinalize(this); OnCompletion(error, synchronously); } } }
public unsafe static extern int GetHandleInformation(MsmqQueueHandle handle, out int flags);
void CloseQueue(MsmqQueueHandle handle) { handle.Dispose(); }
unsafe int ReceiveCoreAsync(MsmqQueueHandle handle, IntPtr nativePropertiesPointer, TimeSpan timeout, int action, NativeOverlapped* nativeOverlapped, UnsafeNativeMethods.MQReceiveCallback receiveCallback) { int timeoutInMilliseconds = TimeoutHelper.ToMilliseconds(timeout); return UnsafeNativeMethods.MQReceiveMessage(handle, timeoutInMilliseconds, action, nativePropertiesPointer, nativeOverlapped, receiveCallback, IntPtr.Zero, (IntPtr)UnsafeNativeMethods.MQ_NO_TRANSACTION); }
private int PeekLockCore(MsmqQueueHandle handle, MsmqInputMessage message, TimeSpan timeout) { int num = 0; TimeoutHelper helper = new TimeoutHelper(timeout); IntPtr properties = message.Pin(); try { bool flag = false; while (!flag) { ITransaction transaction; bool flag2; object obj2; num = UnsafeNativeMethods.MQBeginTransaction(out transaction); if (num != 0) { return num; } int num3 = (TimeoutHelper.ToMilliseconds(helper.RemainingTime()) == 0) ? 0 : 100; Label_0045: flag2 = false; try { Monitor.Enter(obj2 = this.receiveLock, ref flag2); num = UnsafeNativeMethods.MQReceiveMessage(handle.DangerousGetHandle(), num3, 0, properties, null, IntPtr.Zero, IntPtr.Zero, transaction); if (num == -1072824293) { if (TimeoutHelper.ToMilliseconds(helper.RemainingTime()) == 0) { return num; } goto Label_0045; } if (num != 0) { BOID pboidReason = new BOID(); transaction.Abort(ref pboidReason, 0, 0); return num; } } finally { if (flag2) { Monitor.Exit(obj2); } } lock (this.internalStateLock) { TransactionLookupEntry entry; if (!this.lockMap.TryGetValue(message.LookupId.Value, out entry)) { this.lockMap.Add(message.LookupId.Value, new TransactionLookupEntry(message.LookupId.Value, transaction)); flag = true; } else { entry.MsmqInternalTransaction = transaction; } continue; } } } finally { message.Unpin(); } return num; }
static bool IsCompletionPortSupported(MsmqQueueHandle handle) { // if it's a kernel handle, then it supports completion ports int flags; #pragma warning suppress 56523 return UnsafeNativeMethods.GetHandleInformation(handle, out flags) != 0; }