/// <summary>
/// Adiciona na fila uma nova tarefa de escrita.
/// </summary>
/// <param name="task"></param>
internal void Enqueue(IWriteBehindTask task)
{
lock (this)
{
_queue.Enqueue(task);
Monitor.PulseAll(this);
}
}
/// <summary>
/// Define o estado para a tarefa.
/// </summary>
/// <param name="taskId">Identificador da tarefa.</param>
/// <param name="state">Estado da tarefa.</param>
internal void SetState(string taskId, TaskState state)
{
lock (this)
{
_queue.UpdateState(taskId, state);
IWriteBehindTask task = _queue.Peek();
if ((task != null) && (task.TaskId == taskId))
{
lock (_statusMutex)
Monitor.PulseAll(_statusMutex);
}
}
}
/// <summary>
/// Remove a tarefa da fila.
/// </summary>
/// <param name="taskId">Identificador da tarefa.</param>
internal void Dequeue(string taskId)
{
lock (this)
{
IWriteBehindTask task = _queue.Peek();
if ((task != null) && (task.TaskId == taskId))
{
_queue.Dequeue();
}
else
{
var queue = new WriteBehindQueue(_queue);
for (int i = 0; i < _queue.Count; i++)
{
task = queue.Dequeue();
if ((task != null) && (task.TaskId == taskId))
{
_queue = queue;
break;
}
}
}
}
}
/// <summary>
/// Método de execução do processador.
/// </summary>
protected void Run()
{
while ((_worker != null) && !_isDisposing)
{
IWriteBehindTask task = null;
try
{
lock (this)
{
if (_queue.Count < 1)
{
Monitor.Wait(this);
}
if (_queue.Count > 0)
{
task = _queue.Peek();
}
}
if (task != null)
{
switch (task.State)
{
case TaskState.Wait:
{
lock (_statusMutex)
{
if ((task.State == TaskState.Wait) && !Monitor.Wait(_statusMutex, _timeout))
{
task.State = TaskState.Execute;
}
}
continue;
}
case TaskState.Execute:
_queue.Dequeue();
lock (_processMutex)
{
if (!_isDisposing)
{
task.Process();
}
continue;
}
case TaskState.Remove:
_queue.Dequeue();
continue;
}
}
}
catch (ThreadAbortException)
{
break;
}
catch (Exception)
{
continue;
}
}
}
/// <summary>
/// Executa todas as tarefas da origem.
/// </summary>
/// <param name="args"></param>
protected void ExecuteAllTaskForSource(object args)
{
IWriteBehindTask task = null;
object[] objArray = args as object[];
string str = objArray[0] as string;
bool flag = (bool)objArray[1];
ArrayList list = new ArrayList();
for (int i = 0; i < _queue.Count; i++)
{
try
{
task = _queue[i];
if ((task != null) && (task.Source == str))
{
list.Add(i);
if (flag)
{
switch (task.State)
{
case TaskState.Wait:
{
lock (_statusMutex)
if ((task.State == TaskState.Wait) && !Monitor.Wait(_statusMutex, _timeout))
{
task.State = TaskState.Execute;
}
continue;
}
case TaskState.Execute:
lock (_processMutex)
{
if (!_isDisposing)
{
task.Process();
}
continue;
}
case TaskState.Remove:
_queue.Dequeue();
continue;
}
}
}
}
catch (ThreadAbortException)
{
break;
}
catch (Exception)
{
}
}
for (int j = list.Count - 1; j >= 0; j--)
{
_queue.RemoveAt((int)list[j]);
}
}
