protected override void OnItemProcessing(QueuerItemEventArgs <T> e, QueuerState <T> state)
{
base.OnItemProcessing(e, state);
if (!e.Stop)
{
this.ItemsInQueue.Add(state.CurrentItem = e.Item);
}
}
protected override void OnItemProcessed(QueuerItemEventArgs <T> e, QueuerState <T> state)
{
if (!e.Stop)
{
this.Item_MarkCompleted(state);
}
base.OnItemProcessed(e, state);
}
protected virtual void Process_ExecuteAsync(QueuerState <T> state, int index)
{
var worker = new Thread(this.Process_ExecuteNext)
{
Name = string.Format("Worker {0}", index + 1)
};
worker.Start(state);
}
protected virtual void OnItemProcessing(QueuerItemEventArgs <T> e, QueuerState <T> state)
{
EventHandler <QueuerItemEventArgs <T> > handler = this.ItemProcessing;
if (handler != null)
{
handler(this, e);
}
}
internal void Process(QueuerHandler <T> handler)
{
var state = new QueuerState <T>(handler);
var args = new QueuerProcessEventArgs <T>(state);
this.OnProcessInitialized(args);
for (int i = 0; i < this.ParallelTaskCount; i++)
{
this.Process_ExecuteAsync(state, i);
}
}
protected override void Process_ExecuteNext(object obj)
{
var state = new QueuerState <T>((QueuerState <T>)(obj));
if (this.Process_AssignNext(state))
{
this.Process_ExecuteSpecific(state);
}
else
{
this.OnProcessFinalized(state);
}
}
internal void Process(QueuerHandler <T> handler, IEnumerable <T> items)
{
var state = new QueuerState <T>(handler, items);
var args = new QueuerProcessEventArgs <T>(state);
var count = Math.Min(this.ParallelTaskCount, items.Count());
this.OnProcessInitialized(args);
for (int i = 0; i < count; i++)
{
this.Process_ExecuteAsync(state, i);
}
}
protected virtual void OnItemProcessed(QueuerItemEventArgs <T> e, QueuerState <T> state)
{
if (e.Stop)
{
this.Item_ProcessStopped(state);
}
else if (e.Exception == null)
{
EventHandler <QueuerItemEventArgs <T> > handler = this.ItemProcessed;
if (handler != null)
{
handler(this, e);
}
}
}
private bool Process_AssignNext(QueuerState <T> state)
{
lock (this._taskQueryLock)
{
T nextTask = this.IsProcessing ? state.Items.Where(x => !this.ItemsInQueue.Contains(x)).FirstOrDefault() : default(T);
if (nextTask.IsDefaultValue())
{
return(false);
}
else
{
this.ItemsInQueue.Add(state.CurrentItem = nextTask);
return(true);
}
}
}
protected virtual void Process_ExecuteSpecific(QueuerState <T> state)
{
var e = new QueuerItemEventArgs <T>(state.CurrentItem, Thread.CurrentThread.Name);
// Before item process
this.OnItemProcessing(e, state);
// Item process
if (!e.Stop)
{
this.Process_ExecuteHandler(state, e);
}
// After item process
this.OnItemProcessed(new QueuerItemEventArgs <T>(e), state);
// Next item
if (!e.Stop)
{
this.Process_ExecuteNext(state);
}
}
protected virtual void Process_ExecuteHandler(QueuerState <T> state, QueuerItemEventArgs <T> e)
{
try
{
using (var monitor = new QueuerMonitor(this.ProcessItemTimeout, string.Format("Process task {0}.", e.Item), e))
{
monitor.TimeExceeded += new EventHandler <QueuerMonitorEventArgs>(Monitor_TimeExceeded);
state.Handler.Invoke(state.CurrentItem);
}
}
catch (Exception ex)
{
e.Exception = e.Exception.Append(ex);
}
finally
{
if (e.Exception != null)
{
this.OnItemError(new QueuerItemEventArgs <T>(e));
}
}
}
protected virtual void Item_ProcessStopped(QueuerState <T> state)
{
var worker = new Thread(this.OnProcessFinalized);
worker.Start(state);
}
protected virtual void Item_MarkCompleted(QueuerState <T> state)
{
this.ItemsCompleted.Add(state.CurrentItem);
state.CurrentItem = default(T);
}
protected override void Process_ExecuteNext(object obj)
{
var state = new QueuerState <T>((QueuerState <T>)(obj));
this.Process_ExecuteSpecific(state);
}
