2 2
// The .NET Foundation licenses this file to you under the MIT License.
3 3
// See the LICENSE file in the project root for more information.
4 4 5 +
// The intention is that people will uncomment whichever method call in Main they want to try.
6 +
// The following suppressions prevent warnings due to 'unused' members, and the fact that all of
7 +
// the await statements in Main are commented out to start with
8 +
#pragma warning disable IDE0051, CS1998
9 + 5 10
using System;
6 11
using System.Linq;
7 12
using System.Reactive;
12 17 13 18
namespace Playground
14 19
{
15 -
static class Program
20 +
internal static class Program
16 21
{
17 -
static void Main()
18 -
{
19 -
MainAsync().GetAwaiter().GetResult();
20 - 21 -
Console.ReadLine();
22 -
}
23 - 24 -
static async Task MainAsync()
22 +
private static async Task Main()
25 23
{
26 24
//await AggregateAsync();
27 25
//await AllAsync();
@@ -45,34 +43,36 @@ static async Task MainAsync()
45 43
//await TakeUntilAsync();
46 44
//await TimerAsync();
47 45
//await WhileAsync();
46 + 47 +
Console.ReadLine();
48 48
}
49 49 50 -
static async Task AggregateAsync()
50 +
private static async Task AggregateAsync()
51 51
{
52 52
await AsyncObservable.Range(0, 10).Aggregate(0, (sum, x) => sum + x).SubscribeAsync(Print<int>());
53 53
}
54 54 55 -
static async Task AllAsync()
55 +
private static async Task AllAsync()
56 56
{
57 57
await AsyncObservable.Range(0, 10).All(x => x < 10).SubscribeAsync(Print<bool>());
58 58
}
59 59 60 -
static async Task AnyAsync()
60 +
private static async Task AnyAsync()
61 61
{
62 62
await AsyncObservable.Range(0, 10).Any(x => x == 5).SubscribeAsync(Print<bool>());
63 63
}
64 64 65 -
static async Task AppendAsync()
65 +
private static async Task AppendAsync()
66 66
{
67 67
await AsyncObservable.Range(0, 10).Append(42).SubscribeAsync(Print<int>());
68 68
}
69 69 70 -
static async Task AwaitAsync()
70 +
private static async Task AwaitAsync()
71 71
{
72 72
Console.WriteLine(await AsyncObservable.Range(0, 10));
73 73
}
74 74 75 -
static async Task BufferTimeHoppingAsync()
75 +
private static async Task BufferTimeHoppingAsync()
76 76
{
77 77
await
78 78
AsyncObservable
@@ -82,7 +82,7 @@ static async Task BufferTimeHoppingAsync()
82 82
.SubscribeAsync(Print<string>()); // TODO: Use ForEachAsync.
83 83
}
84 84 85 -
static async Task BufferTimeSlidingAsync()
85 +
private static async Task BufferTimeSlidingAsync()
86 86
{
87 87
await
88 88
AsyncObservable
@@ -93,7 +93,7 @@ static async Task BufferTimeSlidingAsync()
93 93
.SubscribeAsync(Print<string>()); // TODO: Use ForEachAsync.
94 94
}
95 95 96 -
static async Task CombineLatestAsync()
96 +
private static async Task CombineLatestAsync()
97 97
{
98 98
await
99 99
AsyncObservable.CombineLatest(
@@ -104,7 +104,7 @@ static async Task CombineLatestAsync()
104 104
.SubscribeAsync(Print<string>()); // TODO: Use ForEachAsync.
105 105
}
106 106 107 -
static async Task ConcatAsync()
107 +
private static async Task ConcatAsync()
108 108
{
109 109
await
110 110
AsyncObservable.Concat(
@@ -116,7 +116,7 @@ static async Task ConcatAsync()
116 116
.SubscribeAsync(Print<int>()); // TODO: Use ForEachAsync.
117 117
}
118 118 119 -
static async Task DelayAsync()
119 +
private static async Task DelayAsync()
120 120
{
121 121
await
122 122
AsyncObservable.Timer(TimeSpan.Zero, TimeSpan.FromSeconds(1))
@@ -127,7 +127,7 @@ static async Task DelayAsync()
127 127
.SubscribeAsync(Print<string>()); // TODO: Use ForEachAsync.
128 128
}
129 129 130 -
static async Task GroupByAsync()
130 +
private static async Task GroupByAsync()
131 131
{
132 132
await
133 133
AsyncObservable.Interval(TimeSpan.FromMilliseconds(250))
@@ -140,7 +140,7 @@ static async Task GroupByAsync()
140 140
});
141 141
}
142 142 143 -
static async Task GroupBySelectManyAsync()
143 +
private static async Task GroupBySelectManyAsync()
144 144
{
145 145
await
146 146
AsyncObservable.Interval(TimeSpan.FromMilliseconds(250))
@@ -151,7 +151,7 @@ static async Task GroupBySelectManyAsync()
151 151
.SubscribeAsync(Print<string>());
152 152
}
153 153 154 -
static async Task MergeAsync()
154 +
private static async Task MergeAsync()
155 155
{
156 156
var subject = new SequentialSimpleAsyncSubject<IAsyncObservable<int>>();
157 157
@@ -167,17 +167,17 @@ static async Task MergeAsync()
167 167
await subject.OnCompletedAsync();
168 168
}
169 169 170 -
static async Task PrependAsync()
170 +
private static async Task PrependAsync()
171 171
{
172 172
await AsyncObservable.Range(0, 10).Prepend(42).SubscribeAsync(Print<int>());
173 173
}
174 174 175 -
static async Task RangeAsync()
175 +
private static async Task RangeAsync()
176 176
{
177 177
await AsyncObservable.Range(0, 10).SubscribeAsync(PrintAsync<int>()); // TODO: Use ForEachAsync.
178 178
}
179 179 180 -
static async Task ReplaySubjectAsync()
180 +
private static async Task ReplaySubjectAsync()
181 181
{
182 182
var sub = new SequentialReplayAsyncSubject<int>(5);
183 183
@@ -208,12 +208,12 @@ static async Task ReplaySubjectAsync()
208 208
await sub.OnNextAsync(47);
209 209
}
210 210 211 -
static async Task ReturnAsync()
211 +
private static async Task ReturnAsync()
212 212
{
213 213
await AsyncObservable.Return(42).SubscribeAsync(Print<int>());
214 214
}
215 215 216 -
static async Task SelectManyAsync()
216 +
private static async Task SelectManyAsync()
217 217
{
218 218
var res = from i in AsyncObservable.Range(0, 10)
219 219
from j in AsyncObservable.Range(i * 10, 10)
@@ -222,7 +222,7 @@ from j in AsyncObservable.Range(i * 10, 10)
222 222
await res.SubscribeAsync(Print<string>());
223 223
}
224 224 225 -
static async Task SubjectAsync()
225 +
private static async Task SubjectAsync()
226 226
{
227 227
var subject = new SequentialSimpleAsyncSubject<int>();
228 228
@@ -238,24 +238,24 @@ static async Task SubjectAsync()
238 238
await subject.OnCompletedAsync();
239 239
}
240 240 241 -
static async Task TakeUntilAsync()
241 +
private static async Task TakeUntilAsync()
242 242
{
243 243
await AsyncObservable.Range(0, int.MaxValue).TakeUntil(DateTimeOffset.Now.AddSeconds(5)).SubscribeAsync(Print<int>()); // TODO: Use ForEachAsync.
244 244
}
245 245 246 -
static async Task TimerAsync()
246 +
private static async Task TimerAsync()
247 247
{
248 248
await AsyncObservable.Timer(TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(2)).Take(5).Select(_ => DateTimeOffset.Now).SubscribeAsync(Print<DateTimeOffset>()); // TODO: Use ForEachAsync.
249 249
}
250 250 251 -
static async Task WhileAsync()
251 +
private static async Task WhileAsync()
252 252
{
253 253
var i = 0;
254 254 255 255
await AsyncObservable.While(() => ++i < 5, AsyncObservable.Range(0, 5)).SubscribeAsync(Print<int>()); // TODO: Use ForEachAsync.
256 256
}
257 257 258 -
static IAsyncObserver<T> Print<T>()
258 +
private static IAsyncObserver<T> Print<T>()
259 259
{
260 260
return AsyncObserver.Create<T>(
261 261
x =>
@@ -276,7 +276,7 @@ static IAsyncObserver<T> Print<T>()
276 276
);
277 277
}
278 278 279 -
static IAsyncObserver<T> PrintAsync<T>()
279 +
private static IAsyncObserver<T> PrintAsync<T>()
280 280
{
281 281
return AsyncObserver.Create<T>(
282 282
async x =>
RetroSearch is an open source project built by @garambo | Open a GitHub Issue
Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo
HTML:
3.2
| Encoding:
UTF-8
| Version:
0.7.4