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
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
|
// <copyright>
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
namespace System.Runtime
{
using System.Diagnostics;
[Fx.Tag.SynchronizationPrimitive(Fx.Tag.BlocksUsing.NonBlocking, SupportsAsync = true, ReleaseMethod = "Complete")]
abstract class AsyncEventArgs : IAsyncEventArgs
{
#if DEBUG
StackTrace startStack;
StackTrace completeStack;
#endif
OperationState state;
object asyncState;
AsyncEventArgsCallback callback;
Exception exception;
public Exception Exception
{
get { return this.exception; }
}
public object AsyncState
{
get { return this.asyncState; }
}
OperationState State
{
set
{
switch (value)
{
case OperationState.PendingCompletion:
if (this.state == OperationState.PendingCompletion)
{
throw Fx.Exception.AsError(new InvalidOperationException(InternalSR.AsyncEventArgsCompletionPending(GetType())));
}
#if DEBUG
if (!Fx.FastDebug)
{
this.startStack = new StackTrace();
}
#endif
break;
case OperationState.CompletedAsynchronously:
case OperationState.CompletedSynchronously:
if (this.state != OperationState.PendingCompletion)
{
throw Fx.Exception.AsError(new InvalidOperationException(InternalSR.AsyncEventArgsCompletedTwice(GetType())));
}
#if DEBUG
if (!Fx.FastDebug)
{
this.completeStack = new StackTrace();
}
#endif
break;
}
this.state = value;
}
}
public void Complete(bool completedSynchronously)
{
this.Complete(completedSynchronously, null);
}
public virtual void Complete(bool completedSynchronously, Exception exception)
{
// The callback will be invoked only if completedSynchronously is false.
// It is the responsibility of the caller or callback to throw the exception.
this.exception = exception;
if (completedSynchronously)
{
this.State = OperationState.CompletedSynchronously;
}
else
{
this.State = OperationState.CompletedAsynchronously;
this.callback(this);
}
}
protected void SetAsyncState(AsyncEventArgsCallback callback, object state)
{
if (callback == null)
{
throw Fx.Exception.ArgumentNull("callback");
}
this.State = OperationState.PendingCompletion;
this.asyncState = state;
this.callback = callback;
}
enum OperationState
{
Created,
PendingCompletion,
CompletedSynchronously,
CompletedAsynchronously,
}
}
class AsyncEventArgs<TArgument> : AsyncEventArgs
{
public TArgument Arguments
{
get;
private set;
}
public virtual void Set(AsyncEventArgsCallback callback, TArgument arguments, object state)
{
this.SetAsyncState(callback, state);
this.Arguments = arguments;
}
}
class AsyncEventArgs<TArgument, TResult> : AsyncEventArgs<TArgument>
{
public TResult Result { get; set; }
}
}
|
