public void Set(ExItem <T> item)
{
this._Item = item.Data;
if (_Timer != null)
{
_Timer.Change(-1, -1);
}
Complete(false, item.Exception);
}
public bool Dequeue(TimeSpan timeout, out T value)
{
WaitQueueReader <T> reader = null;
ExItem <T> item = new ExItem <T>();
lock (LockObject)
{
if (_QueueState == QueueState.Open)
{
if (_ItemQueue.HasAvailableItem)
{
item = _ItemQueue.DequeueAvailableItem();
}
else
{
reader = new WaitQueueReader <T>(this);
_QueueReader.Enqueue(reader);
}
}
else if (_QueueState == QueueState.Shutdown)
{
if (_ItemQueue.HasAvailableItem)
{
item = _ItemQueue.DequeueAvailableItem();
}
else if (_ItemQueue.HasAnyItem)
{
reader = new WaitQueueReader <T>(this);
_QueueReader.Enqueue(reader);
}
else
{
value = default(T);
return(true);
}
}
else
{
value = default(T);
return(true);
}
}
if (reader != null)
{
return(reader.Wait(timeout, out value));
}
else
{
invokeDequeueCallback(item.Callback);
value = item.GetData();
return(true);
}
}
public void Set(ExItem <T> item)
{
lock (_LockObject)
{
Debug.Assert(this._Item == null, "InputQueue.WaitQueueReader.Set: (this.item == null)");
Debug.Assert(this._Exception == null, "InputQueue.WaitQueueReader.Set: (this.exception == null)");
this._Exception = item.Exception;
this._Item = item.Data;
_WaitHandler.Set();
}
}
public void Dispatch()
{
IQueueReader <T> reader = null;
ExItem <T> item = new ExItem <T>();
IQueueReader <T>[] outstandingReaders = null;
IQueueWaiter[] waiters = null;
bool itemAvailable = true;
lock (LockObject)
{
itemAvailable = (_QueueState != QueueState.Closed && _QueueState != QueueState.Shutdown);
this.getWaiters(out waiters);
if (_QueueState != QueueState.Closed)
{
_ItemQueue.MakePendingItemAvailable();
if (_QueueReader.Count > 0)
{
item = _ItemQueue.DequeueAvailableItem();
reader = _QueueReader.Dequeue();
if (_QueueState == QueueState.Shutdown &&
_QueueReader.Count > 0 &&
_ItemQueue.ItemCount == 0)
{
outstandingReaders = new IQueueReader <T> [_QueueReader.Count];
_QueueReader.CopyTo(outstandingReaders, 0);
_QueueReader.Clear();
itemAvailable = false;
}
}
}
}
if (outstandingReaders != null)
{
if (_CompleteOutstandingReadersCallback == null)
{
_CompleteOutstandingReadersCallback = completeOutstandingReadersCallback;
}
ThreadPool.QueueUserWorkItem(_CompleteOutstandingReadersCallback, outstandingReaders);
}
if (waiters != null)
{
completeWaitersLater(itemAvailable, waiters);
}
if (reader != null)
{
invokeDequeueCallback(item.Callback);
reader.Set(item);
}
}
private ExItem <T> dequeueItemCore()
{
if (_TotalCount == 0)
{
Debug.Assert(false, "ExItemQueue.TotalCount==0");
throw new Exception("ExItemQueue.TotalCount==0");
}
var item = _Items[_Head];
_Items[_Head] = new ExItem <T>();
_TotalCount--;
_Head = (_Head + 1) % _Items.Length;
return(item);
}
private void enquequeItemCore(ExItem <T> item)
{
if (_TotalCount == _Items.Length)
{
ExItem <T>[] newItems = new ExItem <T> [_Items.Length * 2];
for (int i = 0; i < _TotalCount; i++)
{
newItems[i] = _Items[(_Head + i) % _Items.Length];
}
_Head = 0;
_Items = newItems;
}
int tail = (_Head + _TotalCount) % _Items.Length;
_Items[tail] = item;
_TotalCount++;
}
// This does not block, however, Dispatch() must be called later if this function returns true.
private bool enqueueWithoutDispatch(ExItem <T> item)
{
lock (LockObject)
{
if (_QueueState == QueueState.Open)
{
if (_QueueReader.Count == 0)
{
_ItemQueue.EnqueueAvailableItem(item);
return(false);
}
else
{
_ItemQueue.EnqueuePendingItem(item);
return(true);
}
}
}
invokeDequeueCallback(item.Callback);
item.Dispose();
return(false);
}
public IAsyncResult BeginDequeue(TimeSpan timeout, AsyncCallback callback, object state)
{
ExItem <T> item = default(ExItem <T>);
lock (LockObject)
{
if (_QueueState == QueueState.Open)
{
if (_ItemQueue.HasAvailableItem)
{
item = _ItemQueue.DequeueAvailableItem();
}
else
{
AsyncQueueReader <T> reader = new AsyncQueueReader <T>(this, timeout, callback, state);
_QueueReader.Enqueue(reader);
return(reader);
}
}
else if (_QueueState == QueueState.Shutdown)
{
if (_ItemQueue.HasAvailableItem)
{
item = _ItemQueue.DequeueAvailableItem();
}
else if (_ItemQueue.HasAnyItem)
{
AsyncQueueReader <T> reader = new AsyncQueueReader <T>(this, timeout, callback, state);
_QueueReader.Enqueue(reader);
return(reader);
}
}
}
invokeDequeueCallback(item.Callback);
return(new DataCompleteAsyncResult <T>(item.GetData(), callback, state));
}
public void EnqueueAvailableItem(ExItem <T> item)
{
enquequeItemCore(item);
}
public void EnqueuePendingItem(ExItem <T> item)
{
enquequeItemCore(item);
_PendingCount++;
}
private void enqueueAndDispatch(ExItem <T> item, bool canDispatchOnThisThread)
{
bool disposeItem = false;
bool dispatchLater = false;
bool itemAvailable = true;
IQueueReader <T> reader = null;
IQueueWaiter[] waiters = null;
lock (LockObject)
{
itemAvailable = (_QueueState != QueueState.Closed && _QueueState != QueueState.Shutdown);
this.getWaiters(out waiters);
if (_QueueState == QueueState.Open)
{
if (canDispatchOnThisThread)
{
if (_QueueReader.Count == 0)
{
_ItemQueue.EnqueueAvailableItem(item);
}
else
{
reader = _QueueReader.Dequeue();
}
}
else
{
if (_QueueReader.Count == 0)
{
_ItemQueue.EnqueueAvailableItem(item);
}
else
{
_ItemQueue.EnqueuePendingItem(item);
dispatchLater = true;
}
}
}
else
{
disposeItem = true;
}
}
if (waiters != null)
{
if (canDispatchOnThisThread)
{
completeWaiters(itemAvailable, waiters);
}
else
{
completeWaitersLater(itemAvailable, waiters);
}
}
if (reader != null)
{
invokeDequeueCallback(item.Callback);
reader.Set(item);
}
if (dispatchLater)
{
if (_OnDispatchCallback == null)
{
_OnDispatchCallback = onDispatchCallback;
}
ThreadPool.QueueUserWorkItem(_OnDispatchCallback, this);
}
else if (disposeItem)
{
invokeDequeueCallback(item.Callback);
item.Dispose();
}
}
