public void Dispatch()
{
IQueueReader reader = null;
Item item = new Item();
IQueueReader[] outstandingReaders = null;
IQueueWaiter[] waiters = null;
bool itemAvailable = true;
lock (ThisLock)
{
itemAvailable = !((queueState == QueueState.Closed) || (queueState == QueueState.Shutdown));
this.GetWaiters(out waiters);
if (queueState != QueueState.Closed)
{
itemQueue.MakePendingItemAvailable();
if (readerQueue.Count > 0)
{
item = itemQueue.DequeueAvailableItem();
reader = readerQueue.Dequeue();
if (queueState == QueueState.Shutdown && readerQueue.Count > 0 && itemQueue.ItemCount == 0)
{
outstandingReaders = new IQueueReader[readerQueue.Count];
readerQueue.CopyTo(outstandingReaders, 0);
readerQueue.Clear();
itemAvailable = false;
}
}
}
}
if (outstandingReaders != null)
{
if (completeOutstandingReadersCallback == null)
{
completeOutstandingReadersCallback = new Action <object>(CompleteOutstandingReadersCallback);
}
ActionItem.Schedule(completeOutstandingReadersCallback, outstandingReaders);
}
if (waiters != null)
{
CompleteWaitersLater(itemAvailable, waiters);
}
if (reader != null)
{
InvokeDequeuedCallback(item.DequeuedCallback);
reader.Set(item);
}
}
private static void InvokeDequeuedCallbackLater(Action dequeuedCallback)
{
if (dequeuedCallback != null)
{
if (InputQueue <T> .onInvokeDequeuedCallback == null)
{
InputQueue <T> .onInvokeDequeuedCallback = new Action <object>(InputQueue <T> .OnInvokeDequeuedCallback);
}
ActionItem.Schedule(InputQueue <T> .onInvokeDequeuedCallback, dequeuedCallback);
}
}
static void InvokeDequeuedCallbackLater(Action dequeuedCallback)
{
if (dequeuedCallback != null)
{
if (onInvokeDequeuedCallback == null)
{
onInvokeDequeuedCallback = new Action <object>(OnInvokeDequeuedCallback);
}
ActionItem.Schedule(onInvokeDequeuedCallback, dequeuedCallback);
}
}
private static void ScheduleElapsedTimers(IOThreadTimer.TimerGroup timerGroup, long now)
{
IOThreadTimer.TimerQueue timerQueue = timerGroup.TimerQueue;
while (timerQueue.Count > 0)
{
IOThreadTimer minTimer = timerQueue.MinTimer;
if (minTimer.dueTime - now > minTimer.maxSkew)
{
break;
}
timerQueue.DeleteMinTimer();
ActionItem.Schedule(minTimer.callback, minTimer.callbackState);
}
}
public void Dispatch()
{
InputQueue <T> .IQueueReader queueReader = null;
InputQueue <T> .Item item = new InputQueue <T> .Item();
InputQueue <T> .IQueueReader[] queueReaderArray = null;
InputQueue <T> .IQueueWaiter[] queueWaiterArray = null;
bool flag = true;
lock (this.ThisLock)
{
flag = (this.queueState == InputQueue <T> .QueueState.Closed ? false : 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();
flag = false;
}
}
}
}
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 static void CompleteWaitersLater(bool itemAvailable, InputQueue <T> .IQueueWaiter[] waiters)
{
if (itemAvailable)
{
if (InputQueue <T> .completeWaitersTrueCallback == null)
{
InputQueue <T> .completeWaitersTrueCallback = new Action <object>(InputQueue <T> .CompleteWaitersTrueCallback);
}
ActionItem.Schedule(InputQueue <T> .completeWaitersTrueCallback, waiters);
return;
}
if (InputQueue <T> .completeWaitersFalseCallback == null)
{
InputQueue <T> .completeWaitersFalseCallback = new Action <object>(InputQueue <T> .CompleteWaitersFalseCallback);
}
ActionItem.Schedule(InputQueue <T> .completeWaitersFalseCallback, waiters);
}
static void ScheduleElapsedTimers(TimerGroup timerGroup, long now)
{
TimerQueue timerQueue = timerGroup.TimerQueue;
while (timerQueue.Count > 0)
{
IOThreadTimer timer = timerQueue.MinTimer;
long timeDiff = timer.dueTime - now;
if (timeDiff <= timer.maxSkew)
{
timerQueue.DeleteMinTimer();
ActionItem.Schedule(timer.callback, timer.callbackState);
}
else
{
break;
}
}
}
public void Clear()
{
lock (this.syncLock)
{
foreach (ConcurrentTransactionalDictionary <TKey, TValue> .TransactionInformation value in this.pendingTransactions.Values)
{
if (!value.HasWaiters)
{
continue;
}
while (value.Waiters.Count > 0)
{
ConcurrentTransactionalDictionary <TKey, TValue> .TransactionalAsyncWaiter transactionalAsyncWaiter = value.Waiters.Dequeue();
ActionItem.Schedule((object w) => ((ConcurrentTransactionalDictionary <TKey, TValue> .TransactionalAsyncWaiter)w).Cancel(), transactionalAsyncWaiter);
}
}
this.internalDictionary.Clear();
this.pendingTransactions.Clear();
}
}
static void CompleteWaitersLater(bool itemAvailable, IQueueWaiter[] waiters)
{
if (itemAvailable)
{
if (completeWaitersTrueCallback == null)
{
completeWaitersTrueCallback = new Action <object>(CompleteWaitersTrueCallback);
}
ActionItem.Schedule(completeWaitersTrueCallback, waiters);
}
else
{
if (completeWaitersFalseCallback == null)
{
completeWaitersFalseCallback = new Action <object>(CompleteWaitersFalseCallback);
}
ActionItem.Schedule(completeWaitersFalseCallback, waiters);
}
}
public TransactionInformation(Transaction transaction, TKey key, TValue previousValue, bool newEntry, ConcurrentTransactionalDictionary <TKey, TValue> owner)
{
this.key = key;
this.NewEntry = newEntry;
this.owner = owner;
this.PreviousValue = previousValue;
this.transaction = transaction;
this.transaction.TransactionCompleted += Fx.ThunkTransactionEventHandler((object s, TransactionEventArgs e) => {
bool status = e.Transaction.TransactionInformation.Status == TransactionStatus.Committed;
bool flag = false;
TValue tValue = default(TValue);
lock (this.owner.syncLock)
{
this.owner.pendingTransactions.Remove(this.key);
if (!status)
{
if (!this.NewEntry)
{
this.owner.internalDictionary[this.key] = this.PreviousValue;
}
else
{
this.owner.internalDictionary.Remove(this.key);
}
}
if (this.waiters != null)
{
flag = this.owner.internalDictionary.TryGetValue(this.key, out tValue);
}
}
if (this.waiters != null)
{
while (this.waiters.Count > 0)
{
ConcurrentTransactionalDictionary <TKey, TValue> .TransactionalAsyncWaiter transactionalAsyncWaiter = this.waiters.Dequeue();
ActionItem.Schedule((object w) => ((ConcurrentTransactionalDictionary <TKey, TValue> .TransactionalAsyncWaiter)w).Signal(flag, tValue), transactionalAsyncWaiter);
}
}
});
}
public static void Schedule(Action <object> callback, object state)
{
ActionItem.Schedule(callback, state, false);
}
void ScheduleWait()
{
ActionItem.Schedule(this.onWaitCallback, null);
this.waitScheduled = true;
}
private void EnqueueAndDispatch(InputQueue <T> .Item item, bool canDispatchOnThisThread)
{
bool flag = false;
InputQueue <T> .IQueueReader queueReader = null;
bool flag1 = false;
InputQueue <T> .IQueueWaiter[] queueWaiterArray = null;
bool flag2 = true;
lock (this.ThisLock)
{
flag2 = (this.queueState == InputQueue <T> .QueueState.Closed ? false : this.queueState != InputQueue <T> .QueueState.Shutdown);
this.GetWaiters(out queueWaiterArray);
if (this.queueState != InputQueue <T> .QueueState.Open)
{
flag = true;
}
else if (canDispatchOnThisThread)
{
if (this.readerQueue.Count != 0)
{
queueReader = this.readerQueue.Dequeue();
}
else
{
this.itemQueue.EnqueueAvailableItem(item);
}
}
else if (this.readerQueue.Count != 0)
{
this.itemQueue.EnqueuePendingItem(item);
flag1 = true;
}
else
{
this.itemQueue.EnqueueAvailableItem(item);
}
}
if (queueWaiterArray != null)
{
if (!canDispatchOnThisThread)
{
InputQueue <T> .CompleteWaitersLater(flag2, queueWaiterArray);
}
else
{
InputQueue <T> .CompleteWaiters(flag2, queueWaiterArray);
}
}
if (queueReader != null)
{
InputQueue <T> .InvokeDequeuedCallback(item.DequeuedCallback);
queueReader.Set(item);
}
if (!flag1)
{
if (flag)
{
InputQueue <T> .InvokeDequeuedCallback(item.DequeuedCallback);
this.DisposeItem(item);
}
return;
}
if (InputQueue <T> .onDispatchCallback == null)
{
InputQueue <T> .onDispatchCallback = new Action <object>(InputQueue <T> .OnDispatchCallback);
}
ActionItem.Schedule(InputQueue <T> .onDispatchCallback, this);
}
void EnqueueAndDispatch(Item item, bool canDispatchOnThisThread)
{
bool disposeItem = false;
IQueueReader reader = null;
bool dispatchLater = false;
IQueueWaiter[] waiters = null;
bool itemAvailable = true;
lock (ThisLock)
{
itemAvailable = !((queueState == QueueState.Closed) || (queueState == QueueState.Shutdown));
this.GetWaiters(out waiters);
if (queueState == QueueState.Open)
{
if (canDispatchOnThisThread)
{
if (readerQueue.Count == 0)
{
itemQueue.EnqueueAvailableItem(item);
}
else
{
reader = readerQueue.Dequeue();
}
}
else
{
if (readerQueue.Count == 0)
{
itemQueue.EnqueueAvailableItem(item);
}
else
{
itemQueue.EnqueuePendingItem(item);
dispatchLater = true;
}
}
}
else // queueState == QueueState.Closed || queueState == QueueState.Shutdown
{
disposeItem = true;
}
}
if (waiters != null)
{
if (canDispatchOnThisThread)
{
CompleteWaiters(itemAvailable, waiters);
}
else
{
CompleteWaitersLater(itemAvailable, waiters);
}
}
if (reader != null)
{
InvokeDequeuedCallback(item.DequeuedCallback);
reader.Set(item);
}
if (dispatchLater)
{
if (onDispatchCallback == null)
{
onDispatchCallback = new Action <object>(OnDispatchCallback);
}
ActionItem.Schedule(onDispatchCallback, this);
}
else if (disposeItem)
{
InvokeDequeuedCallback(item.DequeuedCallback);
DisposeItem(item);
}
}
