// Token: 0x06003DFE RID: 15870 RVA: 0x000E65A8 File Offset: 0x000E47A8
private void CheckDispose()
{
if (this.m_lockObj == null)
{
throw new ObjectDisposedException(null, SemaphoreSlim.GetResourceString("SemaphoreSlim_Disposed"));
}
}
public Task <bool> WaitAsync(TimeSpan timeout, CancellationToken cancellationToken)
{
long num = (long)timeout.TotalMilliseconds;
if (num < -1L || num > 2147483647L)
{
throw new ArgumentOutOfRangeException("timeout", timeout, SemaphoreSlim.GetResourceString("SemaphoreSlim_Wait_TimeoutWrong"));
}
return(this.WaitAsync((int)timeout.TotalMilliseconds, cancellationToken));
}
public bool Wait(TimeSpan timeout, CancellationToken cancellationToken)
{
long num = (long)timeout.TotalMilliseconds;
if (num < -1L || num > (long)int.MaxValue)
{
throw new ArgumentOutOfRangeException("timeout", (object)timeout, SemaphoreSlim.GetResourceString("SemaphoreSlim_Wait_TimeoutWrong"));
}
return(this.Wait((int)timeout.TotalMilliseconds, cancellationToken));
}
public SemaphoreSlim(int initialCount, int maxCount)
{
if (initialCount < 0 || initialCount > maxCount)
{
throw new ArgumentOutOfRangeException("initialCount", initialCount, SemaphoreSlim.GetResourceString("SemaphoreSlim_ctor_InitialCountWrong"));
}
if (maxCount <= 0)
{
throw new ArgumentOutOfRangeException("maxCount", maxCount, SemaphoreSlim.GetResourceString("SemaphoreSlim_ctor_MaxCountWrong"));
}
this.m_maxCount = maxCount;
this.m_lockObj = new object();
this.m_currentCount = initialCount;
}
public int Release(int releaseCount)
{
this.CheckDispose();
if (releaseCount < 1)
{
throw new ArgumentOutOfRangeException("releaseCount", releaseCount, SemaphoreSlim.GetResourceString("SemaphoreSlim_Release_CountWrong"));
}
object lockObj = this.m_lockObj;
int num2;
lock (lockObj)
{
int num = this.m_currentCount;
num2 = num;
if (this.m_maxCount - num < releaseCount)
{
throw new SemaphoreFullException();
}
num += releaseCount;
int waitCount = this.m_waitCount;
if (num == 1 || waitCount == 1)
{
Monitor.Pulse(this.m_lockObj);
}
else if (waitCount > 1)
{
Monitor.PulseAll(this.m_lockObj);
}
if (this.m_asyncHead != null)
{
int num3 = num - waitCount;
while (num3 > 0 && this.m_asyncHead != null)
{
num--;
num3--;
SemaphoreSlim.TaskNode asyncHead = this.m_asyncHead;
this.RemoveAsyncWaiter(asyncHead);
SemaphoreSlim.QueueWaiterTask(asyncHead);
}
}
this.m_currentCount = num;
if (this.m_waitHandle != null && num2 == 0 && num > 0)
{
this.m_waitHandle.Set();
}
}
return(num2);
}
public Task <bool> WaitAsync(int millisecondsTimeout, CancellationToken cancellationToken)
{
this.CheckDispose();
if (millisecondsTimeout < -1)
{
throw new ArgumentOutOfRangeException("totalMilliSeconds", millisecondsTimeout, SemaphoreSlim.GetResourceString("SemaphoreSlim_Wait_TimeoutWrong"));
}
if (cancellationToken.IsCancellationRequested)
{
return(Task.FromCancellation <bool>(cancellationToken));
}
object lockObj = this.m_lockObj;
Task <bool> result;
lock (lockObj)
{
if (this.m_currentCount > 0)
{
this.m_currentCount--;
if (this.m_waitHandle != null && this.m_currentCount == 0)
{
this.m_waitHandle.Reset();
}
result = SemaphoreSlim.s_trueTask;
}
else
{
SemaphoreSlim.TaskNode taskNode = this.CreateAndAddAsyncWaiter();
result = ((millisecondsTimeout == -1 && !cancellationToken.CanBeCanceled) ? taskNode : this.WaitUntilCountOrTimeoutAsync(taskNode, millisecondsTimeout, cancellationToken));
}
}
return(result);
}
public bool Wait(int millisecondsTimeout, CancellationToken cancellationToken)
{
this.CheckDispose();
if (millisecondsTimeout < -1)
{
throw new ArgumentOutOfRangeException("totalMilliSeconds", millisecondsTimeout, SemaphoreSlim.GetResourceString("SemaphoreSlim_Wait_TimeoutWrong"));
}
cancellationToken.ThrowIfCancellationRequested();
uint startTime = 0U;
if (millisecondsTimeout != -1 && millisecondsTimeout > 0)
{
startTime = TimeoutHelper.GetTime();
}
bool result = false;
Task <bool> task = null;
bool flag = false;
CancellationTokenRegistration cancellationTokenRegistration = cancellationToken.InternalRegisterWithoutEC(SemaphoreSlim.s_cancellationTokenCanceledEventHandler, this);
try
{
SpinWait spinWait = default(SpinWait);
while (this.m_currentCount == 0 && !spinWait.NextSpinWillYield)
{
spinWait.SpinOnce();
}
try
{
}
finally
{
Monitor.Enter(this.m_lockObj, ref flag);
if (flag)
{
this.m_waitCount++;
}
}
if (this.m_asyncHead != null)
{
task = this.WaitAsync(millisecondsTimeout, cancellationToken);
}
else
{
OperationCanceledException ex = null;
if (this.m_currentCount == 0)
{
if (millisecondsTimeout == 0)
{
return(false);
}
try
{
result = this.WaitUntilCountOrTimeout(millisecondsTimeout, startTime, cancellationToken);
}
catch (OperationCanceledException ex2)
{
ex = ex2;
}
}
if (this.m_currentCount > 0)
{
result = true;
this.m_currentCount--;
}
else if (ex != null)
{
throw ex;
}
if (this.m_waitHandle != null && this.m_currentCount == 0)
{
this.m_waitHandle.Reset();
}
}
}
finally
{
if (flag)
{
this.m_waitCount--;
Monitor.Exit(this.m_lockObj);
}
cancellationTokenRegistration.Dispose();
}
if (task == null)
{
return(result);
}
return(task.GetAwaiter().GetResult());
}
public int Release(int releaseCount)
{
this.CheckDispose();
if (releaseCount < 1)
{
throw new ArgumentOutOfRangeException("releaseCount", (object)releaseCount, SemaphoreSlim.GetResourceString("SemaphoreSlim_Release_CountWrong"));
}
int num;
lock (this.m_lockObj)
{
int local_3 = this.m_currentCount;
num = local_3;
if (this.m_maxCount - local_3 < releaseCount)
{
throw new SemaphoreFullException();
}
int local_3_1 = local_3 + releaseCount;
int local_4 = this.m_waitCount;
if (local_3_1 == 1 || local_4 == 1)
{
Monitor.Pulse(this.m_lockObj);
}
else if (local_4 > 1)
{
Monitor.PulseAll(this.m_lockObj);
}
if (this.m_asyncHead != null)
{
int local_5 = local_3_1 - local_4;
while (local_5 > 0 && this.m_asyncHead != null)
{
--local_3_1;
--local_5;
SemaphoreSlim.TaskNode local_6 = this.m_asyncHead;
this.RemoveAsyncWaiter(local_6);
SemaphoreSlim.QueueWaiterTask(local_6);
}
}
this.m_currentCount = local_3_1;
if (this.m_waitHandle != null)
{
if (num == 0)
{
if (local_3_1 > 0)
{
this.m_waitHandle.Set();
}
}
}
}
return(num);
}
public Task <bool> WaitAsync(int millisecondsTimeout, CancellationToken cancellationToken)
{
this.CheckDispose();
if (millisecondsTimeout < -1)
{
throw new ArgumentOutOfRangeException("totalMilliSeconds", (object)millisecondsTimeout, SemaphoreSlim.GetResourceString("SemaphoreSlim_Wait_TimeoutWrong"));
}
if (cancellationToken.IsCancellationRequested)
{
return(Task.FromCancellation <bool>(cancellationToken));
}
lock (this.m_lockObj)
{
if (this.m_currentCount > 0)
{
this.m_currentCount = this.m_currentCount - 1;
if (this.m_waitHandle != null && this.m_currentCount == 0)
{
this.m_waitHandle.Reset();
}
return(SemaphoreSlim.s_trueTask);
}
SemaphoreSlim.TaskNode local_3 = this.CreateAndAddAsyncWaiter();
return(millisecondsTimeout != -1 || cancellationToken.CanBeCanceled ? this.WaitUntilCountOrTimeoutAsync(local_3, millisecondsTimeout, cancellationToken) : (Task <bool>)local_3);
}
}
