|
//------------------------------------------------------------------------------
// <copyright file="LegacyPageAsyncTask.cs" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
//------------------------------------------------------------------------------
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;
// Represents an asynchronous task that uses the old asynchronous patterns and the legacy synchronization systems
internal sealed class LegacyPageAsyncTask {
private BeginEventHandler _beginHandler;
private EndEventHandler _endHandler;
private EndEventHandler _timeoutHandler;
private Object _state;
private bool _executeInParallel;
private LegacyPageAsyncTaskManager _taskManager;
private int _completionMethodLock;
private bool _started;
private bool _completed;
private bool _completedSynchronously;
private AsyncCallback _completionCallback;
private IAsyncResult _asyncResult;
private Exception _error;
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 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(LegacyPageAsyncTaskManager 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;
bool responseEnded = false;
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
HttpApplication app = _taskManager.Application;
try {
if (needSetupThreadContext) {
using (app.Context.SyncContext.AcquireThreadLock()) {
ThreadContext threadContext = null;
try {
threadContext = app.OnThreadEnter();
if (timedOut) {
if (_timeoutHandler != null) {
_timeoutHandler(_asyncResult);
}
}
else {
_endHandler(_asyncResult);
}
}
finally {
if (threadContext != null) {
threadContext.DisassociateFromCurrentThread();
}
}
}
}
else {
if (timedOut) {
if (_timeoutHandler != null) {
_timeoutHandler(_asyncResult);
}
}
else {
_endHandler(_asyncResult);
}
}
}
catch (ThreadAbortException e) {
_error = e;
HttpApplication.CancelModuleException exceptionState = e.ExceptionState as HttpApplication.CancelModuleException;
// Is this from Response.End()
if (exceptionState != null && !exceptionState.Timeout) {
// Mark the request as completed
using (app.Context.SyncContext.AcquireThreadLock()) {
// Handle response end once. Skip if already initiated (previous AsyncTask)
if (!app.IsRequestCompleted) {
responseEnded = true;
app.CompleteRequest();
}
}
// Clear the error for Response.End
_error = null;
}
// ---- the exception. Async completion required (DDB 140655)
Thread.ResetAbort();
}
catch (Exception e) {
_error = e;
}
// Complete the current async task
_completed = true;
_taskManager.TaskCompleted(_completedSynchronously /*onCallerThread*/); // notify TaskManager
// Wait for pending AsyncTasks (DDB 140655)
if (responseEnded) {
_taskManager.CompleteAllTasksNow(false /*syncCaller*/);
}
}
}
}
|