LoadRetryAsyncResult.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / cdf / src / NetFx40 / System.Activities.DurableInstancing / System / Activities / DurableInstancing / LoadRetryAsyncResult.cs / 1305376 / LoadRetryAsyncResult.cs

                            //------------------------------------------------------------------------------ 
// Copyright (c) Microsoft Corporation.  All rights reserved.
//-----------------------------------------------------------------------------

namespace System.Activities.DurableInstancing 
{
    using System; 
    using System.Diagnostics; 
    using System.Diagnostics.CodeAnalysis;
    using System.Globalization; 
    using System.Runtime;
    using System.Runtime.DurableInstancing;

    class LoadRetryAsyncResult : AsyncResult 
    {
        static AsyncCallback onTryCommandCallback = Fx.ThunkCallback(new AsyncCallback(OnTryCommandCallback)); 
        bool commandSuccess; 
        TimeoutHelper commandTimeout;
        InstanceLockedException lastInstanceLockedException; 

        int retryCount;

        public LoadRetryAsyncResult(SqlWorkflowInstanceStore store, InstancePersistenceContext context, 
            InstancePersistenceCommand command, TimeSpan timeout, AsyncCallback callback, object state)
            : base(callback, state) 
        { 
            this.InstanceStore = store;
            this.InstancePersistenceContext = context; 
            this.InstancePersistenceCommand = command;
            this.commandTimeout = new TimeoutHelper(timeout);

            InstanceStore.BeginTryCommandInternal(this.InstancePersistenceContext, this.InstancePersistenceCommand, 
                this.commandTimeout.RemainingTime(), LoadRetryAsyncResult.onTryCommandCallback, this);
        } 
 
        public SqlWorkflowInstanceStore InstanceStore
        { 
            get;
            private set;
        }
 
        public TimeSpan RetryTimeout
        { 
            get; 
            private set;
        } 

        InstancePersistenceCommand InstancePersistenceCommand
        {
            get; 
            set;
        } 
 
        InstancePersistenceContext InstancePersistenceContext
        { 
            get;
            set;
        }
 
        public static bool End(IAsyncResult result)
        { 
            LoadRetryAsyncResult thisPtr = AsyncResult.End(result); 
            return thisPtr.commandSuccess;
        } 

        public void AbortRetry()
        {
            Fx.Assert(this.lastInstanceLockedException != null, "no last instance lock exception"); 
            this.Complete(false, this.lastInstanceLockedException);
        } 
 
        public void Retry()
        { 
            InstanceStore.BeginTryCommandInternal(this.InstancePersistenceContext, this.InstancePersistenceCommand,
                this.commandTimeout.RemainingTime(), LoadRetryAsyncResult.onTryCommandCallback, this);
        }
 
        [SuppressMessage(FxCop.Category.Design, FxCop.Rule.DoNotCatchGeneralExceptionTypes,
            Justification = "Standard AsyncResult callback pattern.")] 
        static void OnTryCommandCallback(IAsyncResult result) 
        {
            LoadRetryAsyncResult tryCommandAsyncResult = (LoadRetryAsyncResult)(result.AsyncState); 
            Exception completeException = null;
            bool completeFlag = true;

            try 
            {
                tryCommandAsyncResult.CompleteTryCommand(result); 
            } 
            catch (InstanceLockedException instanceLockedException)
            { 
                TimeSpan retryDelay = tryCommandAsyncResult.InstanceStore.GetNextRetryDelay(++tryCommandAsyncResult.retryCount);

                if (retryDelay < tryCommandAsyncResult.commandTimeout.RemainingTime())
                { 
                    tryCommandAsyncResult.RetryTimeout = retryDelay;
 
                    if (tryCommandAsyncResult.InstanceStore.EnqueueRetry(tryCommandAsyncResult)) 
                    {
                        tryCommandAsyncResult.lastInstanceLockedException = instanceLockedException; 
                        completeFlag = false;
                    }
                }
                else if (TD.LockRetryTimeoutIsEnabled()) 
                {
                    TD.LockRetryTimeout(tryCommandAsyncResult.commandTimeout.OriginalTimeout.ToString()); 
                } 

                if (completeFlag) 
                {
                    completeException = instanceLockedException;
                }
            } 
            catch (Exception exception)
            { 
                if (Fx.IsFatal(exception)) 
                {
                    throw; 
                }

                completeException = exception;
            } 

            if (completeFlag) 
            { 
                tryCommandAsyncResult.Complete(false, completeException);
            } 
        }

        void CompleteTryCommand(IAsyncResult result)
        { 
            this.commandSuccess = this.InstanceStore.EndTryCommand(result);
        } 
    } 

} 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
                        

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK