1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
|
//------------------------------------------------------------------------------
// <copyright file="PageAsyncTask.cs" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
//------------------------------------------------------------------------------
namespace System.Web.UI {
using System;
using System.Threading;
using System.Threading.Tasks;
using System.Web;
using System.Web.Util;
// Public class to serve as an interface between ASP.NET's synchronization systems and the user code to be executed asynchronously
public sealed class PageAsyncTask {
// APM
public PageAsyncTask(BeginEventHandler beginHandler, EndEventHandler endHandler, EndEventHandler timeoutHandler, Object state)
: this(beginHandler, endHandler, timeoutHandler, state, executeInParallel: false) {
}
// APM
public PageAsyncTask(BeginEventHandler beginHandler, EndEventHandler endHandler, EndEventHandler timeoutHandler, Object state, bool executeInParallel)
: this(beginHandler, endHandler, timeoutHandler, state, executeInParallel, currentMode: SynchronizationContextUtil.CurrentMode) {
}
// 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;
}
// TAP
public PageAsyncTask(Func<Task> handler)
: this(WrapParameterlessTaskHandler(handler)) {
}
public PageAsyncTask(Func<CancellationToken, Task> handler)
: this(handler, currentMode: SynchronizationContextUtil.CurrentMode) {
}
// TAP
internal PageAsyncTask(Func<CancellationToken, Task> handler, SynchronizationContextMode currentMode) {
if (handler == null) {
throw new ArgumentNullException("handler");
}
// The legacy PageAsyncTaskManager doesn't support TAP methods
SynchronizationContextUtil.ValidateMode(currentMode, requiredMode: SynchronizationContextMode.Normal, specificErrorMessage: SR.SynchronizationContextUtil_TaskReturningPageAsyncMethodsNotCompatible);
TaskHandler = handler;
}
#region Legacy properties
// These properties were present in the original PageAsyncTask type, so they must remain in this new type, even if they're unused.
public BeginEventHandler BeginHandler { get; private set; }
public EndEventHandler EndHandler { get; private set; }
public bool ExecuteInParallel { get; private set; }
public object State { get; private set; }
public EndEventHandler TimeoutHandler { get; private set; }
#endregion
// For TAP
internal Func<CancellationToken, Task> TaskHandler { get; private set; }
private static Func<CancellationToken, Task> WrapParameterlessTaskHandler(Func<Task> handler) {
return (handler != null)
? (Func<CancellationToken, Task>)(_ => handler())
: null;
}
}
}
|
