protected override async Task <string> EnqueueImplAsync(T data)
{
string id = Guid.NewGuid().ToString("N");
_logger.Trace("Queue {0} enqueue item: {1}", _options.Name, id);
if (!await OnEnqueuingAsync(data).AnyContext())
{
return(null);
}
var entry = new QueueEntry <T>(id, data.DeepClone(), this, SystemClock.UtcNow, 0);
_queue.Enqueue(entry);
_logger.Trace("Enqueue: Set Event");
_autoResetEvent.Set();
Interlocked.Increment(ref _enqueuedCount);
await OnEnqueuedAsync(entry).AnyContext();
_logger.Trace("Enqueue done");
return(id);
}
public void WhenEventIsBecameSignaled_WaitedClientsShouldStopWaitedwithFIFO()
{
var sut = new AsyncAutoResetEvent();
var task1 = Task.Run(() => sut.Wait());
Thread.Sleep(300);
var task2 = Task.Run(() => sut.Wait());
Thread.Sleep(300);
var task3 = Task.Run(() => sut.Wait());
Thread.Sleep(300);
var task = Task.WhenAny(task1, task2, task3);
sut.Set();
var finishedTask = task.Result;
Assert.AreEqual(finishedTask, task1);
task = Task.WhenAny(task2, task3);
sut.Set();
finishedTask = task.Result;
Assert.AreEqual(finishedTask, task2);
}
public void SetAuthenticationStateTask(Task <AuthenticationState> task)
{
if (_isHoldingFakeAuthTask)
{
_forFakeStateTaskRealTask = task;
_isHoldingFakeAuthTask = false;
if (!_initialStateReady.IsSet)
{
_initialStateReady.Set();
}
//NotifyAuthenticationStateChanged(_authenticationStateTask);
}
else
{
_authenticationStateTask = task;
if (!_initialStateReady.IsSet)
{
_initialStateReady.Set();
}
NotifyAuthenticationStateChanged(_authenticationStateTask);
}
}
// Authorization code flow using OIDAuthState automatic code exchanges.
public async Task <AuthInfo> LoginAsync()
{
//var issuer = new NSUrl(Constants.Issuer);
var redirectUri = new NSUrl(Constants.RedirectUri);
//Console.WriteLine($"Fetching configuration for issuer: {issuer}");
try
{
// discovers endpoints
var configuration =
await AuthorizationService.DiscoverServiceConfigurationForDiscoveryAsync(
new NSUrl(Constants.DiscoveryEndpoint));
Console.WriteLine($"Got configuration: {configuration}");
// builds authentication request
var request = new AuthorizationRequest(configuration, Constants.ClientId,
new string[] { Scope.OpenId, Scope.Profile, "offline_access" }, redirectUri, ResponseType.Code, null);
// performs authentication request
var appDelegate = (AppDelegate)UIApplication.SharedApplication.Delegate;
Console.WriteLine($"Initiating authorization request with scope: {request.Scope}");
appDelegate.CurrentAuthorizationFlow = AuthState.PresentAuthorizationRequest(request,
UIKit.UIApplication.SharedApplication.KeyWindow.RootViewController, (authState, error) =>
{
if (authState != null)
{
_authState = authState;
Console.WriteLine(
$"Got authorization tokens. Access token: {authState.LastTokenResponse.AccessToken}");
}
else
{
Console.WriteLine($"Authorization error: {error.LocalizedDescription}");
_authState = null;
}
//We need this line to tell the Login method to return the result
_loginResultWaitHandle.Set();
});
}
catch (Exception ex)
{
Console.WriteLine($"Error retrieving discovery document: {ex}");
_authState = null;
//We need this line to tell the Login method to return the result
_loginResultWaitHandle.Set();
}
await _loginResultWaitHandle.WaitAsync();
return(new AuthInfo()
{
IsAuthorized = _authState?.IsAuthorized ?? false,
AccessToken = _authState?.LastTokenResponse?.AccessToken,
IdToken = _authState?.LastTokenResponse?.IdToken,
RefreshToken = _authState?.LastTokenResponse?.RefreshToken,
Scope = _authState?.LastTokenResponse?.Scope
});
}
public async Task AsyncAutoResetEvent()
{
var aare = new AsyncAutoResetEvent();
var globalI = 0;
#pragma warning disable 4014
Task.Run(async() =>
#pragma warning restore 4014
{
await aare.WaitOneAsync(CancellationToken.None);
globalI += 1;
});
#pragma warning disable 4014
Task.Run(async() =>
#pragma warning restore 4014
{
await aare.WaitOneAsync(CancellationToken.None);
globalI += 2;
});
await Task.Delay(500);
aare.Set();
await Task.Delay(500);
aare.Set();
await Task.Delay(100);
Assert.AreEqual(3, globalI);
}
private async Task Poll()
{
var headPosition = AllStreamPosition.None;
var previousHeadPosition = headPosition;
while (!_disposed.IsCancellationRequested)
{
try
{
headPosition = await _getHeadPosition(_disposed.Token).ConfigureAwait(false);
}
catch (Exception ex)
{
await Extensions.HandleException(() => _onError(ex, headPosition)).ConfigureAwait(false);
}
if (headPosition > previousHeadPosition)
{
_autoResetEvent.Set();
previousHeadPosition = headPosition;
}
else
{
await Task.Delay(_interval, _disposed.Token);
}
}
}
internal void NotifyOfCallback(Intent intent)
{
try
{
if (!intent.HasExtra(Constants.AuthStateKey))
{
_authState = null;
}
else
{
try
{
_authState = AuthState.JsonDeserialize(intent.GetStringExtra(Constants.AuthStateKey));
}
catch (JSONException ex)
{
Console.WriteLine("Malformed AuthState JSON saved: " + ex);
_authState = null;
}
}
if (_authState != null)
{
AuthorizationResponse response = AuthorizationResponse.FromIntent(intent);
AuthorizationException authEx = AuthorizationException.FromIntent(intent);
_authState.Update(response, authEx);
if (response != null)
{
Console.WriteLine("Received AuthorizationResponse.");
try
{
var clientAuthentication = _authState.ClientAuthentication;
}
catch (ClientAuthenticationUnsupportedAuthenticationMethod ex)
{
_loginResultWaitHandle.Set();
Console.WriteLine(
"Token request cannot be made, client authentication for the token endpoint could not be constructed: " +
ex);
return;
}
_authService.PerformTokenRequest(response.CreateTokenExchangeRequest(), ReceivedTokenResponse);
}
else
{
Console.WriteLine("Authorization failed: " + authEx);
}
}
else
{
_loginResultWaitHandle.Set();
}
}
catch (Exception)
{
_loginResultWaitHandle.Set();
}
}
public static async Task <SocketError> ExecuteAsync(this Socket socket,
Func <Socket, Func <SocketAsyncEventArgs, bool> > methodPredicate,
SocketAsyncEventArgs socketAsyncEventArgs,
CancellationToken cancellationToken)
{
var asyncAutoResetEvent = new AsyncAutoResetEvent(false);
socketAsyncEventArgs.Completed += (sender,
args) =>
{
asyncAutoResetEvent.Set();
};
var method = methodPredicate.Invoke(socket);
var async = method.Invoke(socketAsyncEventArgs);
if (!async)
{
asyncAutoResetEvent.Set();
}
await asyncAutoResetEvent.WaitAsync(cancellationToken);
return(socketAsyncEventArgs.SocketError);
}
/// <summary>
/// <para>Events:</para>
/// <para>@emits routerclose</para>
/// <para>@emits @close</para>
/// <para>@emits @newproducer - (producer: Producer)</para>
/// <para>@emits @producerclose - (producer: Producer)</para>
/// <para>@emits @newdataproducer - (dataProducer: DataProducer)</para>
/// <para>@emits @dataproducerclose - (dataProducer: DataProducer)</para>
/// <para>Observer events:</para>
/// <para>@emits close</para>
/// <para>@emits newproducer - (producer: Producer)</para>
/// <para>@emits newconsumer - (producer: Producer)</para>
/// <para>@emits newdataproducer - (dataProducer: DataProducer)</para>
/// <para>@emits newdataconsumer - (dataProducer: DataProducer)</para>
/// </summary>
/// <param name="loggerFactory"></param>
/// <param name="transportInternalData"></param>
/// <param name="sctpParameters"></param>
/// <param name="sctpState"></param>
/// <param name="channel"></param>
/// <param name="payloadChannel"></param>
/// <param name="appData"></param>
/// <param name="getRouterRtpCapabilities"></param>
/// <param name="getProducerById"></param>
/// <param name="getDataProducerById"></param>
protected Transport(ILoggerFactory loggerFactory,
TransportInternalData transportInternalData,
SctpParameters?sctpParameters,
SctpState?sctpState,
Channel channel,
PayloadChannel payloadChannel,
Dictionary <string, object>?appData,
Func <RtpCapabilities> getRouterRtpCapabilities,
Func <string, Producer?> getProducerById,
Func <string, DataProducer?> getDataProducerById
)
{
_loggerFactory = loggerFactory;
_logger = loggerFactory.CreateLogger <Transport>();
// Internal
Internal = transportInternalData;
// Data
SctpParameters = sctpParameters;
SctpState = sctpState;
Channel = channel;
PayloadChannel = payloadChannel;
AppData = appData;
GetRouterRtpCapabilities = getRouterRtpCapabilities;
GetProducerById = getProducerById;
GetDataProducerById = getDataProducerById;
ProducersLock.Set();
ConsumersLock.Set();
DataProducersLock.Set();
DataConsumersLock.Set();
CloseLock.Set();
}
public async Task When_all_stream_subscription_disposed_while_handling_messages_then_should_drop_subscription_with_reason_Disposed()
{
using (var fixture = GetFixture())
{
using (var store = await fixture.GetStreamStore())
{
string streamId = "stream-1";
var droppedTcs = new TaskCompletionSource <SubscriptionDroppedReason>();
var handler = new AsyncAutoResetEvent();
var subscription = store.SubscribeToAll(
Position.End,
async(_, __) =>
{
handler.Set();
await handler.WaitAsync().WithTimeout(); // block "handling" while a dispose occurs
},
(_, reason, __) =>
{
droppedTcs.SetResult(reason);
});
// First message is blocked in handling, the second is co-operatively cancelled
await subscription.Started;
await AppendMessages(store, streamId, 2);
await handler.WaitAsync().WithTimeout(5000);
subscription.Dispose();
handler.Set();
var droppedReason = await droppedTcs.Task.WithTimeout();
droppedReason.ShouldBe(SubscriptionDroppedReason.Disposed);
}
}
}
protected override async Task <string> EnqueueImplAsync(T data, QueueEntryOptions options)
{
string id = Guid.NewGuid().ToString("N");
_logger.LogTrace("Queue {Name} enqueue item: {Id}", _options.Name, id);
if (!await OnEnqueuingAsync(data, options).AnyContext())
{
return(null);
}
var entry = new QueueEntry <T>(id, options?.CorrelationId, data.DeepClone(), this, SystemClock.UtcNow, 0);
entry.Properties.AddRange(options?.Properties);
_queue.Enqueue(entry);
_logger.LogTrace("Enqueue: Set Event");
_autoResetEvent.Set();
Interlocked.Increment(ref _enqueuedCount);
await OnEnqueuedAsync(entry).AnyContext();
_logger.LogTrace("Enqueue done");
return(id);
}
protected override async Task <string> EnqueueImplAsync(T data, QueueEntryOptions options)
{
string id = Guid.NewGuid().ToString("N");
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug("Queue {Name} enqueue item: {EntryId}", _options.Name, id);
}
bool isTraceLogLevelEnabled = _logger.IsEnabled(LogLevel.Trace);
if (!await OnEnqueuingAsync(data, options).AnyContext())
{
if (isTraceLogLevelEnabled)
{
_logger.LogTrace("Aborting enqueue item: {EntryId}", id);
}
return(null);
}
var now = SystemClock.UtcNow;
var envelope = new RedisPayloadEnvelope <T> {
Properties = options.Properties,
CorrelationId = options.CorrelationId,
Value = data
};
bool success = await Run.WithRetriesAsync(() => _cache.AddAsync(GetPayloadKey(id), envelope, _payloadTimeToLive), logger : _logger).AnyContext();
if (!success)
{
throw new InvalidOperationException("Attempt to set payload failed.");
}
await Run.WithRetriesAsync(() => Task.WhenAll(
_cache.SetAsync(GetEnqueuedTimeKey(id), now.Ticks, _payloadTimeToLive),
Database.ListLeftPushAsync(_queueListName, id)
), logger : _logger).AnyContext();
try {
_autoResetEvent.Set();
await Run.WithRetriesAsync(() => _subscriber.PublishAsync(GetTopicName(), id), logger : _logger).AnyContext();
} catch (Exception ex) {
if (isTraceLogLevelEnabled)
{
_logger.LogTrace(ex, "Error publishing topic message");
}
}
Interlocked.Increment(ref _enqueuedCount);
var entry = new QueueEntry <T>(id, null, data, this, now, 0);
await OnEnqueuedAsync(entry).AnyContext();
if (isTraceLogLevelEnabled)
{
_logger.LogTrace("Enqueue done");
}
return(id);
}
private void AddMessage(Message message)
{
lock (_messages)
{
_messages.Add(message);
}
_updateAvailableEvent.Set();
}
public void OnCompleted()
{
lock (queue)
{
completed = true;
}
next.Set();
}
async Task MainLoopAsync(CancellationToken cancel)
{
try
{
while (true)
{
if (cancel.IsCancellationRequested)
{
return;
}
while (true)
{
if (this.SendQueue.TryDequeue(out Datagram? dg) == false)
{
break;
}
try
{
IPAddress ip = await this.TcpIp.GetIpAsync(this.Options.SyslogServerHostname, cancel: cancel, orderBy : ip => (long)ip.AddressFamily *(this.Options.PreferIPv6 ? -1 : 1));
DatagramSock?sock = null;
if (ip.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork)
{
sock = this.UdpSock_IPv4;
}
else if (ip.AddressFamily == System.Net.Sockets.AddressFamily.InterNetworkV6)
{
sock = this.UdpSock_IPv6;
}
if (sock != null)
{
await sock.SendDatagramAsync(new Datagram(dg.Data, new IPEndPoint(ip, this.Options.SyslogServerPort)), cancel, this.Options.SendTimeoutMsecs, true);
}
}
catch
{
await cancel._WaitUntilCanceledAsync(256); // 念のため
}
}
if (cancel.IsCancellationRequested)
{
return;
}
EmptyEvent.Set(true);
await TaskUtil.WaitObjectsAsync(cancels : cancel._SingleList(), events : this.NewDataArrivedEvent._SingleList());
}
}
finally
{
EmptyEvent.Set(true);
}
}
public ProcessFacade(string fileName, string arguments, string workingDirectory,
ExecutionContext executionContext, string displayName,
bool showOutput, bool showError, bool killOnDispose, OSPlatform platform,
CancellationToken cancellationToken)
{
this.executionContext = executionContext;
this.showOutput = showOutput;
this.showError = showError;
this.killOnDispose = killOnDispose;
this.platform = platform;
this.displayName = displayName;
ProcessStartInfo processInfo = new ProcessStartInfo(fileName, arguments)
{
CreateNoWindow = true,
UseShellExecute = false,
RedirectStandardInput = true,
RedirectStandardOutput = true,
RedirectStandardError = true
};
if (!string.IsNullOrEmpty(workingDirectory))
{
processInfo.WorkingDirectory = workingDirectory;
}
executionContext.WriteVerbose($"Starting process {processInfo.FileName} {processInfo.Arguments} in {processInfo.WorkingDirectory}.");
internalProcess = System.Diagnostics.Process.Start(processInfo);
if (internalProcess != null && !internalProcess.HasExited)
{
try
{
processName = internalProcess.ProcessName;
internalProcess.OutputDataReceived += InternalProcessOnOutputDataReceived;
internalProcess.ErrorDataReceived += InternalProcessOnErrorDataReceived;
internalProcess.EnableRaisingEvents = true;
internalProcess.Exited += InternalProcessOnExited;
internalProcess.BeginOutputReadLine();
outputReadStarted = true;
internalProcess.BeginErrorReadLine();
errorReadStarted = true;
}
catch (Exception e)
{
processName = "unknown process";
executionContext.WriteWarning($"Error while starting process: {e}", false);
//this happens when the process exits somewhere in this if clause
}
cancellationToken.Register(Dispose);
}
else
{
processName = "unknown process";
exitedResetEvent.Set();
}
}
private async Task ReadBlocksAsync()
{
var cancellationToken = CancellationTokenSource.Token;
try
{
while (!EndOfStream && !cancellationToken.IsCancellationRequested)
{
var message = Context.Request.Clone();
message.Id = 0;
// Strip out any block options
message.Options.RemoveAll(o => o is Block1 || o is Block2);
message.Options.Add(new Block2(_readBlockNumber, BlockSizeInternal));
Context.MessageId = await Context.Client.SendAsync(message, Endpoint, cancellationToken);
var response = await Context.Client.GetResponseAsync(Context.MessageId, cancellationToken);
if (!response.Code.IsSuccess())
{
throw new CoapBlockException("Error occured while reading blocks from remote endpoint",
CoapException.FromCoapMessage(response), response.Code);
}
var block2 = response.Options.Get <Block2>();
if (block2.BlockNumber != _readBlockNumber)
{
throw new CoapBlockException("Received incorrect block number from remote host");
}
_readBlockNumber++;
_reader.Enqueue(response.Payload, 0, response.Payload.Length);
_readerEvent.Set();
if (!response.Options.Get <Block2>().IsMoreFollowing)
{
EndOfStream = true;
Context.Response = response;
}
}
}
catch (Exception ex)
{
// Hold onto the exception to throw it from a synchronous call.
CaughtException = ex;
}
finally
{
EndOfStream = true;
_readerEvent.Set();
}
}
/// <summary>
/// Attempt to flush any blocks to <see cref="CoapClient"/> that have been queued up.
/// </summary>
/// <inheritdoc/>
public override void Flush()
{
if (CaughtException == null && !_writerTask.IsCompleted)
{
_writerEvent.Set();
FlushFinishedEvent.WaitAsync(CancellationToken.None).Wait();
}
ThrowExceptionIfCaught();
}
public Task InvokeReceiveAsync(ArraySegment <byte> buffer, WebSocketMessageType messageType, bool endOfMessage)
{
receiveBuffers.Enqueue(new MessageData()
{
Buffer = buffer,
MessageType = messageType,
EndOfMessage = endOfMessage,
});
receiveEvent.Set();
return(Task.CompletedTask);
}
// Only call at the end of the Mainloop or HeartbeatLoop
public async Task FinishClose()
{
// Notify hearbeat loops that they can leave
m_heartbeatRead.Set();
m_closed = true;
MaybeStopHeartbeatTimers();
m_frameHandler.Close();
m_model0.SetCloseReason(m_closeReason);
await m_model0.FinishClose();
}
private Task UponorClientOnOnSuccessfulResponse()
{
ISensorContainer sensor = _hassMqttManager.GetSensor(DeviceId, EntityId);
sensor.SetValue(HassTopicKind.State, OkMessage);
sensor.SetAttribute("last_ok", DateTime.UtcNow.ToString("O"));
_shouldFlush.Set();
return(Task.CompletedTask);
}
public async Task MultipleWaitAsync_AfterMultipleSet_OnlyOneIsCompleted()
{
var are = new AsyncAutoResetEvent();
are.Set();
are.Set();
var task1 = are.WaitAsync();
var task2 = are.WaitAsync();
Assert.True(task1.IsCompleted);
await AsyncAssert.NeverCompletesAsync(task2);
}
/// <inheritdoc/>
public Task PublishAsync(IEnumerable <Message> messages, CancellationToken cancellationToken = default)
{
return(Task.Run(() =>
{
foreach (var message in messages)
{
_queue.Enqueue(message);
}
_processingTriggerEvent.Set();
}, cancellationToken));
}
public async Task MultipleWaitAsync_AfterMultipleSet_OnlyOneIsCompleted()
{
AsyncAutoResetEvent are = new AsyncAutoResetEvent();
are.Set();
are.Set();
Task task1 = are.WaitAsync();
Task task2 = are.WaitAsync();
Assert.True(task1.IsCompleted);
await AsyncAssert.NeverCompletesAsync(task2).ConfigureAwait(false);
}
public void StopWorking()
{
Log.Trace().Message("Queue {0} stop working", _queueName).Write();
_workerAction = null;
_subscriber.UnsubscribeAll();
if (_workerCancellationTokenSource != null)
{
_workerCancellationTokenSource.Cancel();
}
_autoEvent.Set();
}
public async Task SingleThreadedPulse()
{
for (int i = 0; i < 5; i++)
{
var t = _aare.WaitOneAsync();
Assert.IsFalse(t.IsCompleted);
_aare.Set();
await t;
Assert.IsTrue(t.IsCompleted);
}
}
public void MultipleWaitAsync_AfterMultipleSet_OnlyOneIsCompleted()
{
AsyncContext.Run(async() =>
{
var are = new AsyncAutoResetEvent();
are.Set();
are.Set();
var task1 = are.WaitAsync();
var task2 = are.WaitAsync();
Assert.IsTrue(task1.IsCompleted);
await AssertEx.NeverCompletesAsync(task2);
});
}
public virtual async Task WontKeepMessagesWithNoSubscribersAsync()
{
var messageBus = GetMessageBus();
if (messageBus == null)
{
return;
}
try {
await messageBus.PublishAsync(new SimpleMessageA {
Data = "Hello"
});
await SystemClock.SleepAsync(100);
var resetEvent = new AsyncAutoResetEvent(false);
await messageBus.SubscribeAsync <SimpleMessageA>(msg => {
Assert.Equal("Hello", msg.Data);
resetEvent.Set();
});
await Assert.ThrowsAnyAsync <OperationCanceledException>(() => resetEvent.WaitAsync(TimeSpan.FromMilliseconds(100)));
} finally {
await CleanupMessageBusAsync(messageBus);
}
}
/// <summary>
/// Subscribe to connection packet pipe fore waiting answer packet and then send request
/// </summary>
/// <typeparam name="TAnswerPacket"></typeparam>
/// <typeparam name="TAnswerPayload"></typeparam>
/// <param name="src"></param>
/// <param name="packet"></param>
/// <param name="targetSystem"></param>
/// <param name="targetComponent"></param>
/// <param name="cancel"></param>
/// <param name="filter"></param>
/// <returns></returns>
public static async Task <TAnswerPacket> SendAndWaitAnswer <TAnswerPacket, TAnswerPayload>(this IMavlinkV2Connection src, IPacketV2 <IPayload> packet, int targetSystem, int targetComponent, CancellationToken cancel, Func <TAnswerPacket, bool> filter = null)
where TAnswerPacket : IPacketV2 <TAnswerPayload>, new() where TAnswerPayload : IPayload
{
var p = new TAnswerPacket();
var eve = new AsyncAutoResetEvent(false);
IDisposable subscribe = null;
filter = filter ?? (_ => true);
var result = default(TAnswerPacket);
try
{
subscribe = src.Where(_ => _.ComponenId == targetComponent && _.SystemId == targetSystem && _.MessageId == p.MessageId)
.Cast <TAnswerPacket>()
.FirstAsync(filter)
.Subscribe(_ =>
{
result = _;
eve.Set();
});
await src.Send(packet, cancel).ConfigureAwait(false);
await eve.WaitAsync(cancel);
}
finally
{
subscribe?.Dispose();
}
return(result);
}
public void Enqueue(MqttBasePacket packet)
{
if (packet == null)
{
throw new ArgumentNullException(nameof(packet));
}
lock (_queue)
{
if (_queue.Count >= _options.MaxPendingMessagesPerClient)
{
if (_options.PendingMessagesOverflowStrategy == MqttPendingMessagesOverflowStrategy.DropNewMessage)
{
return;
}
if (_options.PendingMessagesOverflowStrategy == MqttPendingMessagesOverflowStrategy.DropOldestQueuedMessage)
{
_queue.Dequeue();
}
}
_queue.Enqueue(packet);
}
_queueAutoResetEvent.Set();
_logger.Verbose("Enqueued packet (ClientId: {0}).", _clientSession.ClientId);
}
public void ItCompletesTheTaskWhenSetIsCalled()
{
var asyncARE = new AsyncAutoResetEvent();
var task = asyncARE.WaitAsync();
asyncARE.Set();
task.Wait(TimeSpan.FromSeconds(1));
Assert.IsTrue(task.IsCompleted);
}
public void ItReturnsNewUncompletedTaskAfterExecution()
{
var asyncARE = new AsyncAutoResetEvent();
var task = asyncARE.WaitAsync();
task.ContinueWith(_ => { });
asyncARE.Set();
var newTask = asyncARE.WaitAsync();
Assert.IsTrue(newTask != task && !newTask.IsCompleted);
}
public async Task concurrentWaits()
{
var token = new CancellationToken();
var ev = new AsyncAutoResetEvent();
ev.Set();
ThreadPool.UnsafeQueueUserWorkItem(async (s) =>
{
for (int i = 0; i < 100; i++)
{
Thread.Sleep(2);
var t = ev.WaitAsync(token);
if (t == Task.CompletedTask)
Console.WriteLine("[1] Took it " + i);
else
await t.ContinueWith((t1, s1) =>
{
Console.WriteLine("[1] Took it later " + i);
}, null);
}
Console.WriteLine("[1] done ");
}, null);
ThreadPool.UnsafeQueueUserWorkItem(async (s) =>
{
for (int i = 0; i < 100; i++)
{
Thread.Sleep(2);
var t = ev.WaitAsync(token);
if (t == Task.CompletedTask)
Console.WriteLine("[2] Took it " + i);
else
await t.ContinueWith((t1, s1) =>
{
Console.WriteLine("[2] Took it later " + i);
}, null);
}
Console.WriteLine("[2] done ");
}, null);
ThreadPool.UnsafeQueueUserWorkItem(async (s) =>
{
for (int i = 0; i < 100; i++)
{
Thread.Sleep(2);
var t = ev.WaitAsync(token);
if (t == Task.CompletedTask)
Console.WriteLine("[3] Took it " + i);
else
await t.ContinueWith((t1, s1) =>
{
Console.WriteLine("[3] Took it later " + i);
}, null);
}
Console.WriteLine("[3] done ");
}, null);
ThreadPool.UnsafeQueueUserWorkItem((s) =>
{
for (int i = 0; i < 400; i++)
{
Thread.Sleep(1);
ev.Set();
}
}, null);
Thread.CurrentThread.Join(TimeSpan.FromSeconds(15));
}