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
|
// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
using System.Threading;
using System.Reactive.Disposables;
namespace System.Reactive.Concurrency
{
/// <summary>
/// Represents an object that schedules units of work to run immediately on the current thread.
/// </summary>
/// <seealso cref="Scheduler.Immediate">Singleton instance of this type exposed through this static property.</seealso>
public sealed class ImmediateScheduler : LocalScheduler
{
private static readonly ImmediateScheduler s_instance = new ImmediateScheduler();
ImmediateScheduler()
{
}
/// <summary>
/// Gets the singleton instance of the immediate scheduler.
/// </summary>
public static ImmediateScheduler Instance
{
get { return s_instance; }
}
/// <summary>
/// Schedules an action to be executed.
/// </summary>
/// <typeparam name="TState">The type of the state passed to the scheduled action.</typeparam>
/// <param name="state">State passed to the action to be executed.</param>
/// <param name="action">Action to be executed.</param>
/// <returns>The disposable object used to cancel the scheduled action (best effort).</returns>
/// <exception cref="ArgumentNullException"><paramref name="action"/> is null.</exception>
public override IDisposable Schedule<TState>(TState state, Func<IScheduler, TState, IDisposable> action)
{
if (action == null)
throw new ArgumentNullException("action");
return action(new AsyncLockScheduler(), state);
}
/// <summary>
/// Schedules an action to be executed after dueTime.
/// </summary>
/// <typeparam name="TState">The type of the state passed to the scheduled action.</typeparam>
/// <param name="state">State passed to the action to be executed.</param>
/// <param name="action">Action to be executed.</param>
/// <param name="dueTime">Relative time after which to execute the action.</param>
/// <returns>The disposable object used to cancel the scheduled action (best effort).</returns>
/// <exception cref="ArgumentNullException"><paramref name="action"/> is null.</exception>
public override IDisposable Schedule<TState>(TState state, TimeSpan dueTime, Func<IScheduler, TState, IDisposable> action)
{
if (action == null)
throw new ArgumentNullException("action");
var dt = Scheduler.Normalize(dueTime);
if (dt.Ticks > 0)
{
ConcurrencyAbstractionLayer.Current.Sleep(dt);
}
return action(new AsyncLockScheduler(), state);
}
class AsyncLockScheduler : LocalScheduler
{
AsyncLock asyncLock;
public override IDisposable Schedule<TState>(TState state, Func<IScheduler, TState, IDisposable> action)
{
if (action == null)
throw new ArgumentNullException("action");
var m = new SingleAssignmentDisposable();
if (asyncLock == null)
asyncLock = new AsyncLock();
asyncLock.Wait(() =>
{
if (!m.IsDisposed)
m.Disposable = action(this, state);
});
return m;
}
public override IDisposable Schedule<TState>(TState state, TimeSpan dueTime, Func<IScheduler, TState, IDisposable> action)
{
if (action == null)
throw new ArgumentNullException("action");
if (dueTime.Ticks <= 0)
return Schedule<TState>(state, action);
var timer = ConcurrencyAbstractionLayer.Current.StartStopwatch();
var m = new SingleAssignmentDisposable();
if (asyncLock == null)
asyncLock = new AsyncLock();
asyncLock.Wait(() =>
{
if (!m.IsDisposed)
{
var sleep = dueTime - timer.Elapsed;
if (sleep.Ticks > 0)
{
ConcurrencyAbstractionLayer.Current.Sleep(sleep);
}
if (!m.IsDisposed)
m.Disposable = action(this, state);
}
});
return m;
}
}
}
}
|
