public AsyncQueueRequest(string ownerId, Guid organizationalUnitRoot, AsyncQueuePriority priority) : this()
{
this.OwnerId = ownerId;
this.OrganizationalUnitRoot = organizationalUnitRoot;
this.Priority = priority;
this.RequestStatus = AsyncQueueStatus.NotStarted;
}
public void TestPriorityQueue()
{
using (Reference <ILogger> loggerRef = Reference <ILogger> .Create(new TraceLogger(true)))
{
const int iterations = 100000;
int sendCount = 0;
int recvCount = 0;
int excpCount = 0;
// dispatches a series of tasks with various priorities
int nPriorities = Enum.GetValues(typeof(AsyncQueuePriority)).Length;
int[] _LastRecv = new int[nPriorities];
for (int l = 0; l < nPriorities; l++)
{
_LastRecv[l] = -1;
}
using (AsyncPriorityQueue queue = new AsyncPriorityQueue(loggerRef.Target))
{
AsyncQueueCallback <int> callback = delegate(int value)
{
int count = Interlocked.Increment(ref recvCount);
// check values are recevied in priority order
int i = value % 1000000;
int priority = (value - i) / 1000000;
int last = _LastRecv[priority];
if (i <= last)
{
int errors = Interlocked.Increment(ref excpCount);
if (errors <= 50)
{
loggerRef.Target.LogDebug("Priority={0}: i ({1}) not greater than previous ({2})!",
priority, i, last);
}
}
_LastRecv[priority] = i;
};
for (int i = 0; i < iterations; i++)
{
Interlocked.Increment(ref sendCount);
AsyncQueuePriority priority = (AsyncQueuePriority)(i % nPriorities);
int value = (int)priority * 1000000 + i;
queue.Dispatch <int>(value, callback, priority);
}
Assert.AreEqual <int>(iterations, sendCount);
long itemsRemaining = queue.WaitUntilEmpty(TimeSpan.FromSeconds(30));
Assert.AreEqual <long>(0, itemsRemaining);
Assert.AreEqual <int>(iterations, recvCount);
Assert.AreEqual <int>(0, excpCount);
}
}
}
protected void EnqueueData <T>(T data, AsyncQueueCallback <T> callback, AsyncQueuePriority priority, string itemKey)
{
if (_Closed)
{
return; // throw new InvalidOperationException("Cannot enqueue while closing!");
}
AsyncQueueItemUser <T> item = new AsyncQueueItemUser <T>(callback, data);
AcquireLock();
try
{
this.OnEnqueueItem(item, priority, itemKey);
}
finally
{
ReleaseLock();
}
// dispatch a dequeue thread if needed
Interlocked.Increment(ref _EnqueueThreads);
ThreadPool.QueueUserWorkItem(DequeueItems);
}
protected override void OnEnqueueItem(AsyncQueueItemBase item, AsyncQueuePriority priority, string itemKey)
{
_queue.Enqueue(item);
}
public void Dispatch <T>(T data, AsyncQueueCallback <T> callback, AsyncQueuePriority priority)
{
EnqueueData(data, callback, priority, null);
}
protected override void OnEnqueueItem(AsyncQueueItemBase item, AsyncQueuePriority priority, string itemKey)
{
_priorityStack[(int)priority][itemKey] = item;
}
public void Dispatch <T>(T data, AsyncQueueCallback <T> callback, AsyncQueuePriority priority, string itemKey)
{
EnqueueData <T>(data, callback, priority, itemKey);
}
protected virtual void OnEnqueueItem(AsyncQueueItemBase item, AsyncQueuePriority priority, string itemKey)
{
throw new NotImplementedException();
}
