internal void DropOrRejectReceivedMessage(MsmqQueue queue, MsmqMessageProperty messageProperty, bool reject) { if (this.Transactional) { TryAbortTransactionCurrent(); IPostRollbackErrorStrategy strategy = new SimplePostRollbackErrorStrategy(messageProperty.LookupId); MsmqQueue.MoveReceiveResult unknown = MsmqQueue.MoveReceiveResult.Unknown; do { using (MsmqEmptyMessage message = new MsmqEmptyMessage()) { using (TransactionScope scope = new TransactionScope(TransactionScopeOption.RequiresNew)) { unknown = queue.TryReceiveByLookupId(messageProperty.LookupId, message, MsmqTransactionMode.CurrentOrThrow); if ((MsmqQueue.MoveReceiveResult.Succeeded == unknown) && reject) { queue.MarkMessageRejected(messageProperty.LookupId); } scope.Complete(); } } if (unknown == MsmqQueue.MoveReceiveResult.Succeeded) { MsmqDiagnostics.MessageConsumed(this.instanceId, messageProperty.MessageId, Msmq.IsRejectMessageSupported && reject); } }while ((unknown == MsmqQueue.MoveReceiveResult.MessageLockedUnderTransaction) && strategy.AnotherTryNeeded()); } else { MsmqDiagnostics.MessageConsumed(this.instanceId, messageProperty.MessageId, false); } }
public void DeleteMessage(long lookupId, TimeSpan timeout) { // operations on the lock subqueue need to be protected from ---- with close MoveReceiveResult receiveResult; IPostRollbackErrorStrategy postRollBack = new SimplePostRollbackErrorStrategy(lookupId); do { using (MsmqEmptyMessage emptyMessage = new MsmqEmptyMessage()) { receiveResult = this.lockQueueForReceive.TryReceiveByLookupId(lookupId, emptyMessage, MsmqTransactionMode.CurrentOrNone); } if (receiveResult != MsmqQueue.MoveReceiveResult.MessageLockedUnderTransaction) { break; } // We could have failed because of ---- with transaction.abort() for the transaction // that had this message locked previously. We will retry in these cases. } while (postRollBack.AnotherTryNeeded()); // We could have failed because of // a) failure in the underlying queue manager // b) expiration of the native message timer // c) ---- with Channel.Close() // ..not much we can do in any of these cases if (receiveResult != MoveReceiveResult.Succeeded) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MsmqException(SR.GetString(SR.MsmqReceiveContextMessageNotReceived, lookupId.ToString(CultureInfo.InvariantCulture)))); } }
internal void DropOrRejectReceivedMessage(MsmqQueue queue, MsmqMessageProperty messageProperty, bool reject) { if (this.Transactional) { TryAbortTransactionCurrent(); IPostRollbackErrorStrategy strategy = new SimplePostRollbackErrorStrategy(messageProperty.LookupId); MsmqQueue.MoveReceiveResult unknown = MsmqQueue.MoveReceiveResult.Unknown; do { using (MsmqEmptyMessage message = new MsmqEmptyMessage()) { using (TransactionScope scope = new TransactionScope(TransactionScopeOption.RequiresNew)) { unknown = queue.TryReceiveByLookupId(messageProperty.LookupId, message, MsmqTransactionMode.CurrentOrThrow); if ((MsmqQueue.MoveReceiveResult.Succeeded == unknown) && reject) { queue.MarkMessageRejected(messageProperty.LookupId); } scope.Complete(); } } if (unknown == MsmqQueue.MoveReceiveResult.Succeeded) { MsmqDiagnostics.MessageConsumed(this.instanceId, messageProperty.MessageId, Msmq.IsRejectMessageSupported && reject); } } while ((unknown == MsmqQueue.MoveReceiveResult.MessageLockedUnderTransaction) && strategy.AnotherTryNeeded()); } else { MsmqDiagnostics.MessageConsumed(this.instanceId, messageProperty.MessageId, false); } }
// WaitForMessage internal bool WaitForMessage(TimeSpan timeout) { using (MsmqEmptyMessage message = new MsmqEmptyMessage()) { return(MsmqQueue.ReceiveResult.Timeout != this.queue.TryPeek(message, timeout)); } }
public WaitForMessageAsyncResult(MsmqQueue msmqQueue, TimeSpan timeout, AsyncCallback callback, object state) : base(callback, state) { this.msmqMessage = new MsmqEmptyMessage(); this.msmqQueue = msmqQueue; this.msmqQueue.BeginPeek(this.msmqMessage, timeout, onCompleteStatic, this); }
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); }
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); }
public void DeleteMessage(long lookupId, TimeSpan timeout) { MsmqQueue.MoveReceiveResult result; IPostRollbackErrorStrategy strategy = new SimplePostRollbackErrorStrategy(lookupId); do { using (MsmqEmptyMessage message = new MsmqEmptyMessage()) { result = this.lockQueueForReceive.TryReceiveByLookupId(lookupId, message, MsmqTransactionMode.CurrentOrNone); } }while ((result == MsmqQueue.MoveReceiveResult.MessageLockedUnderTransaction) && strategy.AnotherTryNeeded()); if (result != MsmqQueue.MoveReceiveResult.Succeeded) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MsmqException(System.ServiceModel.SR.GetString("MsmqReceiveContextMessageNotReceived", new object[] { lookupId.ToString(CultureInfo.InvariantCulture) }))); } }
internal void DropOrRejectReceivedMessage(MsmqQueue queue, MsmqMessageProperty messageProperty, bool reject) { if (this.Transactional) { TryAbortTransactionCurrent(); IPostRollbackErrorStrategy postRollback = new SimplePostRollbackErrorStrategy(messageProperty.LookupId); MsmqQueue.MoveReceiveResult result = MsmqQueue.MoveReceiveResult.Unknown; do { using (MsmqEmptyMessage emptyMessage = new MsmqEmptyMessage()) { using (TransactionScope scope = new TransactionScope(TransactionScopeOption.RequiresNew)) { result = queue.TryReceiveByLookupId(messageProperty.LookupId, emptyMessage, MsmqTransactionMode.CurrentOrThrow); if (MsmqQueue.MoveReceiveResult.Succeeded == result && reject) { queue.MarkMessageRejected(messageProperty.LookupId); } scope.Complete(); } } if (result == MsmqQueue.MoveReceiveResult.Succeeded) { // If 'Reject' supported and 'Reject' requested, put reject in the trace, otherwise put 'Drop' MsmqDiagnostics.MessageConsumed(instanceId, messageProperty.MessageId, (Msmq.IsRejectMessageSupported && reject)); } if (result != MsmqQueue.MoveReceiveResult.MessageLockedUnderTransaction) { break; } }while (postRollback.AnotherTryNeeded()); } else { MsmqDiagnostics.MessageConsumed(instanceId, messageProperty.MessageId, false); } }
public void DeleteMessage(long lookupId, TimeSpan timeout) { TransactionLookupEntry entry; if ((Transaction.Current != null) && (Transaction.Current.TransactionInformation.Status != System.Transactions.TransactionStatus.Active)) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MsmqException(System.ServiceModel.SR.GetString("MsmqAmbientTransactionInactive"))); } lock (this.internalStateLock) { if (!this.lockMap.TryGetValue(lookupId, out entry)) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MsmqException(System.ServiceModel.SR.GetString("MessageNotInLockedState", new object[] { lookupId }))); } if (entry.MsmqInternalTransaction == null) { this.lockMap.Remove(entry.LookupId); throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MsmqException(System.ServiceModel.SR.GetString("MessageNotInLockedState", new object[] { lookupId }))); } } if (Transaction.Current == null) { entry.MsmqInternalTransaction.Commit(0, 0, 0); lock (this.internalStateLock) { this.lockMap.Remove(lookupId); return; } } lock (this.receiveLock) { MsmqQueueHandle handle = base.GetHandle(); BOID pboidReason = new BOID(); entry.MsmqInternalTransaction.Abort(ref pboidReason, 0, 0); entry.MsmqInternalTransaction = null; using (MsmqEmptyMessage message = new MsmqEmptyMessage()) { int error = 0; try { error = base.ReceiveByLookupIdCoreDtcTransacted(handle, lookupId, message, MsmqTransactionMode.CurrentOrThrow, 0x40000020); } catch (ObjectDisposedException exception) { MsmqDiagnostics.ExpectedException(exception); } if (error != 0) { if (MsmqQueue.IsErrorDueToStaleHandle(error)) { base.HandleIsStale(handle); } throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MsmqException(System.ServiceModel.SR.GetString("MsmqCannotReacquireLock"), error)); } } } lock (this.internalStateLock) { List <long> list; if (!this.dtcTransMap.TryGetValue(Transaction.Current.TransactionInformation.DistributedIdentifier, out list)) { list = new List <long>(); this.dtcTransMap.Add(Transaction.Current.TransactionInformation.DistributedIdentifier, list); Transaction.Current.TransactionCompleted += this.transactionCompletedHandler; } list.Add(lookupId); } }
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; }
public void DeleteMessage(long lookupId, TimeSpan timeout) { TransactionLookupEntry entry; if ((Transaction.Current != null) && (Transaction.Current.TransactionInformation.Status != System.Transactions.TransactionStatus.Active)) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MsmqException(System.ServiceModel.SR.GetString("MsmqAmbientTransactionInactive"))); } lock (this.internalStateLock) { if (!this.lockMap.TryGetValue(lookupId, out entry)) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MsmqException(System.ServiceModel.SR.GetString("MessageNotInLockedState", new object[] { lookupId }))); } if (entry.MsmqInternalTransaction == null) { this.lockMap.Remove(entry.LookupId); throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MsmqException(System.ServiceModel.SR.GetString("MessageNotInLockedState", new object[] { lookupId }))); } } if (Transaction.Current == null) { entry.MsmqInternalTransaction.Commit(0, 0, 0); lock (this.internalStateLock) { this.lockMap.Remove(lookupId); return; } } lock (this.receiveLock) { MsmqQueueHandle handle = base.GetHandle(); BOID pboidReason = new BOID(); entry.MsmqInternalTransaction.Abort(ref pboidReason, 0, 0); entry.MsmqInternalTransaction = null; using (MsmqEmptyMessage message = new MsmqEmptyMessage()) { int error = 0; try { error = base.ReceiveByLookupIdCoreDtcTransacted(handle, lookupId, message, MsmqTransactionMode.CurrentOrThrow, 0x40000020); } catch (ObjectDisposedException exception) { MsmqDiagnostics.ExpectedException(exception); } if (error != 0) { if (MsmqQueue.IsErrorDueToStaleHandle(error)) { base.HandleIsStale(handle); } throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MsmqException(System.ServiceModel.SR.GetString("MsmqCannotReacquireLock"), error)); } } } lock (this.internalStateLock) { List<long> list; if (!this.dtcTransMap.TryGetValue(Transaction.Current.TransactionInformation.DistributedIdentifier, out list)) { list = new List<long>(); this.dtcTransMap.Add(Transaction.Current.TransactionInformation.DistributedIdentifier, list); Transaction.Current.TransactionCompleted += this.transactionCompletedHandler; } list.Add(lookupId); } }
public void DeleteMessage(long lookupId, TimeSpan timeout) { // operations on the lock subqueue need to be protected from ---- with close MoveReceiveResult receiveResult; IPostRollbackErrorStrategy postRollBack = new SimplePostRollbackErrorStrategy(lookupId); do { using (MsmqEmptyMessage emptyMessage = new MsmqEmptyMessage()) { receiveResult = this.lockQueueForReceive.TryReceiveByLookupId(lookupId, emptyMessage, MsmqTransactionMode.CurrentOrNone); } if (receiveResult != MsmqQueue.MoveReceiveResult.MessageLockedUnderTransaction) break; // We could have failed because of ---- with transaction.abort() for the transaction // that had this message locked previously. We will retry in these cases. } while (postRollBack.AnotherTryNeeded()); // We could have failed because of // a) failure in the underlying queue manager // b) expiration of the native message timer // c) ---- with Channel.Close() // ..not much we can do in any of these cases if (receiveResult != MoveReceiveResult.Succeeded) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MsmqException(SR.GetString(SR.MsmqReceiveContextMessageNotReceived, lookupId.ToString(CultureInfo.InvariantCulture)))); } }
public void DeleteMessage(long lookupId, TimeSpan timeout) { MsmqQueue.MoveReceiveResult result; IPostRollbackErrorStrategy strategy = new SimplePostRollbackErrorStrategy(lookupId); do { using (MsmqEmptyMessage message = new MsmqEmptyMessage()) { result = this.lockQueueForReceive.TryReceiveByLookupId(lookupId, message, MsmqTransactionMode.CurrentOrNone); } } while ((result == MsmqQueue.MoveReceiveResult.MessageLockedUnderTransaction) && strategy.AnotherTryNeeded()); if (result != MsmqQueue.MoveReceiveResult.Succeeded) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MsmqException(System.ServiceModel.SR.GetString("MsmqReceiveContextMessageNotReceived", new object[] { lookupId.ToString(CultureInfo.InvariantCulture) }))); } }
// WaitForMessage internal bool WaitForMessage(TimeSpan timeout) { using (MsmqEmptyMessage message = new MsmqEmptyMessage()) { return (MsmqQueue.ReceiveResult.Timeout != this.queue.TryPeek(message, timeout)); } }
internal void DropOrRejectReceivedMessage(MsmqQueue queue, MsmqMessageProperty messageProperty, bool reject) { if (this.Transactional) { TryAbortTransactionCurrent(); IPostRollbackErrorStrategy postRollback = new SimplePostRollbackErrorStrategy(messageProperty.LookupId); MsmqQueue.MoveReceiveResult result = MsmqQueue.MoveReceiveResult.Unknown; do { using (MsmqEmptyMessage emptyMessage = new MsmqEmptyMessage()) { using (TransactionScope scope = new TransactionScope(TransactionScopeOption.RequiresNew)) { result = queue.TryReceiveByLookupId(messageProperty.LookupId, emptyMessage, MsmqTransactionMode.CurrentOrThrow); if (MsmqQueue.MoveReceiveResult.Succeeded == result && reject) queue.MarkMessageRejected(messageProperty.LookupId); scope.Complete(); } } if (result == MsmqQueue.MoveReceiveResult.Succeeded) // If 'Reject' supported and 'Reject' requested, put reject in the trace, otherwise put 'Drop' MsmqDiagnostics.MessageConsumed(instanceId, messageProperty.MessageId, (Msmq.IsRejectMessageSupported && reject)); if (result != MsmqQueue.MoveReceiveResult.MessageLockedUnderTransaction) break; } while (postRollback.AnotherTryNeeded()); } else { MsmqDiagnostics.MessageConsumed(instanceId, messageProperty.MessageId, false); } }
// The demand is not added now (in 4.5), to avoid a breaking change. To be considered in the next version. /* * // We demand full trust because we call code from a non-APTCA assembly. * // MSMQ is not enabled in partial trust, so this demand should not break customers. * [PermissionSet(SecurityAction.Demand, Unrestricted = true)] */ public void DeleteMessage(long lookupId, TimeSpan timeout) { TransactionLookupEntry entry; if (Transaction.Current != null && Transaction.Current.TransactionInformation.Status != System.Transactions.TransactionStatus.Active) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MsmqException(SR.GetString(SR.MsmqAmbientTransactionInactive))); } lock (this.internalStateLock) { if (!this.lockMap.TryGetValue(lookupId, out entry)) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MsmqException(SR.GetString(SR.MessageNotInLockedState, lookupId))); } // a failed relock is the same as not having a lock if (entry.MsmqInternalTransaction == null) { this.lockMap.Remove(entry.LookupId); throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MsmqException(SR.GetString(SR.MessageNotInLockedState, lookupId))); } } if (Transaction.Current == null) { entry.MsmqInternalTransaction.Commit( 0, // fRetaining 0, // grfTC 0 // grfRM ); lock (this.internalStateLock) { this.lockMap.Remove(lookupId); } } else { // we don't want any thread receiving the message we are trying to re-receive in a new transaction lock (this.receiveLock) { MsmqQueueHandle handle = GetHandle(); // abort internal transaction and re-receive in the ambient transaction BOID boid = new BOID(); entry.MsmqInternalTransaction.Abort( ref boid, // pboidReason 0, // fRetaining 0 // fAsync ); // null indicates that the associated internal tx was aborted and the message is now // unlocked as far as the native queue manager is concerned entry.MsmqInternalTransaction = null; using (MsmqEmptyMessage emptyMessage = new MsmqEmptyMessage()) { int error = 0; try { error = base.ReceiveByLookupIdCoreDtcTransacted(handle, lookupId, emptyMessage, MsmqTransactionMode.CurrentOrThrow, UnsafeNativeMethods.MQ_LOOKUP_RECEIVE_CURRENT); } catch (ObjectDisposedException ex) { // ---- with Close MsmqDiagnostics.ExpectedException(ex); } if (error != 0) { if (IsErrorDueToStaleHandle(error)) { HandleIsStale(handle); } throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MsmqException(SR.GetString(SR.MsmqCannotReacquireLock), error)); } } } List <long> transMsgs; lock (this.internalStateLock) { if (!this.dtcTransMap.TryGetValue(Transaction.Current.TransactionInformation.DistributedIdentifier, out transMsgs)) { transMsgs = new List <long>(); this.dtcTransMap.Add(Transaction.Current.TransactionInformation.DistributedIdentifier, transMsgs); // only need to attach the tx complete handler once per transaction Transaction.Current.TransactionCompleted += this.transactionCompletedHandler; } transMsgs.Add(lookupId); } } }
// The demand is not added now (in 4.5), to avoid a breaking change. To be considered in the next version. /* // We demand full trust because we call code from a non-APTCA assembly. // MSMQ is not enabled in partial trust, so this demand should not break customers. [PermissionSet(SecurityAction.Demand, Unrestricted = true)] */ public void DeleteMessage(long lookupId, TimeSpan timeout) { TransactionLookupEntry entry; if (Transaction.Current != null && Transaction.Current.TransactionInformation.Status != System.Transactions.TransactionStatus.Active) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MsmqException(SR.GetString(SR.MsmqAmbientTransactionInactive))); } lock (this.internalStateLock) { if (!this.lockMap.TryGetValue(lookupId, out entry)) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MsmqException(SR.GetString(SR.MessageNotInLockedState, lookupId))); } // a failed relock is the same as not having a lock if (entry.MsmqInternalTransaction == null) { this.lockMap.Remove(entry.LookupId); throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MsmqException(SR.GetString(SR.MessageNotInLockedState, lookupId))); } } if (Transaction.Current == null) { entry.MsmqInternalTransaction.Commit( 0, // fRetaining 0, // grfTC 0 // grfRM ); lock (this.internalStateLock) { this.lockMap.Remove(lookupId); } } else { // we don't want any thread receiving the message we are trying to re-receive in a new transaction lock (this.receiveLock) { MsmqQueueHandle handle = GetHandle(); // abort internal transaction and re-receive in the ambient transaction BOID boid = new BOID(); entry.MsmqInternalTransaction.Abort( ref boid, // pboidReason 0, // fRetaining 0 // fAsync ); // null indicates that the associated internal tx was aborted and the message is now // unlocked as far as the native queue manager is concerned entry.MsmqInternalTransaction = null; using (MsmqEmptyMessage emptyMessage = new MsmqEmptyMessage()) { int error = 0; try { error = base.ReceiveByLookupIdCoreDtcTransacted(handle, lookupId, emptyMessage, MsmqTransactionMode.CurrentOrThrow, UnsafeNativeMethods.MQ_LOOKUP_RECEIVE_CURRENT); } catch (ObjectDisposedException ex) { // ---- with Close MsmqDiagnostics.ExpectedException(ex); } if (error != 0) { if (IsErrorDueToStaleHandle(error)) { HandleIsStale(handle); } throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MsmqException(SR.GetString(SR.MsmqCannotReacquireLock), error)); } } } List<long> transMsgs; lock (this.internalStateLock) { if (!this.dtcTransMap.TryGetValue(Transaction.Current.TransactionInformation.DistributedIdentifier, out transMsgs)) { transMsgs = new List<long>(); this.dtcTransMap.Add(Transaction.Current.TransactionInformation.DistributedIdentifier, transMsgs); // only need to attach the tx complete handler once per transaction Transaction.Current.TransactionCompleted += this.transactionCompletedHandler; } transMsgs.Add(lookupId); } } }
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; }