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)); } }