public WorkItem DequeueWorkItem(int millisecondsTimeout, WaitHandle cancelEvent)
{
WorkItem workItem = null;
WorkItemsQueue.WaiterEntry threadWaiterEntry;
try
{
while (!Monitor.TryEnter(this))
{
}
this.ValidateNotDisposed();
if (this._workItems.Count > 0)
{
workItem = (this._workItems.Dequeue() as WorkItem);
return(workItem);
}
threadWaiterEntry = WorkItemsQueue.GetThreadWaiterEntry();
this.PushWaiter(threadWaiterEntry);
}
finally
{
Monitor.Exit(this);
}
WaitHandle[] waitHandles = new WaitHandle[]
{
threadWaiterEntry.WaitHandle,
cancelEvent
};
int num = STPEventWaitHandle.WaitAny(waitHandles, millisecondsTimeout, true);
Monitor.Enter(this);
try
{
bool flag = 0 == num;
bool flag2 = !flag;
if (flag2)
{
flag2 = threadWaiterEntry.Timeout();
if (flag2)
{
this.RemoveWaiter(threadWaiterEntry, false);
}
flag = !flag2;
}
if (flag)
{
workItem = threadWaiterEntry.WorkItem;
if (workItem == null)
{
workItem = (this._workItems.Dequeue() as WorkItem);
}
}
}
finally
{
Monitor.Exit(this);
}
return(workItem);
}
internal static bool WaitAll(IWaitableResult[] waitableResults, int millisecondsTimeout, bool exitContext, WaitHandle cancelWaitHandle)
{
if (waitableResults.Length == 0)
{
return(true);
}
WaitHandle[] array = new WaitHandle[waitableResults.Length];
WorkItem.GetWaitHandles(waitableResults, array);
bool result;
if (cancelWaitHandle == null && array.Length <= 64)
{
result = STPEventWaitHandle.WaitAll(array, millisecondsTimeout, exitContext);
}
else
{
result = true;
int num = millisecondsTimeout;
Stopwatch stopwatch = Stopwatch.StartNew();
WaitHandle[] array2;
if (cancelWaitHandle != null)
{
array2 = new WaitHandle[]
{
null,
cancelWaitHandle
};
}
else
{
WaitHandle[] array3 = new WaitHandle[1];
array2 = array3;
}
bool flag = -1 == millisecondsTimeout;
for (int i = 0; i < waitableResults.Length; i++)
{
if (!flag && num < 0)
{
result = false;
break;
}
array2[0] = array[i];
int num2 = STPEventWaitHandle.WaitAny(array2, num, exitContext);
if (num2 > 0 || -1 == num2)
{
result = false;
break;
}
if (!flag)
{
num = millisecondsTimeout - (int)stopwatch.ElapsedMilliseconds;
}
}
}
WorkItem.ReleaseWaitHandles(waitableResults);
return(result);
}
private object GetResult(int millisecondsTimeout, bool exitContext, WaitHandle cancelWaitHandle, out Exception e)
{
e = null;
if (WorkItem.WorkItemState.Canceled == this.GetWorkItemState())
{
throw new WorkItemCancelException("Work item canceled");
}
if (this.IsCompleted)
{
e = this._exception;
return(this._result);
}
if (cancelWaitHandle == null)
{
WaitHandle waitHandle = this.GetWaitHandle();
bool flag = !STPEventWaitHandle.WaitOne(waitHandle, millisecondsTimeout, exitContext);
this.ReleaseWaitHandle();
if (flag)
{
throw new WorkItemTimeoutException("Work item timeout");
}
}
else
{
WaitHandle waitHandle2 = this.GetWaitHandle();
int num = STPEventWaitHandle.WaitAny(new WaitHandle[]
{
waitHandle2,
cancelWaitHandle
});
this.ReleaseWaitHandle();
switch (num)
{
case -1:
case 1:
throw new WorkItemTimeoutException("Work item timeout");
}
}
if (WorkItem.WorkItemState.Canceled == this.GetWorkItemState())
{
throw new WorkItemCancelException("Work item canceled");
}
e = this._exception;
return(this._result);
}
internal static int WaitAny(IWaitableResult[] waitableResults, int millisecondsTimeout, bool exitContext, WaitHandle cancelWaitHandle)
{
WaitHandle[] array;
if (cancelWaitHandle != null)
{
array = new WaitHandle[waitableResults.Length + 1];
WorkItem.GetWaitHandles(waitableResults, array);
array[waitableResults.Length] = cancelWaitHandle;
}
else
{
array = new WaitHandle[waitableResults.Length];
WorkItem.GetWaitHandles(waitableResults, array);
}
int num = STPEventWaitHandle.WaitAny(array, millisecondsTimeout, exitContext);
if (cancelWaitHandle != null && num == waitableResults.Length)
{
num = -1;
}
WorkItem.ReleaseWaitHandles(waitableResults);
return(num);
}
public override bool WaitForIdle(int millisecondsTimeout)
{
SmartThreadPool.ValidateWorkItemsGroupWaitForIdle(this);
return(STPEventWaitHandle.WaitOne(this._isIdleWaitHandle, millisecondsTimeout, false));
}
