public async Task Should_execute_in_correct_order()
{
//arrange
var semaphore = new SemaphoreQueue(1);
var numbers = new int[5000];
var tasks = new List <Task>();
//act
for (var i = 0; i < 5000; i++)
{
var intCopy = i;
tasks.Add(semaphore.WaitAsync(CancellationToken.None).ContinueWith(task =>
{
semaphore.Release();
return(numbers[intCopy] = intCopy);
}));
}
await Task.WhenAll(tasks);
//assert
for (var i = 0; i < 5000; i++)
{
numbers[i].Should().Be(i);
}
}
/// <summary>
/// Starts receiving and sending data.
/// </summary>
/// <exception cref="SslException">If SSL is enabled</exception>
public void Initialize()
{
if (Connected)
{
return;
}
Socket.NoDelay = true;
_stream = new NetworkStream(Socket);
if (SslMode != SslMode.None)
{
_sslStream = _sslFactory.Build(this);
if (SslMode == SslMode.AuthorizationOnly)
{
_sslStream?.Dispose();
_sslStream = null;
}
}
var wrapper = _services.Get <IInternalStreamWrapper>();
_sslStream = wrapper?.Wrap(Stream);
Connected = true;
LastReceived = DateTime.Now;
_services.Attach(this);
if (UseCustomIncomingMessageQueue)
{
_decoder.PacketReceived = DispatchPayloadReceived;
CustomIncomingMessageQueue.NewClient();
}
if (UseCustomOutcomingMessageQueue)
{
CustomOutcomingMessageQueue.NewClient();
}
else
{
_sendLock = new SemaphoreQueue(1, 1);
}
if (!_receiveWorkerThreadRunning)
{
_receiveWorkerThreadRunning = true;
if (_readAsync)
{
Task.Run(ReadAsync);
}
else
{
_receiveWorkerThread = new Thread(ReadSync)
{
IsBackground = true
};
_receiveWorkerThread.Start();
}
}
}
protected RedisChannelReceiver(IConnectionMultiplexer connectionMultiplexer, string queueName, IProcessingSettings settings, RedisConfiguration redisConfiguration, IHostConfiguration hostConfiguration, IMessageProcessor processor)
{
ConnectionMultiplexer = connectionMultiplexer;
_settings = settings;
_redisConfiguration = redisConfiguration;
_hostConfiguration = hostConfiguration;
_processor = processor;
_queueName = queueName;
_maxConcurrent = new SemaphoreQueue(settings.MaxConcurrentCalls);
}
public void Should_cancel()
{
//arrange
var tokenSource = new CancellationTokenSource();
var token = tokenSource.Token;
var semaphore = new SemaphoreQueue(1);
tokenSource.Cancel();
semaphore.Awaiting(x => x.WaitAsync(token))
.Should().Throw <OperationCanceledException>();
//assert
semaphore.CurrentCount.Should().Be(1);
}
public async Task Should_wait()
{
//arrange
var semaphore = new SemaphoreQueue(1);
var countable = new Mock <ICountable>();
//act
#pragma warning disable 4014
semaphore.WaitAsync(CancellationToken.None).ContinueWith(task => countable.Object.Count());
semaphore.WaitAsync(CancellationToken.None).ContinueWith(task => countable.Object.Count());
semaphore.WaitAsync(CancellationToken.None).ContinueWith(task => countable.Object.Count());
#pragma warning restore 4014
await Task.Delay(500);
//assert
countable.Verify(x => x.Count(), Times.Once);
semaphore.Release();
}
public ThrottlingMiddleware(int maxConcurrent)
{
_semaphoreQueue = new SemaphoreQueue(maxConcurrent);
}
