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;
                    }
                }
            }
        }
        internal static void MoveReceivedMessage(MsmqQueue queueFrom, MsmqQueue queueTo, long lookupId)
        {
            TryAbortTransactionCurrent();
            IPostRollbackErrorStrategy strategy = new SimplePostRollbackErrorStrategy(lookupId);

            do
            {
                if (queueFrom.TryMoveMessage(lookupId, queueTo, MsmqTransactionMode.Single) != MsmqQueue.MoveReceiveResult.MessageLockedUnderTransaction)
                {
                    return;
                }
            }while (strategy.AnotherTryNeeded());
        }
Esempio n. 3
0
        //
        internal static void MoveReceivedMessage(MsmqQueue queueFrom, MsmqQueue queueTo, long lookupId)
        {
            TryAbortTransactionCurrent();

            IPostRollbackErrorStrategy postRollback = new SimplePostRollbackErrorStrategy(lookupId);

            MsmqQueue.MoveReceiveResult result = MsmqQueue.MoveReceiveResult.Unknown;
            do
            {
                result = queueFrom.TryMoveMessage(lookupId, queueTo, MsmqTransactionMode.Single);

                if (result != MsmqQueue.MoveReceiveResult.MessageLockedUnderTransaction)
                {
                    break;
                }
            }while (postRollback.AnotherTryNeeded());
        }
 private void CollectLocks(MsmqQueue lockQueue)
 {
     MsmqQueue.ReceiveResult messageReceived = MsmqQueue.ReceiveResult.MessageReceived;
     while (messageReceived == MsmqQueue.ReceiveResult.MessageReceived)
     {
         using (MsmqMessageLookupId id = new MsmqMessageLookupId())
         {
             try
             {
                 messageReceived = lockQueue.TryPeek(id, TimeSpan.FromSeconds(0.0));
                 if (messageReceived == MsmqQueue.ReceiveResult.MessageReceived)
                 {
                     lockQueue.TryMoveMessage(id.lookupId.Value, this.mainQueueForMove, MsmqTransactionMode.None);
                 }
             }
             catch (MsmqException exception)
             {
                 MsmqDiagnostics.ExpectedException(exception);
                 messageReceived = MsmqQueue.ReceiveResult.Unknown;
             }
             continue;
         }
     }
 }
Esempio n. 5
0
 private void CollectLocks(MsmqQueue lockQueue)
 {
     MsmqQueue.ReceiveResult messageReceived = MsmqQueue.ReceiveResult.MessageReceived;
     while (messageReceived == MsmqQueue.ReceiveResult.MessageReceived)
     {
         using (MsmqMessageLookupId id = new MsmqMessageLookupId())
         {
             try
             {
                 messageReceived = lockQueue.TryPeek(id, TimeSpan.FromSeconds(0.0));
                 if (messageReceived == MsmqQueue.ReceiveResult.MessageReceived)
                 {
                     lockQueue.TryMoveMessage(id.lookupId.Value, this.mainQueueForMove, MsmqTransactionMode.None);
                 }
             }
             catch (MsmqException exception)
             {
                 MsmqDiagnostics.ExpectedException(exception);
                 messageReceived = MsmqQueue.ReceiveResult.Unknown;
             }
             continue;
         }
     }
 }
        //
        internal static void MoveReceivedMessage(MsmqQueue queueFrom, MsmqQueue queueTo, long lookupId)
        {
            TryAbortTransactionCurrent();

            IPostRollbackErrorStrategy postRollback = new SimplePostRollbackErrorStrategy(lookupId);
            MsmqQueue.MoveReceiveResult result = MsmqQueue.MoveReceiveResult.Unknown;
            do
            {
                result = queueFrom.TryMoveMessage(lookupId, queueTo, MsmqTransactionMode.Single);

                if (result != MsmqQueue.MoveReceiveResult.MessageLockedUnderTransaction)
                    break;
            }
            while (postRollback.AnotherTryNeeded());
        }
        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;
                    }
                }
            }
        }
 internal static void MoveReceivedMessage(MsmqQueue queueFrom, MsmqQueue queueTo, long lookupId)
 {
     TryAbortTransactionCurrent();
     IPostRollbackErrorStrategy strategy = new SimplePostRollbackErrorStrategy(lookupId);
     do
     {
         if (queueFrom.TryMoveMessage(lookupId, queueTo, MsmqTransactionMode.Single) != MsmqQueue.MoveReceiveResult.MessageLockedUnderTransaction)
         {
             return;
         }
     }
     while (strategy.AnotherTryNeeded());
 }