コード例 #1
0
 public static void DisposeExceptionManager(this IAsyncBuilder builder)
 {
     if (builder.HasExceptionManager())
     {
         builder.ExceptionManager.Dispose();
     }
 }
コード例 #2
0
 public static void InsertPromisesToParent(this IAsyncBuilder builder)
 {
     if (builder.Parent != null)
     {
         builder.Parent.Delegates.AddRange(builder.Delegates);
     }
 }
コード例 #3
0
 /// <summary>
 /// Mark the promises as initial state. The promises are always going to be executed unless a there is an explicit return.
 /// </summary>
 /// <param name="builder">The instance of the current AsyncBuilder</param>
 public static void SetPromisesState(this IAsyncBuilder builder)
 {
     //The appended promises are marked as pending
     foreach (var delegateinfo in builder.Delegates)
     {
         var promise = delegateinfo.CreatedPromise as PromiseInfo;
         if (promise != null && promise.State != PromiseState.Skipped)
         {
             promise.State = PromiseState.Default;
         }
     }
 }
コード例 #4
0
        /// <summary>
        /// Adds a delegate and its respective promise to the list of promises to be validated.
        /// </summary>
        /// <param name="builder">The instance of the current AsyncBuilder</param>
        /// <param name="del">The original Delgate</param>
        /// <param name="promise">The promise associeted to the Delegate</param>
        /// <param name="promiseType">Indicates the type of promise added. By default is CodeExecution</param>
        public static void AddPromise(this IAsyncBuilder builder, Delegate del, IPromise promise, PromiseType promiseType = PromiseType.CodeExecution)
        {
            var delPromise = new DelegateOrPromise()
            {
                Delegate = del
            };

            delPromise.CreatedPromise = promise;
            builder.Delegates.Add(delPromise);
            builder.SetPromiseInfo(delPromise.CreatedPromise, builder.FamilyId, promiseType);
            builder.HasAppendedPromises = true;
        }
コード例 #5
0
        /// <summary>
        /// Sets the FamilyId from the current builder  to the promise.
        /// All of the promises within a method belong to the same family.
        /// </summary>
        /// <param name="builder">The instance of the current AsyncBuilder</param>
        /// <param name="promise">The promise to add to the family</param>
        public static void SetPromiseInfo(this IAsyncBuilder builder, IPromise promise, string familyId, PromiseType promiseType)
        {
            var basePomise = promise as BasePromiseInfo;

            if (basePomise != null)
            {
                basePomise.FamilyId    = familyId + UniqueIDGenerator.UniqueIdSeparator + builder.UniqueId;
                basePomise.PromiseType = promiseType;

                if (promiseType == PromiseType.Catch)
                {
                    basePomise.State = PromiseState.Skipped;
                }
                if (promiseType == PromiseType.Finally)
                {
                    basePomise.State = PromiseState.Default;
                }
            }
        }
コード例 #6
0
        /// <summary>
        /// Sets the initial values for an AsyncBuilder
        /// </summary>
        /// <param name="topBuilder">Indicates if the builder creates a new context</param>
        /// <param name="builder">The AsyncBuilder instance</param>
        private void InitBuilder(bool topBuilder, IAsyncBuilder builder)
        {
            if (_currentBuilders == null)
            {
                _currentBuilders = new Stack <IAsyncBuilder>();
            }

            if (_currentBuilders.Count > 0)
            {
                builder.Parent = _currentBuilders.Peek();
            }

            builder.UniqueId        = _stateManager.UniqueIDGenerator.GetBuilderUniqueID();
            builder.DisposeBuilder += RemoveFromStack;

            if (topBuilder)
            {
#if DEBUG
                if (_currentBuilders.Count > 0)
                {
                    UpgradeHelpers.WebMap.Server.Common.TraceUtil.TraceInformation("A new Top Async Builder has been open within another.");
                }
#endif
                //A new scope has been open, all of the following builder are grouped in the current family.
                builder.FamilyId = _stateManager.UniqueIDGenerator.GetFamilyUniqueID();
            }
            else if (builder.Parent != null)
            {
                //Inherits the FamilyId from the last builder
                builder.FamilyId = builder.Parent.FamilyId;
            }
            else
            {
                //The FamilyId is calculated based on the current executing promise
                if (_viewManager.State.ExecutingPromiseInfo != null)
                {
                    builder.FamilyId = _viewManager.State.ExecutingPromiseInfo.FamilyId;
                }
            }
        }
コード例 #7
0
        /// <summary>
        /// Triggers the logic associated to a catch block on synchronic code. Looks for a suitable excpetion through the same family
        /// </summary>
        /// <typeparam name="T">The type of the exception</typeparam>
        /// <param name="ex">The instance of the exception</param>
        /// <param name="builder">The instance of the parent builder</param>
        private void HandleException <T>(T ex, IAsyncBuilder builder) where T : Exception
        {
            if (builder != null && builder.HasExceptionManager())
            {
                var      exceptionManager  = builder.ExceptionManager as ExceptionManager;
                Delegate genericException  = null;
                Delegate specificException = null;
                exceptionManager.Exceptions.TryGetValue(TYPE_OF_EXCEPTION, out genericException);

                //If System.Exception no need to look for a more specific exception.
                if (typeof(T) != TYPE_OF_EXCEPTION)
                {
                    exceptionManager.Exceptions.TryGetValue(typeof(T), out specificException);
                    if (specificException != null)
                    {
                        //The type of the thrown exception is different than System.Exception and has catch that handles it specifically.
                        (specificException as Action <T>)(ex);
                        return;
                    }
                }

                if (genericException != null)
                {
                    //If no specific excption is declared then the generic catch handles it.
                    (genericException as Action <T>)(ex);
                    return;
                }
                else if (builder == null)
                {
                    //If no more parents the exception must be handled asynchronically.
                    return;
                }
                else
                {
                    //Look for another exception in the chain
                    HandleException <T>(ex, builder.Parent);
                }
            }
        }