PageAsyncTask.cs source code in C# .NET

Source code for the .NET framework in C#

                        
Code:

                         / FX-1434 / FX-1434 / 1.0 / untmp / whidbey / REDBITS / ndp / fx / src / xsp / System / Web / UI / PageAsyncTask.cs / 3 / PageAsyncTask.cs
                        

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

namespace System.Web.UI { 
 
using System;
using System.Collections; 
using System.Security;
using System.Security.Permissions;
using System.Threading;
using System.Web; 
using System.Web.UI;
using System.Web.Util; 
 
[AspNetHostingPermission(SecurityAction.LinkDemand, Level=AspNetHostingPermissionLevel.Minimal)]
public sealed class PageAsyncTask { 
    private BeginEventHandler   _beginHandler;
    private EndEventHandler     _endHandler;
    private EndEventHandler     _timeoutHandler;
    private Object              _state; 
    private bool                _executeInParallel;
 
    private PageAsyncTaskManager _taskManager; 
    private int                 _completionMethodLock;
    private bool                _started; 
    private bool                _completed;
    private bool                _completedSynchronously;
    private AsyncCallback       _completionCallback;
    private IAsyncResult        _asyncResult; 
    private Exception           _error;
 
    public PageAsyncTask(BeginEventHandler beginHandler, EndEventHandler endHandler, EndEventHandler timeoutHandler, Object state) 
        : this(beginHandler, endHandler, timeoutHandler, state, false) {
    } 

    public PageAsyncTask(BeginEventHandler beginHandler, EndEventHandler endHandler, EndEventHandler timeoutHandler, Object state, bool executeInParallel) {
        if (beginHandler == null) {
            throw new ArgumentNullException("beginHandler"); 
        }
        if (endHandler == null) { 
            throw new ArgumentNullException("endHandler"); 
        }
 
        _beginHandler = beginHandler;
        _endHandler = endHandler;
        _timeoutHandler = timeoutHandler;
        _state = state; 
        _executeInParallel = executeInParallel;
    } 
 
    public BeginEventHandler BeginHandler {
        get { return _beginHandler; } 
    }

    public EndEventHandler EndHandler {
        get { return _endHandler; } 
    }
 
    public EndEventHandler TimeoutHandler { 
        get { return _timeoutHandler; }
    } 

    public Object State {
        get { return _state; }
    } 

    public bool ExecuteInParallel { 
        get { return _executeInParallel; } 
    }
 
    internal bool Started {
        get { return _started; }
    }
 
    internal bool CompletedSynchronously {
        get { return _completedSynchronously; } 
    } 

    internal bool Completed { 
        get { return _completed; }
    }

    internal IAsyncResult AsyncResult { 
        get { return _asyncResult; }
    } 
 
    internal Exception Error {
        get { return _error; } 
    }

    internal void Start(PageAsyncTaskManager manager, Object source, EventArgs args) {
        Debug.Assert(!_started); 

        _taskManager = manager; 
        _completionCallback = new AsyncCallback(this.OnAsyncTaskCompletion); 
        _started = true;
 
        Debug.Trace("Async", "Start task");

        try {
            IAsyncResult ar = _beginHandler(source, args, _completionCallback, _state); 

            if (ar == null) { 
                throw new InvalidOperationException(SR.GetString(SR.Async_null_asyncresult)); 
            }
 
            if (_asyncResult == null) {
                // _asyncResult could be not null if already completed
                _asyncResult = ar;
            } 
        }
        catch (Exception e) { 
            Debug.Trace("Async", "Task failed to start"); 

            _error = e; 
            _completed = true;
            _completedSynchronously = true;
            _taskManager.TaskCompleted(true /*onCallerThread*/); // notify TaskManager
            // it is ok to say false (onCallerThread) above because this kind of 
            // error completion will never be the last in ResumeTasks()
        } 
    } 

    private void OnAsyncTaskCompletion(IAsyncResult ar) { 
        Debug.Trace("Async", "Task completed, CompletedSynchronously=" + ar.CompletedSynchronously);

        if (_asyncResult == null) {
            // _asyncResult could be null if the code not yet returned from begin method 
            _asyncResult = ar;
        } 
 
        CompleteTask(false /*timedOut*/);
    } 

    internal void ForceTimeout(bool syncCaller) {
        Debug.Trace("Async", "Task timed out");
        CompleteTask(true /*timedOut*/, syncCaller /*syncTimeoutCaller*/); 
    }
 
    private void CompleteTask(bool timedOut) { 
        CompleteTask(timedOut, false /*syncTimeoutCaller*/);
    } 

    private void CompleteTask(bool timedOut, bool syncTimeoutCaller) {
        if (Interlocked.Exchange(ref _completionMethodLock, 1) != 0) {
            return; 
        }
 
        bool needSetupThreadContext; 

        if (timedOut) { 
            needSetupThreadContext = !syncTimeoutCaller;
        }
        else {
            _completedSynchronously = _asyncResult.CompletedSynchronously; 
            needSetupThreadContext = !_completedSynchronously;
        } 
 
        // call the completion or timeout handler
        //  when neeeded setup the thread context and lock 
        //  catch and remember all exceptions

        try {
            if (needSetupThreadContext) { 
                HttpApplication app = _taskManager.Application;
 
                lock (app) { 
                    HttpApplication.ThreadContext threadContext = null;
                    try { 
                        threadContext = app.OnThreadEnter();
                        if (timedOut) {
                            if (_timeoutHandler != null) {
                                _timeoutHandler(_asyncResult); 
                            }
                        } 
                        else { 
                            _endHandler(_asyncResult);
                        } 
                    }
                    finally {
                        if (threadContext != null) {
                            threadContext.Leave(); 
                        }
                    } 
                } 
            }
            else { 
                if (timedOut) {
                    if (_timeoutHandler != null) {
                        _timeoutHandler(_asyncResult);
                    } 
                }
                else { 
                    _endHandler(_asyncResult); 
                }
            } 
        }
        catch (Exception e) {
            _error = e;
        } 

        _completed = true; 
        _taskManager.TaskCompleted(_completedSynchronously /*onCallerThread*/); // notify TaskManager 
    }
} 

}

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