private void AttachHandlers()
	{
		BeginEventHandler bh = new BeginEventHandler( this.BeginLoad );
		EndEventHandler eh = new EndEventHandler( this.EndLoad );

		AddOnPreRenderCompleteAsync( bh, eh );
	}

    internal LegacyPageAsyncTask(BeginEventHandler beginHandler, EndEventHandler endHandler, EndEventHandler timeoutHandler, Object state, bool executeInParallel) {
        // Parameter checking is done by the public PageAsyncTask constructor

        _beginHandler = beginHandler;
        _endHandler = endHandler;
        _timeoutHandler = timeoutHandler;
        _state = state;
        _executeInParallel = executeInParallel;
    }

		public PageAsyncTask (BeginEventHandler beginHandler, EndEventHandler endHandler,
			EndEventHandler timeoutHandler, Object state, bool executeInParallel) 
		{
			this.beginHandler = beginHandler;
			this.endHandler = endHandler;
			this.timeoutHandler = timeoutHandler;
			this.state = state;
			this.executeInParallel = executeInParallel;
		}

 public void Init(HttpApplication context)
 {
     if (beginEventHandler == null)
     {
         beginEventHandler = new BeginEventHandler(ServiceHttpModule.BeginProcessRequest);
     }
     if (endEventHandler == null)
     {
         endEventHandler = new EndEventHandler(ServiceHttpModule.EndProcessRequest);
     }
     context.AddOnPostAuthenticateRequestAsync(beginEventHandler, endEventHandler);
 }

        protected void Start_Clicked(object sender, EventArgs e)
        {
            ProgressLabel.Text = "Page_Load: thread #" + System.Threading.Thread.CurrentThread.GetHashCode();

            BeginEventHandler bh = new BeginEventHandler(this.BeginGetAsyncData);
            EndEventHandler eh = new EndEventHandler(this.EndGetAsyncData);

            AddOnPreRenderCompleteAsync(bh, eh);

            // Initialize the WebRequest.
            string address = "http://localhost/";

            myRequest = System.Net.WebRequest.Create(address);
        }

 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");
     }
     this._beginHandler = beginHandler;
     this._endHandler = endHandler;
     this._timeoutHandler = timeoutHandler;
     this._state = state;
     this._executeInParallel = executeInParallel;
 }

        // APM
        internal PageAsyncTask(BeginEventHandler beginHandler, EndEventHandler endHandler, EndEventHandler timeoutHandler, Object state, bool executeInParallel, SynchronizationContextMode currentMode) {
            if (beginHandler == null) {
                throw new ArgumentNullException("beginHandler");
            }
            if (endHandler == null) {
                throw new ArgumentNullException("endHandler");
            }

            // Only the legacy PageAsyncTaskManager supports timing out APM methods or executing them in parallel
            if (timeoutHandler != null || executeInParallel) {
                SynchronizationContextUtil.ValidateMode(currentMode, requiredMode: SynchronizationContextMode.Legacy, specificErrorMessage: SR.SynchronizationContextUtil_PageAsyncTaskTimeoutHandlerParallelNotCompatible);
            }

            BeginHandler = beginHandler;
            EndHandler = endHandler;
            TimeoutHandler = timeoutHandler;
            State = state;
            ExecuteInParallel = executeInParallel;
        }

    private void DoAsync()
    {
        if (IsAsync)
        {
            Session["Halted"] = false;
            Timer1.Enabled = true;
            var asyncHandler = new AsyncHandler(Context);
            asyncHandler.NotifyHaltHandler += Halted;
            asyncHandler.NotifyLogger += Logger;
            BeginEventHandler bh = new BeginEventHandler(asyncHandler.BeginProcessRequest);
            EndEventHandler eh = new EndEventHandler(asyncHandler.EndProcessRequest);

            AddOnPreRenderCompleteAsync(bh, eh);

            // Initialize the WebRequest.
            string address = "http://localhost/";

            asyncHandler.WebRequest = System.Net.WebRequest.Create(address);
        }
        GC.Collect();
        GC.WaitForPendingFinalizers();
    }

	public void AddOnBeginRequestAsync(BeginEventHandler bh, EndEventHandler eh) {}

	public void AddOnPostUpdateRequestCacheAsync(BeginEventHandler bh, EndEventHandler eh) {}

	public void AddOnPostReleaseRequestStateAsync(BeginEventHandler bh, EndEventHandler eh) {}

	public void AddOnPreRequestHandlerExecuteAsync(BeginEventHandler beginHandler, EndEventHandler endHandler, object state) {}

	public void AddOnAcquireRequestStateAsync(BeginEventHandler bh, EndEventHandler eh) {}

	public void AddOnPostMapRequestHandlerAsync(BeginEventHandler bh, EndEventHandler eh) {}

	public void AddOnPostAuthorizeRequestAsync(BeginEventHandler beginHandler, EndEventHandler endHandler, object state) {}

	public void AddOnResolveRequestCacheAsync(BeginEventHandler bh, EndEventHandler eh) {}

 public void AddOnMapRequestHandlerAsync(BeginEventHandler bh, EndEventHandler eh) {
     if (!HttpRuntime.UseIntegratedPipeline) {
         throw new PlatformNotSupportedException(SR.GetString(SR.Requires_Iis_Integrated_Mode));
     }
     AddOnMapRequestHandlerAsync(bh, eh, null);
 }

 public void AddOnPostMapRequestHandlerAsync(BeginEventHandler beginHandler, EndEventHandler endHandler, Object state) {
     AsyncEvents.AddHandler(EventPostMapRequestHandler, beginHandler, endHandler, state,
                            RequestNotification.MapRequestHandler, true, this);
 }

	public void AddOnPostRequestHandlerExecuteAsync(BeginEventHandler bh, EndEventHandler eh) {}

	public void AddOnPreRenderCompleteAsync (BeginEventHandler beginHandler, EndEventHandler endHandler)
	{
		AddOnPreRenderCompleteAsync (beginHandler, endHandler, null);
	}