private void ProcessTask(ISynchronizedOperation taskProcessor)
{
bool tryExecuteTask(Task task)
{
s_currentlyExecutingTask = true;
bool result = TryExecuteTask(task);
s_currentlyExecutingTask = false;
return(result);
}
// This loop ensures that we execute exactly
// one task unless there are no tasks to execute
while (true)
{
if (!Queue.TryDequeue(out Task task))
{
break;
}
if (tryExecuteTask(task))
{
break;
}
}
if (TryDeactivate(taskProcessor))
{
return;
}
taskProcessor.RunAsync();
}
/// <summary>
/// Creates a new <see cref="AsyncQueue{T}"/>.
/// </summary>
/// <param name="synchronizedOperationType">The type of synchronized operation to use to process items in the queue.</param>
public AsyncQueue(SynchronizedOperationType synchronizedOperationType)
{
m_asyncQueue = new ConcurrentQueue <T>();
m_enabled = 1;
switch (synchronizedOperationType)
{
case SynchronizedOperationType.Short:
m_processItemOperation = new ShortSynchronizedOperation(TryProcessItem, OnProcessException);
break;
case SynchronizedOperationType.Long:
m_processItemOperation = new LongSynchronizedOperation(TryProcessItem, OnProcessException);
break;
case SynchronizedOperationType.LongBackground:
LongSynchronizedOperation processItemOperation = new LongSynchronizedOperation(TryProcessItem, OnProcessException);
processItemOperation.IsBackground = true;
m_processItemOperation = processItemOperation;
break;
case SynchronizedOperationType.Mixed:
m_processItemOperation = new MixedSynchronizedOperation(TryProcessItem, OnProcessException);
break;
default:
throw new ArgumentOutOfRangeException("synchronizedOperationType");
}
}
/// <summary>
/// Creates a new instance of the <see cref="DoubleBufferedQueue{T}"/> class.
/// </summary>
public DoubleBufferedQueue()
{
m_lists = new List <T> [2];
m_lists[0] = new List <T>();
m_lists[1] = new List <T>();
m_swapLock = new SpinLock();
m_processItemsOperation = new ShortSynchronizedOperation(TryProcessItems, OnProcessException);
}
/// <summary>
/// Creates a new <see cref="AsyncQueue{T}"/>.
/// </summary>
/// <param name="synchronizedOperationType">The type of synchronized operation to use to process items in the queue.</param>
public AsyncQueue(SynchronizedOperationType synchronizedOperationType)
{
m_asyncQueue = new ConcurrentQueue <T>();
m_enabled = 1;
m_processItemOperation = synchronizedOperationType switch
{
SynchronizedOperationType.Short => new ShortSynchronizedOperation(TryProcessItem, OnProcessException),
SynchronizedOperationType.Long => new LongSynchronizedOperation(TryProcessItem, OnProcessException),
SynchronizedOperationType.LongBackground => new LongSynchronizedOperation(TryProcessItem, OnProcessException)
{
IsBackground = true
},
_ => throw new ArgumentOutOfRangeException(nameof(synchronizedOperationType)),
};
}
/// <summary>
/// Creates a new <see cref="AsyncQueue{T}"/>.
/// </summary>
public AsyncQueue()
{
m_asyncQueue = new ConcurrentQueue <T>();
m_processItemOperation = new ShortSynchronizedOperation(TryProcessItem, OnProcessException);
m_enabled = 1;
}
// Instantiates new task processors and puts them in the pool.
private void CreateNewTaskProcessors(int count)
{
for (int i = 0; i < count; i++)
{
ISynchronizedOperation taskProcessor = default !;
public EventEmailType(Action <EventEmailParameters, List <Event> > sendEmailCallback)
{
m_triggeredEvents = new ConcurrentQueue <Event>();
m_sendEmailCallback = sendEmailCallback;
m_synchronizedOperation = new LongSynchronizedOperation(UpdateTimersAndSendEmail, HandleException);
}
