| public Enqueue ( IHasWorkItemPriority workItem ) : void | ||
| workItem | IHasWorkItemPriority | A work item |
| return | void | |
public void MultipleWorkItemsMultiplePriorities()
{
// Get all the available priorities
WorkItemPriority [] priorities = Enum.GetValues(typeof(WorkItemPriority)) as WorkItemPriority [];
// Create an array of priority items
PriorityItem [] priorityItems = new PriorityItem[priorities.Length];
// Create a priority item for each priority
int i = priorities.Length;
foreach(WorkItemPriority workItemPriority in priorities)
{
--i;
priorityItems[i] = new PriorityItem(workItemPriority);
}
// Create a PermutationGenerator for the priority items
PermutationGenerator permutations = new PermutationGenerator(priorityItems);
int count = 0;
// Iterate over the permutations
foreach(object [] permutation in permutations)
{
++count;
Console.Write("Permutation #" + count + " : ");
for(int j = 0; j < permutation.Length; ++j)
{
PriorityItem pi = permutation[j] as PriorityItem;
Console.Write(pi.WorkItemPriority + ", ");
}
Console.WriteLine();
// Create a priority queue
PriorityQueue pq = new PriorityQueue();
// Enqueue each priority item according to the permutation
for(i = 0; i < permutation.Length; ++i)
{
PriorityItem priorityItem = permutation[i] as PriorityItem;
pq.Enqueue(priorityItem);
}
// Make sure all the priority items are in the queue
Assert.AreEqual(priorityItems.Length, pq.Count);
// Compare the order of the priority items
for(i = 0; i < priorityItems.Length; ++i)
{
PriorityItem priorityItem = pq.Dequeue() as PriorityItem;
Assert.AreSame(priorityItems[i], priorityItem);
}
}
}
public void OneWorkItem()
{
WorkItemPriority [] priorities = Enum.GetValues(typeof(WorkItemPriority)) as WorkItemPriority [];
foreach(WorkItemPriority wip in priorities)
{
PriorityQueue pq = new PriorityQueue();
PriorityItem pi = new PriorityItem(wip);
pq.Enqueue(pi);
Assert.AreEqual(1, pq.Count, "Failed for priority {0}", wip);
PriorityItem pi2 = pq.Dequeue() as PriorityItem;
Assert.IsNotNull(pi2, "Failed for priority {0}", wip);
Assert.AreSame(pi, pi2, "Failed for priority {0}", wip);
Assert.AreEqual(0, pq.Count, "Failed for priority {0}", wip);
}
}
public void MultipleWorkItemsOnePriority()
{
WorkItemPriority [] priorities = Enum.GetValues(typeof(WorkItemPriority)) as WorkItemPriority [];
foreach(WorkItemPriority wip in priorities)
{
PriorityQueue pq = new PriorityQueue();
PriorityItem [] priorityItems = new PriorityItem[10];
for(int i = 0; i < priorityItems.Length; ++i)
{
priorityItems[i] = new PriorityItem(wip);
pq.Enqueue(priorityItems[i]);
Assert.AreEqual(i+1, pq.Count, "Failed for priority {0} item count {1}", wip, i+1);
}
for(int i = 0; i < priorityItems.Length; ++i)
{
PriorityItem pi = pq.Dequeue() as PriorityItem;
Assert.AreEqual(priorityItems.Length-(i+1), pq.Count, "Failed for priority {0} item count {1}", wip, i+1);
Assert.IsNotNull(pi, "Failed for priority {0} item count {1}", wip, i+1);
Assert.AreSame(pi, priorityItems[i], "Failed for priority {0} item count {1}", wip, i+1);
}
Assert.AreEqual(0, pq.Count, "Failed for priority {0}", wip);
Assert.IsNull(pq.Dequeue());
Assert.AreEqual(0, pq.Count);
}
}
private void EnqueueToSTPNextWorkItem(WorkItem workItem, bool decrementWorkItemsInStpQueue)
{
lock (_lock)
{
// Got here from OnWorkItemCompletedCallback()
if (decrementWorkItemsInStpQueue)
{
--_workItemsInStpQueue;
if (_workItemsInStpQueue < 0)
{
_workItemsInStpQueue = 0;
}
--_workItemsExecutingInStp;
if (_workItemsExecutingInStp < 0)
{
_workItemsExecutingInStp = 0;
}
}
// If the work item is not null then enqueue it
if (null != workItem)
{
workItem.CanceledWorkItemsGroup = _canceledWorkItemsGroup;
RegisterToWorkItemCompletion(workItem.GetWorkItemResult());
_workItemsQueue.Enqueue(workItem);
//_stp.IncrementWorkItemsCount();
if ((1 == _workItemsQueue.Count) &&
(0 == _workItemsInStpQueue))
{
_stp.RegisterWorkItemsGroup(this);
Trace.WriteLine("WorkItemsGroup " + Name + " is NOT idle");
_isIdleWaitHandle.Reset();
}
}
// If the work items queue of the group is empty than quit
if (0 == _workItemsQueue.Count)
{
if (0 == _workItemsInStpQueue)
{
_stp.UnregisterWorkItemsGroup(this);
Trace.WriteLine("WorkItemsGroup " + Name + " is idle");
_isIdleWaitHandle.Set();
_stp.QueueWorkItem(new WorkItemCallback(this.FireOnIdle));
}
return;
}
if (!_workItemsGroupStartInfo.StartSuspended)
{
if (_workItemsInStpQueue < _concurrency)
{
WorkItem nextWorkItem = _workItemsQueue.Dequeue() as WorkItem;
_stp.Enqueue(nextWorkItem, true);
++_workItemsInStpQueue;
}
}
}
}
