private async Task RunRecurrentTaskAsync(Lazy <IRecurrentTask, RecurrentTaskMetadata> recurrentTask) { object result = null; var executed = false; try { if (await recurrentTask.Value.CanExecuteAsync(_cancellationTokenSource.Token).ConfigureAwait(false)) { _logger.LogEvent(RunTaskEvent, $"Task: {recurrentTask.Metadata.Name}"); executed = true; result = await recurrentTask.Value.ExecuteAsync(_cancellationTokenSource.Token).ConfigureAwait(false); } } catch (OperationCanceledException) { } catch (Exception ex) { _logger.LogFault(RunTaskFaultEvent, $"Failed to run recurrent task '{recurrentTask.Metadata.Name}'.", ex); } finally { if (executed) { await TaskHelper.RunOnUIThreadAsync(() => { TaskCompleted?.Invoke(this, new RecurrentTaskEventArgs(recurrentTask.Metadata.Name, result)); }).ConfigureAwait(false); } } }
public void Handle(TaskCompleted <SaveContactResult> taskCompleted) { if (taskCompleted.Result.TaskResult == TaskResult.OK) { ImportContactsAsync(); } }
public void Test() { TaskCompleted callback = TestCallBack; CallBack testCallBack = new CallBack(); testCallBack.StartNewTask(callback); }
public void Task(TaskCompleted taskCompleted) { Console.WriteLine("starting task"); if (taskCompleted != null) { taskCompleted("task completed"); } }
public void StartNewTask(TaskCompleted taskCompleted) { Console.WriteLine("Initializing the task..."); if (taskCompleted != null) { taskCompleted("Task Finished!!!"); } }
private void OnTaskCompleted(ScheduledTask <T> task, ISchedulerAction action) { try { TaskCompleted?.Invoke(this, new ScheduledTaskCompletedEventArgs <T>(task, action.IsSuccess, action.IsCanceled, action.Exception, action.State)); } catch { } }
public ClientResult Post([FromBody] TaskCompleted signal) { return(new ClientResult { State = true, Message = $"Signal TaskCompleted" }); }
protected virtual void OnTaskCompleted <T>(T input) { count--; TaskCompleted?.Invoke(this, new EventArgs <object>(input)); if (count == 0) { OnCompleted(); } }
public void Handle(TaskCompleted @event) { if (@event.QueueId != queueId) { return; } timer.Stop(); }
//----------------------------------------------------------------------------- //----------------------------------------------------------------------------- public Task(TaskCompleted taskCompletedCallBack, object userData, ParameterizedThreadStart task, bool bContinuousExecution) { m_returnData = default(T); TaskOp += task; Event = null; SetCompleteEvent(taskCompletedCallBack); UserData = userData; ContinuousExecution = bContinuousExecution; }
/// <summary> /// Add a <see cref="TaskCompleted"/> callback /// </summary> /// <param name="callback"><see cref="TaskCompleted"/> callback to add</param> /// <returns>The <see cref="TaskContext"/></returns> public TaskContext Completed(TaskCompleted callback) { if (IsComplete) { callback(this); } _completed += callback; return(this); }
//---------------------------------------------------------------------------------- //---------------------------------------------------------------------------------- public void Load(String szAssetGroupName, TaskCompleted callBack) { TaskHandle taskHandle; if (!IsChunkAlreadyLoaded(szAssetGroupName, callBack)) { taskHandle = TaskManager.Instance.CreateTask <Object>(new TaskCompleted[] { AssetLoadedCallBack, callBack }, szAssetGroupName, m_iLoader.Load, false); TaskManager.Instance.ExecuteTask(taskHandle); } }
public void OnMultipleDownloadsCompleted(object sender, EventArgs e) { ComicConvert.ImgsToCbz(repo.Location, OutputFileName); Active = false; Status = "Finished"; if (TaskCompleted != null) { TaskCompleted.Invoke(this, new EventArgs()); } }
private void OnTaskCompleted(SharpEncryptTaskModel task) { TaskCompleted?.Invoke(task); if (!DisableAfterTaskCompleted) { return; } Disabled = true; BackgroundWorkerDisabled?.Invoke(Identifier); }
/// <summary> /// Called when [task completed]. /// </summary> /// <param name="task">The task.</param> /// <param name="result">The result.</param> internal void OnTaskCompleted(IScheduledTaskWorker task, TaskResult result) { TaskCompleted?.Invoke(task, new TaskCompletionEventArgs { Result = result, Task = task }); ExecuteQueuedTasks(); }
/// <summary> /// /// </summary> protected virtual void OnTaskCompleted <T>(T Result) { count--; TaskCompleted?.Invoke(this, new ResultEventArgs(Result)); if (count == 0) { OnCompleted(); } }
private void OnRunningTaskCompleted(Task task) { RunningTask runningTask = null; CancellationTokenSource cancellationTokenSource = null; var cancellationToken = default(CancellationToken); var exception = task.Exception; var stringBuilder = new StringBuilder(); stringBuilder.AppendLine($"Task completed, searching for existing running task"); stringBuilder.AppendLine($" * Canceled: {task.IsCanceled}"); stringBuilder.AppendLine($" * Completed: {task.IsCompleted}"); stringBuilder.AppendLine($" * Faulted: {task.IsFaulted}"); stringBuilder.AppendLine($" * Exception: {exception}"); Log.Debug(stringBuilder.ToString()); lock (_lock) { for (var i = 0; i < _runningTasks.Count; i++) { var possibleRunningTask = _runningTasks[i]; if (ReferenceEquals(possibleRunningTask.Task, task)) { runningTask = possibleRunningTask.RunningTask; _runningTasks.RemoveAt(i); cancellationTokenSource = possibleRunningTask.RunningTask.CancellationTokenSource; cancellationToken = cancellationTokenSource.Token; cancellationTokenSource.Dispose(); break; } } } if (runningTask is not null) { Log.Debug($"Found task '{runningTask}' for the completed task"); if (runningTask.ScheduledTask.ScheduleRecurringTaskAfterTaskExecutionHasCompleted) { RescheduleRecurringTask(runningTask); } if (!task.IsCanceled && !cancellationTokenSource.IsCancellationRequested && !_cancelledTokenSources.Contains(cancellationToken)) { TaskCompleted?.Invoke(this, new TaskEventArgs(runningTask)); } } }
public async Task RunTaskAsync(string title, Action <CancellationToken, IProgress <int> > task, Action <int> progressUpdate, Action taskCompleted) { if (_task != null) { throw new Exception("A task is already running."); } cancellationTokenSource = new CancellationTokenSource(); cancellationToken = cancellationTokenSource.Token; TaskStarted?.Invoke(this, null); _progressDialog = new ProgressDialog(this, _owner, $"Task - {title}", Maximum, Interval); _progressDialog.Show(); var progress = new Progress <int>(percent => { progressUpdate(percent); }); try { _task = Task.Run(() => { task(cancellationToken, progress); }, cancellationToken); // wait for worker task to finish. await _task; } catch (TaskCanceledException) { Console.WriteLine("Task cancelled."); } catch (Exception exception) { MessageBox.Show(exception.Message); } SystemSounds.Beep.Play(); taskCompleted(); _progressDialog.Close(); TaskCompleted?.Invoke(this, null); _progressDialog = null; _task = null; }
public async Task <bool> StartTask(string tempInputFolderPath, string tempOutputFolderPath, string waifu2xCaffePath, string ffmpegPath) { bool faulted = false; try { if (!Initialize()) { return(false); } } catch (Exception e) { TaskFaulted?.Invoke(this, $"Error occurred during initialization: {e.Message}"); Logger.Error("An exception occurred during initialization: {@Exception}", e); faulted = true; } bool taskSucceeded = false; if (!faulted) { try { taskSucceeded = await Start(tempInputFolderPath, tempOutputFolderPath, waifu2xCaffePath, ffmpegPath); } catch (Exception e) { taskSucceeded = false; TaskFaulted?.Invoke(this, $"Error occurred while processing: {e.Message}"); Logger.Error("An exception occurred while processing: {@Exception}", e); } } TaskCompleted?.Invoke(this); try { return(Dispose()); } catch (Exception e) { if (!faulted) { TaskFaulted?.Invoke(this, $"Error occurred while running cleanup: {e.Message}"); } return(false); } }
public void Invoke(CommandLineApplication app) { CommandOption fullScreenOpt = app.Option("-fullscreen", null, CommandOptionType.SingleValue); CommandOption languageOpt = app.Option("-language", null, CommandOptionType.MultipleValue); CommandOption roleOpt = app.Option("-role", null, CommandOptionType.SingleValue); CommandOption awaitedOpt = app.Option("-awaited", null, CommandOptionType.SingleValue); CommandOption closeOpt = app.Option("-close", null, CommandOptionType.SingleOrNoValue); app.OnExecute(() => { int awaited = 0; bool fullScreen = false; bool closeWhenDone = false; string role = roleOpt.Value(); string[] language = languageOpt.Values.ToArray(); int.TryParse(awaitedOpt.Value(), out awaited); bool.TryParse(closeOpt.Value(), out closeWhenDone); bool.TryParse(fullScreenOpt.Value(), out fullScreen); InitializeWebBrowser(); if (fullScreen) { driver.Manage().Window.Maximize(); } driver.Navigate().GoToUrl(TargetUri); driver.WaitElement(ClearFiltersXpath); driver.Scroll(ClearFiltersXpath); driver.ClickXp(LangXpath); LangFilter.Invoke(driver, language); driver.ClickXp(LangXpath); driver.ClickXp(DepartsXpath); DepartmentFilter.Invoke(driver, role); Count = driver.GetElementsCount(AwaliableVacansions); if (TaskCompleted != null) { TaskCompleted.Invoke(awaitedVacansionsCount: awaited, realVacansionsCount: Count); } if (closeWhenDone) { driver.Dispose(); } }); }
public void ExecuteTask(Assembly task, Object[] parameters, GruntTaskingMessage message) { string output = ""; try { var results = task.GetType("Task").GetMethod("Execute").Invoke(null, parameters); if (results != null) { output = (string)results; } TaskCompleted?.Invoke(this, new TaskCompletedArgs(message, output)); } catch (Exception e) { TaskCompleted?.Invoke(this, new TaskCompletedArgs(message, "TaskHandler Exception: " + e.Message + "\n" + e.StackTrace)); } }
private void RaiseTaskCompleted(IBackgroundTask task, object state) { TaskCompleted?.Invoke(task, state); lock (_tasks) { if (_tasks.Count > 0) { _uiDispatcher.Dispatch(() => _tasks.Dequeue()); } else { _taskIsRunning = false; } } }
private void StartToInvokeFunction() { var cts = new CancellationToken(); Task.Factory.StartNew(async() => { while (ActionQueue.Any()) { ActionQueue.TryDequeue(out Action action); await Task.Factory.StartNew(action, cts); await Task.Delay(100, cts); } _runingAction = false; }, cts); TaskCompleted?.Invoke(this, EventArgs.Empty); }
//------------------------------------------------------------------------------- /// <summary> /// overloaded: Creates a task. /// </summary> /// <typeparam name="T">data type.</typeparam> /// <param name="taskCompletedCallBack"> callback upon complete.</param> /// <param name="userData">user data to be used in task.</param> /// <param name="task">thread</param> /// <param name="bContinuousExecution">if allow continuous execution.</param> /// <returns></returns> //------------------------------------------------------------------------------- public TaskHandle CreateTask <T>(TaskCompleted taskCompletedCallBack, object userData, ParameterizedThreadStart task, bool bContinuousExecution) { Task <T> theTask = new Task <T>(taskCompletedCallBack, userData, task, bContinuousExecution); theTask.Name = "Task " + m_nTaskCount; TaskHandle taskHandle = new TaskHandle(m_nTaskCount++); theTask.Handle = taskHandle; m_dictionaryLock.TryEnterWriteLock(5); { m_tasks.Add(taskHandle, theTask); } m_dictionaryLock.ExitWriteLock(); return(taskHandle); }
public async Task <TaskCompleted> SaveTaskCompleted(TaskCompleted taskCompleted) { try { taskCompleted.LastUpdatedDate = DateTime.Now; taskCompleted.LastUpdatedBy = _userManager.CurrentUser(); var savedTaskCompleted = _unitOfWork.TaskCompeletedRepository.Add(taskCompleted); await _unitOfWork.SaveChangesAsync(); return(savedTaskCompleted); } catch (Exception ex) { throw ex; } }
public void Handle(TaskCompleted <PhotoResult> result) { if (result.Result.TaskResult == TaskResult.OK) { byte[] bytes; var sourceStream = result.Result.ChosenPhoto; var fileName = result.Result.OriginalFileName; using (var memoryStream = new MemoryStream()) { sourceStream.CopyTo(memoryStream); bytes = memoryStream.ToArray(); } StateService.ProfilePhotoBytes = bytes; PhotoBytes = bytes; NotifyOfPropertyChange(() => PhotoBytes); } }
//---------------------------------------------------------------------------------- //---------------------------------------------------------------------------------- private bool IsChunkAlreadyLoaded(String szAssetGroupName, TaskCompleted callback) { bool bIsLoaded = false; if (m_loadedAssets.ContainsKey(szAssetGroupName.GetHashCode())) { Asset asset = m_loadedAssets[szAssetGroupName.GetHashCode()]; asset.RefCount++; if (callback != null) { callback(asset); } bIsLoaded = true; } return(bIsLoaded); }
/// <summary> /// Called to notify task controller that a task has been completed. /// </summary> /// <param name="taskCompleted"> /// The <see cref="TaskCompleted"/> notification message. /// </param> void OnTaskCompleted(TaskCompleted taskCompleted) { if (taskCompleted == null) { throw new ArgumentNullException("taskCompleted"); } Log.Information( "{ActorPath}: Task completed by task-runner '{TaskRunnerName}' in {RunTime}: {What} ({TotalTaskCount} tasks now active)", Self.Path.ToUserRelativePath(), taskCompleted.ByWho, taskCompleted.RunTime, taskCompleted.What, --_outstandingTaskCount ); if (_shutdownPending) { StopIfAllRequestsComplete(); } }
public MainWindow() { Window = this; InitializeComponent(); InitComponents(); var musicDir = Properties.Settings.Default.MusicDir.Trim(); if (string.IsNullOrEmpty(musicDir)) { musicDir = Properties.Settings.Default.DefaultMusicDir.Trim(); } MusicDirTextBox.Text = musicDir; AddLyricForAllRadioButton.IsChecked = true; _lyricAdder = new LyricAdder(); _taskCompleted = InitComponents; }
private void Handle(TaskCompleted message) { RequireActivation(true); if (message.ParentTaskInstanceId != this.InstanceId) { throw new Exception(); } if (message is MultiTaskCompleted) { throw new Exception(); } TransitionInfo ti = GetTransition(message.FromTaskInstanceId); if (ti == null) { throw new Exception(); } log.Info("MT Child task {0} has completed", ti.InstanceId); if (ti.Status == TransitionStatus.Completed) { return; } if (!ti.IsTransitionActive) { log.Warn("Transition {0} ({1}) is not active: {2}", ti.InstanceId, ti.TaskId, ti.Status); return; } ti.Status = TransitionStatus.Completed; ti.OutputData = message.OutputData; if (ti.OutputData == null) { log.Info("No output data returned from child task {0}", ti.InstanceId); ti.OutputData = new Dictionary <string, object>(); } OnTransitionStatusChanged(ti.InstanceId); return; }
/// <summary> /// Add a <see cref="TaskCompleted"/> callback /// </summary> /// <param name="callback"><see cref="TaskCompleted"/> callback to add</param> /// <returns>The <see cref="TaskContext"/></returns> public TaskContext Completed(TaskCompleted callback) { if (IsComplete) callback(this); _completed += callback; return this; }
public bool Poll(out TaskCompleted completed) { return _completeds.TryTake(out completed); }
public void OfferAndWaitUntilAccepted(TaskCompleted completed) { _completeds.Add(completed); }
public bool Offer(TaskCompleted completed) { return _completeds.TryAdd(completed); }
/// <summary> /// Called to notify task controller that a task has been completed. /// </summary> /// <param name="taskCompleted"> /// The <see cref="TaskCompleted"/> notification message. /// </param> void OnTaskCompleted(TaskCompleted taskCompleted) { if (taskCompleted == null) throw new ArgumentNullException("taskCompleted"); Log.Information( "{ActorPath}: Task completed by task-runner '{TaskRunnerName}' in {RunTime}: {What} ({TotalTaskCount} tasks now active)", Self.Path.ToUserRelativePath(), taskCompleted.ByWho, taskCompleted.RunTime, taskCompleted.What, --_outstandingTaskCount ); if (_shutdownPending) StopIfAllRequestsComplete(); }
public void Process(TaskCompleted completed) { completed.Send(_socket); }