Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
Adding reference source for
System.Data
System.Data.DataSetExtensions
System.Data.Entity
System.Data.Entity.Design
System.Data.Linq
System.Data.SqlXml
System.ServiceModel
System.ServiceModel.Activation
System.ServiceModel.Activities
System.ServiceModel.Channels
System.ServiceModel.Discovery
System.ServiceModel.Internals
System.ServiceModel.Routing
System.ServiceModel.WasHosting
System.ServiceModel.Web
System.Web
System.Web.ApplicationServices
System.Web.DynamicData
System.Web.Entity
System.Web.Entity.Design
System.Web.Extensions
System.Web.Mobile
System.Web.Routing
System.Web.Services
System.Xml
System.Xml.Linq
2016-05-03 00:07:37 +02:00

235 lines
7.4 KiB
C#

//------------------------------------------------------------------------------
// <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*/);
}
}
}
}