public IAsyncResult BeginWaitForItem(TimeSpan timeout, AsyncCallback callback, object state)
{
IAsyncResult asyncResult;
lock (this.ThisLock)
{
if (this.queueState != InputQueue <T> .QueueState.Open)
{
if (this.queueState == InputQueue <T> .QueueState.Shutdown && !this.itemQueue.HasAvailableItem && this.itemQueue.HasAnyItem)
{
InputQueue <T> .AsyncQueueWaiter asyncQueueWaiter = new InputQueue <T> .AsyncQueueWaiter(timeout, callback, state);
this.waiterList.Add(asyncQueueWaiter);
asyncResult = asyncQueueWaiter;
return(asyncResult);
}
}
else
{
if (!this.itemQueue.HasAvailableItem)
{
InputQueue <T> .AsyncQueueWaiter asyncQueueWaiter1 = new InputQueue <T> .AsyncQueueWaiter(timeout, callback, state);
this.waiterList.Add(asyncQueueWaiter1);
asyncResult = asyncQueueWaiter1;
return(asyncResult);
}
}
return(new CompletedAsyncResult <bool>(true, callback, state));
}
return(asyncResult);
}
private bool RemoveReader(InputQueue <T> .IQueueReader reader)
{
bool flag;
lock (this.ThisLock)
{
if (this.queueState == InputQueue <T> .QueueState.Open || this.queueState == InputQueue <T> .QueueState.Shutdown)
{
bool flag1 = false;
for (int i = this.readerQueue.Count; i > 0; i--)
{
InputQueue <T> .IQueueReader queueReader = this.readerQueue.Dequeue();
if (!object.ReferenceEquals(queueReader, reader))
{
this.readerQueue.Enqueue(queueReader);
}
else
{
flag1 = true;
}
}
flag = flag1;
}
else
{
return(false);
}
}
return(flag);
}
public void Dispose()
{
bool flag = false;
lock (this.ThisLock)
{
if (this.queueState != InputQueue <T> .QueueState.Closed)
{
this.queueState = InputQueue <T> .QueueState.Closed;
}
}
if (flag)
{
while (this.readerQueue.Count > 0)
{
InputQueue <T> .IQueueReader queueReader = this.readerQueue.Dequeue();
InputQueue <T> .Item item = new InputQueue <T> .Item();
queueReader.Set(item);
}
while (this.itemQueue.HasAnyItem)
{
InputQueue <T> .Item item1 = this.itemQueue.DequeueAnyItem();
this.DisposeItem(item1);
InputQueue <T> .InvokeDequeuedCallback(item1.DequeuedCallback);
}
}
}
public IAsyncResult BeginDequeue(TimeSpan timeout, AsyncCallback callback, object state)
{
Item <T> item = new Item <T>();
lock (this.ThisLock)
{
if (this.queueState == QueueState <T> .Open)
{
if (!this.itemQueue.HasAvailableItem)
{
AsyncQueueReader <T> reader = new AsyncQueueReader <T>((InputQueue <T>) this, timeout, callback, state);
this.readerQueue.Enqueue(reader);
return(reader);
}
item = this.itemQueue.DequeueAvailableItem();
}
else if (this.queueState == QueueState <T> .Shutdown)
{
if (this.itemQueue.HasAvailableItem)
{
item = this.itemQueue.DequeueAvailableItem();
}
else if (this.itemQueue.HasAnyItem)
{
AsyncQueueReader <T> reader2 = new AsyncQueueReader <T>((InputQueue <T>) this, timeout, callback, state);
this.readerQueue.Enqueue(reader2);
return(reader2);
}
}
}
InputQueue <T> .InvokeDequeuedCallback(item.DequeuedCallback);
return(new CompletedAsyncResult <T>(item.GetValue(), callback, state));
}
public void Dispose()
{
bool flag = false;
lock (this.ThisLock)
{
if (this.queueState != QueueState <T> .Closed)
{
this.queueState = QueueState <T> .Closed;
flag = true;
}
}
if (flag)
{
while (this.readerQueue.Count > 0)
{
Item <T> item2 = new Item <T>();
this.readerQueue.Dequeue().Set(item2);
}
while (this.itemQueue.HasAnyItem)
{
Item <T> item = this.itemQueue.DequeueAnyItem();
this.DisposeItem(item);
InputQueue <T> .InvokeDequeuedCallback(item.DequeuedCallback);
}
}
}
private bool EnqueueWithoutDispatch(InputQueue <T> .Item item)
{
bool flag;
lock (this.ThisLock)
{
if (this.queueState == InputQueue <T> .QueueState.Closed || this.queueState == InputQueue <T> .QueueState.Shutdown)
{
this.DisposeItem(item);
InputQueue <T> .InvokeDequeuedCallbackLater(item.DequeuedCallback);
return(false);
}
else
{
if (this.readerQueue.Count != 0 || this.waiterList.Count != 0)
{
this.itemQueue.EnqueuePendingItem(item);
flag = true;
}
else
{
this.itemQueue.EnqueueAvailableItem(item);
flag = false;
}
}
}
return(flag);
}
public InputQueue()
{
this.itemQueue = new InputQueue <T> .ItemQueue();
this.readerQueue = new Queue <InputQueue <T> .IQueueReader>();
this.waiterList = new List <InputQueue <T> .IQueueWaiter>();
this.queueState = InputQueue <T> .QueueState.Open;
}
public void Set(InputQueue <T> .Item item)
{
this.item = item.Value;
if (this.timer != null)
{
this.timer.Cancel();
}
base.Complete(false, item.Exception);
}
private static void TimerCallback(object state)
{
InputQueue <T> .AsyncQueueReader asyncQueueReader = (InputQueue <T> .AsyncQueueReader)state;
if (asyncQueueReader.inputQueue.RemoveReader(asyncQueueReader))
{
asyncQueueReader.expired = true;
asyncQueueReader.Complete(false);
}
}
public void Set(InputQueue <T> .Item item)
{
lock (this)
{
this.exception = item.Exception;
this.item = item.Value;
this.waitEvent.Set();
}
}
public InputQueue <T> .Item DequeueAnyItem()
{
if (this.pendingCount == this.totalCount)
{
InputQueue <T> .ItemQueue itemQueue = this;
itemQueue.pendingCount = itemQueue.pendingCount - 1;
}
return(this.DequeueItemCore());
}
public void Dispatch()
{
bool flag = false;
bool flag1;
InputQueue <T> .IQueueReader queueReader = null;
InputQueue <T> .Item item = new InputQueue <T> .Item();
InputQueue <T> .IQueueReader[] queueReaderArray = null;
InputQueue <T> .IQueueWaiter[] queueWaiterArray = null;
lock (this.ThisLock)
{
if (this.queueState == InputQueue <T> .QueueState.Closed)
{
flag1 = false;
}
else
{
flag1 = this.queueState != InputQueue <T> .QueueState.Shutdown;
}
this.GetWaiters(out queueWaiterArray);
if (this.queueState != InputQueue <T> .QueueState.Closed)
{
this.itemQueue.MakePendingItemAvailable();
if (this.readerQueue.Count > 0)
{
item = this.itemQueue.DequeueAvailableItem();
queueReader = this.readerQueue.Dequeue();
if (this.queueState == InputQueue <T> .QueueState.Shutdown && this.readerQueue.Count > 0 && this.itemQueue.ItemCount == 0)
{
queueReaderArray = new InputQueue <T> .IQueueReader[this.readerQueue.Count];
this.readerQueue.CopyTo(queueReaderArray, 0);
this.readerQueue.Clear();
}
}
}
}
if (queueReaderArray != null)
{
if (InputQueue <T> .completeOutstandingReadersCallback == null)
{
InputQueue <T> .completeOutstandingReadersCallback = new Action <object>(InputQueue <T> .CompleteOutstandingReadersCallback);
}
ActionItem.Schedule(InputQueue <T> .completeOutstandingReadersCallback, queueReaderArray);
}
if (queueWaiterArray != null)
{
InputQueue <T> .CompleteWaitersLater(flag, queueWaiterArray);
}
if (queueReader != null)
{
InputQueue <T> .InvokeDequeuedCallback(item.DequeuedCallback);
queueReader.Set(item);
}
}
private InputQueue <T> .Item DequeueItemCore()
{
Fx.AssertAndThrow(this.totalCount != 0, "ItemQueue does not contain any items");
InputQueue <T> .Item item = this.items[this.head];
this.items[this.head] = new InputQueue <T> .Item();
this.totalCount--;
this.head = (this.head + 1) % this.items.Length;
return(item);
}
private static void CompleteOutstandingReadersCallback(object state)
{
InputQueue <T> .IQueueReader[] queueReaderArray = (InputQueue <T> .IQueueReader[])state;
for (int i = 0; i < (int)queueReaderArray.Length; i++)
{
InputQueue <T> .Item item = new InputQueue <T> .Item();
queueReaderArray[i].Set(item);
}
}
public static bool End(IAsyncResult result, out T value)
{
InputQueue <T> .AsyncQueueReader reader = AsyncResult.End <InputQueue <T> .AsyncQueueReader>(result);
if (reader.expired)
{
value = default(T);
return(false);
}
value = reader.item;
return(true);
}
public AsyncQueueReader(InputQueue <T> inputQueue, TimeSpan timeout, AsyncCallback callback, object state)
: base(callback, state)
{
if (inputQueue.AsyncCallbackGenerator != null)
{
base.VirtualCallback = inputQueue.AsyncCallbackGenerator();
}
_inputQueue = inputQueue;
if (timeout != TimeSpan.MaxValue)
{
_timer = new Timer(new TimerCallback(s_timerCallback), this, timeout, TimeSpan.FromMilliseconds(-1));
}
}
public AsyncQueueReader(InputQueue <T> inputQueue, TimeSpan timeout, AsyncCallback callback, object state) : base(callback, state)
{
if (inputQueue.AsyncCallbackGenerator != null)
{
base.VirtualCallback = inputQueue.AsyncCallbackGenerator();
}
this.inputQueue = inputQueue;
if (timeout != TimeSpan.MaxValue)
{
this.timer = new IOThreadTimer(InputQueue <T> .AsyncQueueReader.timerCallback, this, false);
this.timer.Set(timeout);
}
}
public bool Dequeue(TimeSpan timeout, out T value)
{
WaitQueueReader <T> reader = null;
Item <T> item = new Item <T>();
lock (this.ThisLock)
{
if (this.queueState == QueueState <T> .Open)
{
if (this.itemQueue.HasAvailableItem)
{
item = this.itemQueue.DequeueAvailableItem();
}
else
{
reader = new WaitQueueReader <T>((InputQueue <T>) this);
this.readerQueue.Enqueue(reader);
}
}
else if (this.queueState == QueueState <T> .Shutdown)
{
if (!this.itemQueue.HasAvailableItem)
{
if (!this.itemQueue.HasAnyItem)
{
value = default(T);
return(true);
}
reader = new WaitQueueReader <T>((InputQueue <T>) this);
this.readerQueue.Enqueue(reader);
}
else
{
item = this.itemQueue.DequeueAvailableItem();
}
}
else
{
value = default(T);
return(true);
}
}
if (reader != null)
{
return(reader.Wait(timeout, out value));
}
InputQueue <T> .InvokeDequeuedCallback(item.DequeuedCallback);
value = item.GetValue();
return(true);
}
public IAsyncResult BeginDequeue(TimeSpan timeout, AsyncCallback callback, object state)
{
IAsyncResult asyncResult;
InputQueue <T> .Item item = new InputQueue <T> .Item();
lock (this.ThisLock)
{
if (this.queueState != InputQueue <T> .QueueState.Open)
{
if (this.queueState == InputQueue <T> .QueueState.Shutdown)
{
if (!this.itemQueue.HasAvailableItem)
{
if (this.itemQueue.HasAnyItem)
{
InputQueue <T> .AsyncQueueReader asyncQueueReader = new InputQueue <T> .AsyncQueueReader(this, timeout, callback, state);
this.readerQueue.Enqueue(asyncQueueReader);
asyncResult = asyncQueueReader;
return(asyncResult);
}
}
else
{
item = this.itemQueue.DequeueAvailableItem();
}
}
}
else
{
if (!this.itemQueue.HasAvailableItem)
{
InputQueue <T> .AsyncQueueReader asyncQueueReader1 = new InputQueue <T> .AsyncQueueReader(this, timeout, callback, state);
this.readerQueue.Enqueue(asyncQueueReader1);
asyncResult = asyncQueueReader1;
return(asyncResult);
}
else
{
item = this.itemQueue.DequeueAvailableItem();
}
}
InputQueue <T> .InvokeDequeuedCallback(item.DequeuedCallback);
return(new CompletedAsyncResult <T>(item.GetValue(), callback, state));
}
return(asyncResult);
}
public void Dispatch()
{
IQueueReader <T> reader = null;
Item <T> item = new Item <T>();
IQueueReader <T>[] array = null;
IQueueWaiter <T>[] waiters = null;
bool itemAvailable = true;
lock (this.ThisLock)
{
itemAvailable = (this.queueState != QueueState <T> .Closed) && (this.queueState != QueueState <T> .Shutdown);
this.GetWaiters(out waiters);
if (this.queueState != QueueState <T> .Closed)
{
this.itemQueue.MakePendingItemAvailable();
if (this.readerQueue.Count > 0)
{
item = this.itemQueue.DequeueAvailableItem();
reader = this.readerQueue.Dequeue();
if (((this.queueState == QueueState <T> .Shutdown) && (this.readerQueue.Count > 0)) && (this.itemQueue.ItemCount == 0))
{
array = new IQueueReader <T> [this.readerQueue.Count];
this.readerQueue.CopyTo(array, 0);
this.readerQueue.Clear();
itemAvailable = false;
}
}
}
}
if (array != null)
{
if (InputQueue <T> .completeOutstandingReadersCallback == null)
{
InputQueue <T> .completeOutstandingReadersCallback = new Action <object>(InputQueue <T> .CompleteOutstandingReadersCallback);
}
ActionItem.Schedule(InputQueue <T> .completeOutstandingReadersCallback, array);
}
if (waiters != null)
{
InputQueue <T> .CompleteWaitersLater(itemAvailable, waiters);
}
if (reader != null)
{
InputQueue <T> .InvokeDequeuedCallback(item.DequeuedCallback);
reader.Set(item);
}
}
private void EnqueueItemCore(InputQueue <T> .Item item)
{
if (this.totalCount == this.items.Length)
{
InputQueue <T> .Item[] itemArray = new InputQueue <T> .Item[this.items.Length * 2];
for (int i = 0; i < this.totalCount; i++)
{
itemArray[i] = this.items[(this.head + i) % this.items.Length];
}
this.head = 0;
this.items = itemArray;
}
int index = (this.head + this.totalCount) % this.items.Length;
this.items[index] = item;
this.totalCount++;
}
public void Shutdown(Func <Exception> pendingExceptionGenerator)
{
Exception exception;
InputQueue <T> .IQueueReader[] queueReaderArray = null;
lock (this.ThisLock)
{
if (this.queueState != InputQueue <T> .QueueState.Shutdown)
{
if (this.queueState != InputQueue <T> .QueueState.Closed)
{
this.queueState = InputQueue <T> .QueueState.Shutdown;
if (this.readerQueue.Count > 0 && this.itemQueue.ItemCount == 0)
{
queueReaderArray = new InputQueue <T> .IQueueReader[this.readerQueue.Count];
this.readerQueue.CopyTo(queueReaderArray, 0);
this.readerQueue.Clear();
}
}
else
{
return;
}
}
else
{
return;
}
}
if (queueReaderArray != null)
{
for (int i = 0; i < (int)queueReaderArray.Length; i++)
{
if (pendingExceptionGenerator != null)
{
exception = pendingExceptionGenerator();
}
else
{
exception = null;
}
Exception exception1 = exception;
queueReaderArray[i].Set(new InputQueue <T> .Item(exception1, null));
}
}
}
private void EnqueueItemCore(InputQueue <T> .Item item)
{
if (this.totalCount == (int)this.items.Length)
{
InputQueue <T> .Item[] itemArray = new InputQueue <T> .Item[(int)this.items.Length * 2];
for (int i = 0; i < this.totalCount; i++)
{
itemArray[i] = this.items[(this.head + i) % (int)this.items.Length];
}
this.head = 0;
this.items = itemArray;
}
int length = (this.head + this.totalCount) % (int)this.items.Length;
this.items[length] = item;
InputQueue <T> .ItemQueue itemQueue = this;
itemQueue.totalCount = itemQueue.totalCount + 1;
}
private bool EnqueueWithoutDispatch(Item <T> item)
{
lock (this.ThisLock)
{
if ((this.queueState != QueueState <T> .Closed) && (this.queueState != QueueState <T> .Shutdown))
{
if ((this.readerQueue.Count == 0) && (this.waiterList.Count == 0))
{
this.itemQueue.EnqueueAvailableItem(item);
return(false);
}
this.itemQueue.EnqueuePendingItem(item);
return(true);
}
}
this.DisposeItem(item);
InputQueue <T> .InvokeDequeuedCallbackLater(item.DequeuedCallback);
return(false);
}
private void DisposeItem(InputQueue <T> .Item item)
{
T value = item.Value;
if (value != null)
{
if ((object)value as IDisposable == null)
{
Action <T> disposeItemCallback = this.DisposeItemCallback;
if (disposeItemCallback != null)
{
disposeItemCallback(value);
}
}
else
{
((IDisposable)(object)value).Dispose();
return;
}
}
}
public WaitQueueReader(InputQueue <T> inputQueue)
{
_inputQueue = inputQueue;
_waitEvent = new ManualResetEvent(false);
}
public TaskQueueReader(InputQueue <T> inputQueue)
{
_inputQueue = inputQueue;
}
private static void TimerCallback(object state)
{
InputQueue <T> .AsyncQueueWaiter asyncQueueWaiter = (InputQueue <T> .AsyncQueueWaiter)state;
asyncQueueWaiter.Complete(false);
}
public static bool End(IAsyncResult result)
{
InputQueue <T> .AsyncQueueWaiter asyncQueueWaiter = AsyncResult.End <InputQueue <T> .AsyncQueueWaiter>(result);
return(asyncQueueWaiter.itemAvailable);
}
public bool WaitForItem(TimeSpan timeout)
{
bool flag;
InputQueue <T> .WaitQueueWaiter waitQueueWaiter = null;
bool flag1 = false;
lock (this.ThisLock)
{
if (this.queueState != InputQueue <T> .QueueState.Open)
{
if (this.queueState != InputQueue <T> .QueueState.Shutdown)
{
flag = true;
return(flag);
}
else
{
if (!this.itemQueue.HasAvailableItem)
{
if (!this.itemQueue.HasAnyItem)
{
flag = true;
return(flag);
}
else
{
waitQueueWaiter = new InputQueue <T> .WaitQueueWaiter();
this.waiterList.Add(waitQueueWaiter);
}
}
else
{
flag1 = true;
}
}
}
else
{
if (!this.itemQueue.HasAvailableItem)
{
waitQueueWaiter = new InputQueue <T> .WaitQueueWaiter();
this.waiterList.Add(waitQueueWaiter);
}
else
{
flag1 = true;
}
}
goto Label0;
}
return(flag);
Label0:
if (waitQueueWaiter == null)
{
return(flag1);
}
else
{
return(waitQueueWaiter.Wait(timeout));
}
}
