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);