public static void AddToQueueAndWaitExecution(this IQueueWorker <Action> queueWorker, Action a)
{
var signal = new ManualResetEvent(false);
Exception exception = null;
queueWorker.AddToExecutionQueue(() =>
{
try
{
a();
}
catch (Exception ex)
{
exception = ex;
}
finally {
signal.Set();
}
});
signal.WaitOne();
if (exception != null)
{
throw exception;
}
}
public ScheduleParallelLimit(IQueueWorker queue, ICounterBlocked processCount, TimeSpan timeLimit, int limit, IWorkerHandler workerHandler)
: base(queue, processCount, timeLimit, workerHandler)
{
limit = limit <= 0 ? 5 : limit;
_threadLimit = new SemaphoreSlim(limit, limit);
}
public WorkerProgressReportCompleted(IQueueWorker sender,
WorkerProgressData[] datas,
IActionInvoker <WorkerCompletedData> actionInvoker)
: base(datas)
{
_queueWorker = sender;
_actionInvoker = actionInvoker;
}
public ScheduleStrategiesBase(IQueueWorker queueWorker, ICounterBlocked processCount, TimeSpan timeLimit, IWorkerHandler workerHandler)
{
_processCount = processCount;
_timeLimit = timeLimit;
_handler = workerHandler;
_queueWorker = queueWorker;
_workerRunner = CreateWorkerRunner(_processCount, workerHandler, _timeLimit);
}
protected override async Task StartCore(IWorkerRunner workerRunner, IQueueWorker queueWorker, CancellationToken cancellationToken)
{
while (!cancellationToken.IsCancellationRequested || !queueWorker.IsEmpty)
{
await queueWorker.ReceiveAsync()
.ContinueWith(async invoker => await workerRunner.ExcecuteInvoker(await invoker), TaskContinuationOptions.OnlyOnRanToCompletion);
}
}
protected override async Task StartCore(IWorkerRunner workerRunner, IQueueWorker queueWorker, CancellationToken cancellationToken)
{
while (!cancellationToken.IsCancellationRequested || !queueWorker.IsEmpty)
{
var invoker = await queueWorker.ReceiveAsync();
await workerRunner.ExcecuteInvoker(invoker);
}
}
public IndexModel(IMessageQueue messageQueue, IConfiguration configuration, ILogger <IndexModel> logger, IQueueWorker queueWorker)
{
_messageQueue = messageQueue;
_configuration = configuration;
_logger = logger;
_queueWorker = queueWorker;
_optionA = _configuration.GetValue <string>("Voting:OptionA");
_optionB = _configuration.GetValue <string>("Voting:OptionB");
}
protected override async Task StartCore(IWorkerRunner workerRunner, IQueueWorker queueWorker, CancellationToken cancellationToken)
{
while (!cancellationToken.IsCancellationRequested || !queueWorker.IsEmpty)
{
await _threadLimit.WaitAsync()
.ContinueWith(async t =>
await queueWorker.ReceiveAsync()
.ContinueWith(async invoker => await workerRunner.ExcecuteInvoker(await invoker)
.ContinueWith(t2 => _threadLimit.Release()))
);
}
}
private void QueueBackgroundWorkerTest()
{
Log("QueueBackgroundWorkerTest");
var bw = new QueueBackWorker <Action>(action => action());
_queueWorker = bw;
_uiNotifier = bw;
for (int i = 0; i < 10; ++i)
{
var i1 = i;
_queueWorker.AddToExecutionQueue(() => {
Log("Hello" + i1);
_uiNotifier.Notify(() => Log("World" + i1));
});
}
}
internal DispatcherToken(ICounterBlocked counterProcess,
IQueueWorker queueWorker,
ActionDispatcherSettings actionDispatcherSettings,
CancellationTokenSource cancellationTokenSource,
ICounterBlocked chainCounterBlocked,
IWorkerHandler workerHandler)
{
_processCount = counterProcess;
_chainCounter = chainCounterBlocked;
_workerHandler = workerHandler;
_queueWorker = queueWorker;
_cancellationTokenSource = cancellationTokenSource;
_actionDispatcherSettings = actionDispatcherSettings;
}
public static IScheduleStrategies BuildSchedule(this ActionDispatcherSettings settings,
IQueueWorker queue,
ICounterBlocked processCount,
IWorkerHandler workerHandler)
{
var timeout = settings.Timeout == TimeSpan.MinValue ? TimeSpan.FromMinutes(1) : settings.Timeout;
switch (settings.Schedule)
{
case ScheduleType.Parallel:
return(new ScheduleParallel(queue, processCount, timeout, workerHandler));
case ScheduleType.Sequenced:
return(new ScheduleConsistent(queue, processCount, timeout, workerHandler));
case ScheduleType.ParallelLimit:
return(new ScheduleParallelLimit(queue, processCount, timeout, settings.PrefetchCount, workerHandler));
}
throw new ArgumentException("Schedule not found for " + settings.Schedule);
}
public static void AddToQueueAndWaitExecution(this IQueueWorker <Action> queueWorker, Action a, TimeSpan timeout)
{
var sync = new object();
var signal = new ManualResetEvent(false);
bool wasExecuted = false;
Exception exception = null;
queueWorker.AddToExecutionQueue(() =>
{
try
{
a();
lock (sync) {
wasExecuted = true;
}
}
catch (Exception ex)
{
exception = ex;
}
finally
{
signal.Set();
}
});
signal.WaitOne(timeout);
bool hasBeenExecuted;
lock (sync) {
hasBeenExecuted = wasExecuted;
}
if (!hasBeenExecuted)
{
throw new Exception("Таймаут операции");
}
if (exception != null)
{
throw exception;
}
}
public ScheduleConsistent(IQueueWorker queue, ICounterBlocked processCount, TimeSpan timeLimit, IWorkerHandler workerHandler)
: base(queue, processCount, timeLimit, workerHandler)
{
}
public DefaultWorkerChain(IQueueWorker queueWorker, ICounterBlocked counterBloaked)
{
_queueWorker = queueWorker;
_counterBlocked = counterBloaked;
_workerChainDefaults = new ConcurrentQueue <IActionInvoker>();
}
public SetupModel(IMessageQueue messageQueue, ILogger <SetupModel> logger, IQueueWorker queueWorker)
{
_messageQueue = messageQueue;
_logger = logger;
_queueWorker = queueWorker;
}
protected abstract Task StartCore(IWorkerRunner workerRunner, IQueueWorker queueWorker, CancellationToken cancellationToken);
