Esempio n. 1
0
        /// <summary>
        /// Initialize the callback holding object.
        /// </summary>
        /// <param name="workItemsGroup">The workItemGroup of the workitem</param>
        /// <param name="workItemInfo">The WorkItemInfo of te workitem</param>
        /// <param name="callback">Action delegate for the callback.</param>
        /// <param name="state">Items with which to call the callback delegate.</param>
        ///
        /// We assume that the WorkItem object is created within the thread
        /// that meant to run the callback
        public WorkItem(
            IWorkItemsGroup workItemsGroup,
            WorkItemInfo workItemInfo,
            WorkItemCallback callback,
            object state)
        {
            if (null == workItemInfo)
            {
                throw new ArgumentNullException("workItemInfo");
            }

            _workItemsGroup = workItemsGroup;
            _workItemInfo   = workItemInfo;

#if !(_WINDOWS_CE) && !(_SILVERLIGHT)
            if (_workItemInfo.UseCallerCallContext || _workItemInfo.UseCallerHttpContext)
            {
                _callerContext = CallerThreadContext.Capture(_workItemInfo.UseCallerCallContext, _workItemInfo.UseCallerHttpContext);
            }
#endif

            _callback       = callback;
            _state          = state;
            _workItemResult = new WorkItemResult(this);
            Initialize();
        }
Esempio n. 2
0
        private void ExecuteWorkItem()
        {
#if !(_WINDOWS_CE) && !(_SILVERLIGHT)
            CallerThreadContext ctc = null;
            if (null != _callerContext)
            {
                ctc = CallerThreadContext.Capture(_callerContext.CapturedCallContext, _callerContext.CapturedHttpContext);
                CallerThreadContext.Apply(_callerContext);
            }
#endif

            Exception exception = null;
            object    result    = null;

            try
            {
                try
                {
                    result = _callback(_state);
                }
                catch (Exception ex)
                {
                    // Save the exception so we can rethrow it later
                    exception = ex;
                    try
                    {
                        new TaskThreadException(ex).HandleException();
                    }
                    catch
                    {
                        EffectiveFileLogger.WriteException(new TaskThreadException(ex));
                    }
                }

                // Remove the value of the execution thread, so it will be impossible to cancel the work item,
                // since it is already completed.
                // Cancelling a work item that already completed may cause the abortion of the next work item!!!
                Thread executionThread = Interlocked.CompareExchange(ref _executingThread, null, _executingThread);

                if (null == executionThread)
                {
                    // Oops! we are going to be aborted..., Wait here so we can catch the ThreadAbortException
                    Thread.Sleep(60 * 1000);

                    // If after 1 minute this thread was not aborted then let it continue working.
                }
            }
            // We must treat the ThreadAbortException or else it will be stored in the exception variable
            catch
            {
                // Check if the work item was cancelled
                // If we got a ThreadAbortException and the STP is not shutting down, it means the
                // work items was cancelled.
                if (!SmartThreadPool.CurrentThreadEntry.AssociatedSmartThreadPool.IsShuttingdown)
                {
#if !(_WINDOWS_CE) && !(_SILVERLIGHT)
                    Thread.ResetAbort();
#endif
                }
            }

#if !(_WINDOWS_CE) && !(_SILVERLIGHT)
            if (null != _callerContext)
            {
                CallerThreadContext.Apply(ctc);
            }
#endif

            if (!SmartThreadPool.IsWorkItemCanceled)
            {
                SetResult(result, exception);
            }
        }