mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
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
387 lines
12 KiB
C#
387 lines
12 KiB
C#
//------------------------------------------------------------------------------
|
|
// <copyright file="LegacyPageAsyncTaskManager.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;
|
|
|
|
internal class LegacyPageAsyncTaskManager {
|
|
private Page _page;
|
|
private HttpApplication _app;
|
|
private HttpAsyncResult _asyncResult;
|
|
private bool _failedToStart;
|
|
private ArrayList _tasks;
|
|
private DateTime _timeoutEnd;
|
|
private volatile bool _timeoutEndReached;
|
|
private volatile bool _inProgress;
|
|
private int _tasksStarted;
|
|
private int _tasksCompleted;
|
|
private WaitCallback _resumeTasksCallback;
|
|
private Timer _timeoutTimer;
|
|
|
|
internal LegacyPageAsyncTaskManager(Page page) {
|
|
_page = page;
|
|
_app = page.Context.ApplicationInstance;
|
|
_tasks = new ArrayList();
|
|
_resumeTasksCallback = new WaitCallback(this.ResumeTasksThreadpoolThread);
|
|
}
|
|
|
|
internal HttpApplication Application {
|
|
get { return _app; }
|
|
}
|
|
|
|
internal void AddTask(LegacyPageAsyncTask task) {
|
|
_tasks.Add(task);
|
|
}
|
|
|
|
internal bool AnyTasksRemain {
|
|
get {
|
|
for (int i = 0; i < _tasks.Count; i++) {
|
|
LegacyPageAsyncTask task = (LegacyPageAsyncTask)_tasks[i];
|
|
if (!task.Started) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
internal bool FailedToStartTasks {
|
|
get { return _failedToStart; }
|
|
}
|
|
|
|
internal bool TaskExecutionInProgress {
|
|
get { return _inProgress; }
|
|
}
|
|
|
|
private Exception AnyTaskError {
|
|
get {
|
|
for (int i = 0; i < _tasks.Count; i++) {
|
|
LegacyPageAsyncTask task = (LegacyPageAsyncTask)_tasks[i];
|
|
if (task.Error != null) {
|
|
return task.Error;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
|
|
private bool TimeoutEndReached {
|
|
get {
|
|
if (!_timeoutEndReached && (DateTime.UtcNow >= _timeoutEnd)) {
|
|
_timeoutEndReached = true;
|
|
}
|
|
|
|
return _timeoutEndReached;
|
|
}
|
|
}
|
|
|
|
private void WaitForAllStartedTasks(bool syncCaller, bool forceTimeout) {
|
|
// don't foreach because the ArrayList could be modified by tasks' end methods
|
|
for (int i = 0; i < _tasks.Count; i++) {
|
|
LegacyPageAsyncTask task = (LegacyPageAsyncTask)_tasks[i];
|
|
|
|
if (!task.Started || task.Completed) {
|
|
continue;
|
|
}
|
|
|
|
// need to wait, but no longer than timeout.
|
|
if (!forceTimeout && !TimeoutEndReached) {
|
|
DateTime utcNow = DateTime.UtcNow;
|
|
|
|
if (utcNow < _timeoutEnd) { // re-check not to wait negative time span
|
|
WaitHandle waitHandle = task.AsyncResult.AsyncWaitHandle;
|
|
|
|
if (waitHandle != null) {
|
|
bool signaled = waitHandle.WaitOne(_timeoutEnd - utcNow, false);
|
|
|
|
if (signaled && task.Completed) {
|
|
// a task could complete before timeout expires
|
|
// in this case go to the next task
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// start polling after timeout reached (or if there is no handle to wait on)
|
|
|
|
bool taskTimeoutForced = false;
|
|
|
|
while (!task.Completed) {
|
|
if (forceTimeout || (!taskTimeoutForced && TimeoutEndReached)) {
|
|
task.ForceTimeout(syncCaller);
|
|
taskTimeoutForced = true;
|
|
}
|
|
else {
|
|
Thread.Sleep(50);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
internal void RegisterHandlersForPagePreRenderCompleteAsync() {
|
|
_page.AddOnPreRenderCompleteAsync(
|
|
new BeginEventHandler(this.BeginExecuteAsyncTasks),
|
|
new EndEventHandler(this.EndExecuteAsyncTasks));
|
|
}
|
|
|
|
private IAsyncResult BeginExecuteAsyncTasks(object sender, EventArgs e, AsyncCallback cb, object extraData) {
|
|
return ExecuteTasks(cb, extraData);
|
|
}
|
|
|
|
private void EndExecuteAsyncTasks(IAsyncResult ar) {
|
|
_asyncResult.End();
|
|
}
|
|
|
|
internal HttpAsyncResult ExecuteTasks(AsyncCallback callback, Object extraData) {
|
|
_failedToStart = false;
|
|
_timeoutEnd = DateTime.UtcNow + _page.AsyncTimeout;
|
|
_timeoutEndReached = false;
|
|
_tasksStarted = 0;
|
|
_tasksCompleted = 0;
|
|
|
|
_asyncResult = new HttpAsyncResult(callback, extraData);
|
|
|
|
bool waitUntilDone = (callback == null);
|
|
|
|
if (waitUntilDone) {
|
|
// when requested to wait for tasks, before starting tasks
|
|
// make sure that the lock can be suspended.
|
|
try {} finally {
|
|
try {
|
|
// disassociating allows other pending work to take place, and associating will block until that work is complete
|
|
_app.Context.SyncContext.DisassociateFromCurrentThread();
|
|
_app.Context.SyncContext.AssociateWithCurrentThread();
|
|
}
|
|
catch (SynchronizationLockException) {
|
|
_failedToStart = true;
|
|
throw new InvalidOperationException(SR.GetString(SR.Async_tasks_wrong_thread));
|
|
}
|
|
}
|
|
}
|
|
|
|
_inProgress = true;
|
|
|
|
try {
|
|
// all work done here:
|
|
ResumeTasks(waitUntilDone, true /*onCallerThread*/);
|
|
}
|
|
finally {
|
|
if (waitUntilDone) {
|
|
_inProgress = false;
|
|
}
|
|
}
|
|
|
|
return _asyncResult;
|
|
}
|
|
|
|
private void ResumeTasks(bool waitUntilDone, bool onCallerThread) {
|
|
|
|
#if DBG
|
|
Debug.Trace("Async", "TaskManager.ResumeTasks: onCallerThread=" + onCallerThread +
|
|
", _tasksCompleted=" + _tasksCompleted + ", _tasksStarted=" + _tasksStarted);
|
|
|
|
if (waitUntilDone) {
|
|
// must be on caller thread to wait
|
|
Debug.Assert(onCallerThread);
|
|
}
|
|
#endif
|
|
|
|
// artifically increment the task count by one
|
|
// to make sure _tasksCompleted doesn't become equal to _tasksStarted during this method
|
|
Interlocked.Increment(ref _tasksStarted);
|
|
|
|
try {
|
|
if (onCallerThread) {
|
|
ResumeTasksPossiblyUnderLock(waitUntilDone);
|
|
}
|
|
else {
|
|
using (_app.Context.SyncContext.AcquireThreadLock()) {
|
|
ThreadContext threadContext = null;
|
|
try {
|
|
threadContext = _app.OnThreadEnter();
|
|
ResumeTasksPossiblyUnderLock(waitUntilDone);
|
|
}
|
|
finally {
|
|
if (threadContext != null) {
|
|
threadContext.DisassociateFromCurrentThread();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
finally {
|
|
// complete the bogus task introduced with incrementing _tasksStarted at the beginning
|
|
TaskCompleted(onCallerThread);
|
|
}
|
|
}
|
|
|
|
private void ResumeTasksPossiblyUnderLock(bool waitUntilDone) {
|
|
|
|
while (AnyTasksRemain) {
|
|
bool someTasksStarted = false;
|
|
bool realAsyncTaskStarted = false;
|
|
bool parallelTaskStarted = false;
|
|
|
|
// start the tasks
|
|
|
|
for (int i = 0; i < _tasks.Count; i++) {
|
|
LegacyPageAsyncTask task = (LegacyPageAsyncTask)_tasks[i];
|
|
|
|
if (task.Started) {
|
|
continue; // ignore already started tasks
|
|
}
|
|
|
|
if (parallelTaskStarted && !task.ExecuteInParallel) {
|
|
// already started a parallel task, so need to ignore sequential ones
|
|
continue;
|
|
}
|
|
|
|
someTasksStarted = true;
|
|
Interlocked.Increment(ref _tasksStarted);
|
|
|
|
task.Start(this, _page, EventArgs.Empty);
|
|
|
|
if (task.CompletedSynchronously) {
|
|
continue; // ignore the ones completed synchornously
|
|
}
|
|
|
|
// at this point a truly async task has been started
|
|
realAsyncTaskStarted = true;
|
|
|
|
if (task.ExecuteInParallel) {
|
|
parallelTaskStarted = true;
|
|
}
|
|
else {
|
|
// only one sequential task at a time
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!someTasksStarted) {
|
|
// no tasks to start, all done
|
|
break;
|
|
}
|
|
|
|
if (!TimeoutEndReached && realAsyncTaskStarted && !waitUntilDone) {
|
|
// make sure we have a timer going
|
|
StartTimerIfNeeeded();
|
|
|
|
// unwind the stack for async callers
|
|
break;
|
|
}
|
|
|
|
// need to wait until tasks comlete, but the wait
|
|
// must be outside of the lock (deadlock otherwise)
|
|
|
|
// this code is always already under lock
|
|
bool locked = true;
|
|
|
|
try {
|
|
// outer code has lock(_app) { ... }
|
|
// the assumption here is that Disassociate undoes the lock
|
|
try {} finally {
|
|
_app.Context.SyncContext.DisassociateFromCurrentThread();
|
|
locked = false;
|
|
}
|
|
|
|
WaitForAllStartedTasks(true /*syncCaller*/, false /*forceTimeout*/);
|
|
}
|
|
finally {
|
|
if (!locked) {
|
|
_app.Context.SyncContext.AssociateWithCurrentThread();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void ResumeTasksThreadpoolThread(Object data) {
|
|
ResumeTasks(false /*waitUntilDone*/, false /*onCallerThread*/);
|
|
}
|
|
|
|
internal void TaskCompleted(bool onCallerThread) {
|
|
int newTasksCompleted = Interlocked.Increment(ref _tasksCompleted);
|
|
|
|
Debug.Trace("Async", "TaskManager.TaskCompleted: onCallerThread=" + onCallerThread +
|
|
", _tasksCompleted=" + newTasksCompleted + ", _tasksStarted=" + _tasksStarted);
|
|
|
|
if (newTasksCompleted < _tasksStarted) {
|
|
// need to wait for more completions
|
|
return;
|
|
}
|
|
|
|
// check if any tasks remain not started
|
|
if (!AnyTasksRemain) {
|
|
// can complete the caller - all done
|
|
_inProgress = false;
|
|
_asyncResult.Complete(onCallerThread, null /*result*/, AnyTaskError);
|
|
return;
|
|
}
|
|
|
|
// need to resume executing tasks
|
|
if (Thread.CurrentThread.IsThreadPoolThread) {
|
|
// if on thread pool thread, use the current thread
|
|
ResumeTasks(false /*waitUntilDone*/, onCallerThread);
|
|
}
|
|
else {
|
|
// if on a non-threadpool thread, requeue
|
|
ThreadPool.QueueUserWorkItem(_resumeTasksCallback);
|
|
}
|
|
}
|
|
|
|
private void StartTimerIfNeeeded() {
|
|
if (_timeoutTimer != null) {
|
|
return;
|
|
}
|
|
|
|
// calculate the wait time
|
|
DateTime utcNow = DateTime.UtcNow;
|
|
|
|
if (utcNow >= _timeoutEnd) {
|
|
return;
|
|
}
|
|
|
|
double timerPeriod = (_timeoutEnd - utcNow).TotalMilliseconds;
|
|
|
|
if (timerPeriod >= (double)Int32.MaxValue) {
|
|
// timeout too big to launch timer (> ~25 days, plenty enough for an async page task)
|
|
return;
|
|
}
|
|
|
|
// start the timer
|
|
Debug.Trace("Async", "Starting timeout timer for " + timerPeriod + " ms");
|
|
_timeoutTimer = new Timer(new TimerCallback(this.TimeoutTimerCallback), null, (int)timerPeriod, -1);
|
|
}
|
|
|
|
internal void DisposeTimer() {
|
|
Timer timer = _timeoutTimer;
|
|
if (timer != null && Interlocked.CompareExchange(ref _timeoutTimer, null, timer) == timer) {
|
|
timer.Dispose();
|
|
}
|
|
}
|
|
|
|
private void TimeoutTimerCallback(Object state) {
|
|
DisposeTimer();
|
|
|
|
// timeout everything that's left
|
|
WaitForAllStartedTasks(false /*syncCaller*/, false /*forceTimeout*/);
|
|
}
|
|
|
|
internal void CompleteAllTasksNow(bool syncCaller) {
|
|
WaitForAllStartedTasks(syncCaller, true /*forceTimeout*/);
|
|
}
|
|
}
|
|
|
|
}
|