public void Start() { lock (_external_lock) { lock (_thread_flag_lock) { //clearing attributed status _upload_thread_flag = _upload_thread_flag & 0xffffff; if ((_upload_thread_flag & (_UPLOAD_THREAD_FLAG_READY | _UPLOAD_THREAD_FLAG_PAUSED)) != 0) { if (_enable_slice_upload) { Tracer.GlobalTracer.TraceInfo("---STARTED---"); _upload_thread_flag = (_upload_thread_flag | _UPLOAD_THREAD_FLAG_START_REQUESTED) & ~_UPLOAD_THREAD_FLAG_READY; //_monitor_thread = new Thread(_monitor_thread_callback); //_monitor_thread.IsBackground = true; //_monitor_thread.Name = "Upload monitor"; //_monitor_thread.Start(); ThreadPool.QueueUserWorkItem(new WaitCallback(_monitor_thread_callback), null); } else { throw new NotImplementedException(); } } else { return; } } } try { TaskStarted?.Invoke(this, new EventArgs()); } catch { } }
private void SetCurrentTask(AIBackupUnitTask task) { currentTask = task; currentTask.Finished += OnCurrentTaskFinished; currentTask.Start(); TaskStarted?.Invoke(currentTask); }
private void IterateWorkflow(WorkflowRun <TWfContext> run) { if (_finish.Exists(precondition => precondition.Met(run.FinishedTasks))) { WorkflowFinished?.Invoke(this, new WorkflowEventArgs <TWfContext>(run.RunId, run.Context)); return; } var tasksToExecute = _tasks.Where(kv => kv.Value.Met(run.FinishedTasks) && !run.HasFinished(kv.Key)) .Select(kv => kv.Key).ToList(); var anythingFinished = false; foreach (var task in tasksToExecute) { task.Action(run.Context); run.StartTask(task); TaskStarted?.Invoke(this, new WorkflowTaskEventArgs <TWfContext>(run.RunId, task.TaskId, run.Context)); if (task.Autocomplete) { TaskFinished?.Invoke(this, new WorkflowTaskEventArgs <TWfContext>(run.RunId, task.TaskId, run.Context)); run.FinishTask(task); anythingFinished = true; } } if (anythingFinished) { IterateWorkflow(run); } }
public void Run(string taskName, string taskDescription, Action <ITaskChanges> taskAction) { var task = new Task(taskName, taskDescription, taskAction); TaskStarted.Raise(this, new TaskEventArgs(task)); task.Run(); }
public void Update() { _searchItems.Clear(); var classNames = ClassNames.ToList(); var i = 0; var n = classNames.Count; var progress = new Progress <ProgressInfo>(); TaskStarted?.Invoke(progress); var progressInterface = (IProgress <ProgressInfo>)progress; _searchItems.AddRange( classNames .Select( name => { var subKey = _clsidKey.OpenSubKey(name); var regClass = subKey != default ? CreateSearchItem(new RegistryClass(subKey)) : default; progressInterface.Report(new ProgressInfo("Load Classes", ++i, n)); return(regClass); } ) ); OnPropertyChanged(nameof(Items)); }
/// <summary> /// 开始下载任务 /// </summary> public void Start() { lock (_external_lock) { lock (_thread_flag_lock) { //clear error flag _download_thread_flag = _download_thread_flag & ~_DOWNLOAD_THREAD_FLAG_ERROR; if (((_download_thread_flag & 0xffffff) & (_DOWNLOAD_THREAD_FLAG_READY | _DOWNLOAD_THREAD_FLAG_PAUSED)) != 0) { //Tracer.GlobalTracer.TraceInfo("---STARTED---"); _download_thread_flag = (_download_thread_flag | _DOWNLOAD_THREAD_FLAG_START_REQUESTED) & ~_DOWNLOAD_THREAD_FLAG_READY; _url_fail_to_fetch_count = 0; //_api.GetAccount(_data.AccountID).GetLocateDownloadLinkAsync(_data.Path, _main_url_request_callback); _url_expire_time = DateTime.Now; _monitor_thread = new Thread(_monitor_thread_callback); _monitor_thread.Name = "Download Monitor"; _monitor_thread.IsBackground = false; _monitor_thread.Start(); } } } try { TaskStarted?.Invoke(this, new EventArgs()); } catch { } }
/// <summary> /// This function controls the button events from UVC. /// This code if not run in background process, will not be able to handle button pressed events when app is suspended. /// </summary> /// <param name="sender"></param> /// <param name="args"></param> private void systemmediatransportcontrol_ButtonPressed(SystemMediaTransportControls sender, SystemMediaTransportControlsButtonPressedEventArgs args) { switch (args.Button) { case SystemMediaTransportControlsButton.Play: Debug.WriteLine("UVC play button pressed"); // If music is in paused state, for a period of more than 5 minutes, //app will get task cancellation and it cannot run code. //However, user can still play music by pressing play via UVC unless a new app comes in clears UVC. //When this happens, the task gets re-initialized and that is asynchronous and hence the wait if (!_backgroundtaskrunning) { var result = TaskStarted.WaitOne(5000); if (!result) { throw new Exception("Background Task didn't initialize in time"); } StartPlayback(); } else { BackgroundMediaPlayer.Current.Play(); } break; case SystemMediaTransportControlsButton.Pause: Debug.WriteLine("UVC pause button pressed"); try { BackgroundMediaPlayer.Current.Pause(); } catch (Exception ex) { Debug.WriteLine(ex.ToString()); } break; case SystemMediaTransportControlsButton.Next: Debug.WriteLine("UVC next button pressed"); SkipToNext(); break; case SystemMediaTransportControlsButton.Previous: Debug.WriteLine("UVC previous button pressed"); if (BackgroundMediaPlayer.Current.Position.TotalSeconds > 20) { //StartPlayback(); BackgroundMediaPlayer.Current.Position = TimeSpan.Zero; BackgroundMediaPlayer.Current.Play(); } else { SkipToPrevious(); } break; } }
public void OnTaskStarted(TaskDefinition task) { TaskStarted?.Invoke(new TaskStartedEvent { Task = task, Timestamp = DateTimeUtils.Now }); }
/// <summary> /// Executes the task. /// </summary> /// <param name="task">The task.</param> /// <exception cref="NotImplementedException"></exception> public void ExecuteTask(IEngineTask task) { // Check if task can be executed if (!task.CanBeExecuted()) { task.AddMessage($"The task cannot be executed.", MessageSeverity.Error); if (task.ParentJob.FailIfAnyTaskHasError) { throw new EngineException(logger, $"The task cannot be executed. This job was aborted."); } else { return; } } // Execute task if (TaskStarted != null) { TaskStarted.Invoke((Guid)task.EntityId, (Guid)task.InstanceID); } task.Start(); // Stop task task.Stop(); if (task.HasErrors) { task.AddMessage($"The task (instance: {task.InstanceID}) was not executed cause one or more errors occurs.", MessageSeverity.Error); if (task.ParentJob.FailIfAnyTaskHasError) { if (TaskFinished != null) { TaskFinished.Invoke((Guid)task.EntityId, (Guid)task.InstanceID, false); } throw new EngineException(logger, $"The task (instance: {task.InstanceID}) was not executed cause one or more errors occurs. This job was aborted."); } } else if (task.HasWarnings) { task.AddMessage($"The task (instance: {task.InstanceID}) was executed but one or more warning occurs.", MessageSeverity.Warning); if (task.ParentJob.FailIfAnyTaskHasWarning) { if (TaskFinished != null) { TaskFinished.Invoke((Guid)task.EntityId, (Guid)task.InstanceID, false); } throw new EngineException(logger, $"The task (instance: {task.InstanceID}) was executed but one or more warning occurs. This job was aborted."); } } if (TaskFinished != null) { TaskFinished.Invoke((Guid)task.EntityId, (Guid)task.InstanceID, true); } }
/// <summary> /// Raise one of the events that is appropriate for the type of the BuildEventArgs /// </summary> public void Dispatch(BuildEventArgs buildEvent) { if (buildEvent is BuildMessageEventArgs) { MessageRaised?.Invoke(null, (BuildMessageEventArgs)buildEvent); } else if (buildEvent is TaskStartedEventArgs) { TaskStarted?.Invoke(null, (TaskStartedEventArgs)buildEvent); } else if (buildEvent is TaskFinishedEventArgs) { TaskFinished?.Invoke(null, (TaskFinishedEventArgs)buildEvent); } else if (buildEvent is TargetStartedEventArgs) { TargetStarted?.Invoke(null, (TargetStartedEventArgs)buildEvent); } else if (buildEvent is TargetFinishedEventArgs) { TargetFinished?.Invoke(null, (TargetFinishedEventArgs)buildEvent); } else if (buildEvent is ProjectStartedEventArgs) { ProjectStarted?.Invoke(null, (ProjectStartedEventArgs)buildEvent); } else if (buildEvent is ProjectFinishedEventArgs) { ProjectFinished?.Invoke(null, (ProjectFinishedEventArgs)buildEvent); } else if (buildEvent is BuildStartedEventArgs) { BuildStarted?.Invoke(null, (BuildStartedEventArgs)buildEvent); } else if (buildEvent is BuildFinishedEventArgs) { BuildFinished?.Invoke(null, (BuildFinishedEventArgs)buildEvent); } else if (buildEvent is CustomBuildEventArgs) { CustomEventRaised?.Invoke(null, (CustomBuildEventArgs)buildEvent); } else if (buildEvent is BuildStatusEventArgs) { StatusEventRaised?.Invoke(null, (BuildStatusEventArgs)buildEvent); } else if (buildEvent is BuildWarningEventArgs) { WarningRaised?.Invoke(null, (BuildWarningEventArgs)buildEvent); } else if (buildEvent is BuildErrorEventArgs) { ErrorRaised?.Invoke(null, (BuildErrorEventArgs)buildEvent); } AnyEventRaised?.Invoke(null, buildEvent); }
public virtual void OnTaskStarted(EventArgs e) { Collect.Enabled = NScan.Enabled = false; CameraBox.Enabled = false; BeamFlagBox.Objects.Enabled = false; Abort.Enabled = Pause.Enabled = true; Paused.Set(); // Set running/resumed. TaskStarted.Raise(this, e); }
public void OnTaskStarted(EventArgs args) { groupBoxReadMode.Enabled = false; groupBoxSettings.Enabled = false; groupBoxTemp.Enabled = false; buttonAbort.Enabled = true; buttonPause.Enabled = true; buttonSave.Enabled = false; Paused.Set(); // set running/resumed TaskStarted?.Invoke(this, args); }
private bool StartTask(IScheduledTask scheduledTask) { lock (_lock) { if (!IsEnabled) { return(false); } Log.Debug("Starting task {0}", scheduledTask); var runningTask = new RunningTask(scheduledTask, _timeService.CurrentDateTime); #pragma warning disable 4014 // Note: don't await, we are a scheduler. var task = TaskShim.Run(async() => await scheduledTask.InvokeAsync(), runningTask.CancellationTokenSource.Token); task.ContinueWith(OnRunningTaskCompleted); #pragma warning restore 4014 Log.Debug("Started task {0}", scheduledTask); var completed = task.IsCompleted; if (completed) { // Shortcut mode TaskStarted.SafeInvoke(this, new TaskEventArgs(runningTask)); OnRunningTaskCompleted(task); } else { _runningTasks.Add(new RunningTaskInfo(task, runningTask)); TaskStarted.SafeInvoke(this, new TaskEventArgs(runningTask)); } } // Note: it's important to start possible recurring tasks outside the loop if (scheduledTask.Recurring.HasValue) { var startDate = _timeService.CurrentDateTime.Add(scheduledTask.Recurring.Value); Log.Debug("Task {0} is a recurring task, rescheduling a copy at '{1}'", scheduledTask, startDate); var newScheduledTask = (IScheduledTask)scheduledTask.Clone(); newScheduledTask.Start = startDate; AddScheduledTask(newScheduledTask); } return(true); }
public void StartTask(BuildNode node) { _logger.LogDebug($"BuildProcess.StartTask: Node: \"{node.Name}\""); var task = FindTask(node); if (task != null) { _logger.LogDebug($"BuildProcess.StartTask: Task: {task.GetHashCode()}"); CurrentTasks.Add(task); task.Start(); TaskStarted?.Invoke(task); } }
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; }
/// <summary> /// Starts new task in current session /// </summary> /// <param name="context">The task context to start</param> private void StartNextTask(TimeTaskContext context) { // Set provided time CurrentTimeLeft = context.SessionDynamicTime; // Save it for progress calculations mCurrentTask.SessionDynamicTime = CurrentTimeLeft; // Start the timer mSecondsTicker.Start(); // Inform subscribers TaskStarted.Invoke(); }
/// <summary> /// Called to notify task controller that a task has started. /// </summary> /// <param name="taskStarted"> /// The <see cref="TaskStarted"/> notification message. /// </param> void OnTaskStarted(TaskStarted taskStarted) { if (taskStarted == null) { throw new ArgumentNullException("taskStarted"); } Log.Information( "{ActorPath}: Task started by task-runner '{TaskRunnerName}': {What} ({TotalTaskCount} tasks now active)", Self.Path.ToUserRelativePath(), taskStarted.ByWho, taskStarted.What, _outstandingTaskCount ); }
/// <summary> /// The Run method is the entry point of a background task. /// </summary> /// <param name="taskInstance"></param> public void Run(IBackgroundTaskInstance taskInstance) { _appSettingsHelper = new AppSettingsHelper(); Debug.WriteLine("Background Audio Task " + taskInstance.Task.Name + " starting..."); // InitializeAsync SMTC object to talk with UVC. //Note that, this is intended to run after app is paused and //hence all the logic must be written to run in background process _systemmediatransportcontrol = BackgroundMediaPlayer.Current.SystemMediaTransportControls; _systemmediatransportcontrol.ButtonPressed += systemmediatransportcontrol_ButtonPressed; // _systemmediatransportcontrol.PropertyChanged += systemmediatransportcontrol_PropertyChanged; _systemmediatransportcontrol.IsEnabled = true; _systemmediatransportcontrol.IsPauseEnabled = true; _systemmediatransportcontrol.IsPlayEnabled = true; _systemmediatransportcontrol.IsNextEnabled = true; _systemmediatransportcontrol.IsPreviousEnabled = true; //InitializeAsync message channel BackgroundMediaPlayer.MessageReceivedFromForeground += BackgroundMediaPlayer_MessageReceivedFromForeground; BackgroundMediaPlayer.Current.CurrentStateChanged += Current_CurrentStateChanged; //Send information to foreground that background task has been started if app is active if (ForegroundAppState == ForegroundAppStatus.Active) { var message = new ValueSet { { PlayerConstants.BackgroundTaskStarted, "" } }; BackgroundMediaPlayer.SendMessageToForeground(message); } _appSettingsHelper.Write(PlayerConstants.BackgroundTaskState, PlayerConstants.BackgroundTaskRunning); // This must be retrieved prior to subscribing to events below which use it _deferral = taskInstance.GetDeferral(); // Mark the background task as started to unblock SMTC Play operation (see related WaitOne on this signal) TaskStarted.Set(); taskInstance.Task.Completed += Taskcompleted; taskInstance.Canceled += OnCanceled; //Add handlers for MediaPlayer //Add handlers for playlist trackchanged QueueManager.TrackChanged += playList_TrackChanged; QueueManager.ErrorHandler += QueueManager_ErrorHandler; _backgroundtaskrunning = true; }
private void StartTask(IScheduledTask scheduledTask) { Task task = null; RunningTask runningTask = null; lock (_lock) { if (!IsEnabled) { return; } Log.Debug($"Starting task {scheduledTask}"); runningTask = new RunningTask(scheduledTask, _timeService.CurrentDateTime); #pragma warning disable 4014 // Note: don't await, we are a scheduler task = TaskShim.Run(async() => await scheduledTask.InvokeAsync(), runningTask.CancellationTokenSource.Token); task.ContinueWith(OnRunningTaskCompleted); #pragma warning restore 4014 Log.Debug($"Started task {scheduledTask}"); } if (!scheduledTask.ScheduleRecurringTaskAfterTaskExecutionHasCompleted) { // Schedule immediately, even though task is still running RescheduleRecurringTask(runningTask); } var completed = task.IsCompleted; if (completed) { // Shortcut mode TaskStarted?.Invoke(this, new TaskEventArgs(runningTask)); OnRunningTaskCompleted(task); } else { _runningTasks.Add(new RunningTaskInfo(task, runningTask)); TaskStarted?.Invoke(this, new TaskEventArgs(runningTask)); } }
public RepetitiveTask(Action action, int dueTime, int period) { State = RepeririveTaskState.Stopped; DueTime = dueTime; Period = period; _action = action; TaskStarted += (task) => State = RepeririveTaskState.TaskStarted; TaskEnded += (task, status) => State = State != RepeririveTaskState.Stopped ? RepeririveTaskState.Waiting : State; _timer = new Timer((sender) => { TaskStarted?.Invoke(this); Task.Factory.StartNew(action).ContinueWith((task) => { TaskEnded?.Invoke(this, task.Status); }); }, null, Timeout.Infinite, Timeout.Infinite); }
public void Confirm() { Task.Factory.StartNew(() => { try { TaskEx.Delay(5000, _cancellationTokenSource.Token).GetAwaiter().GetResult(); if (_cancellationTokenSource.IsCancellationRequested) { return; } } catch (TaskCanceledException) { return; } TaskStarted?.Invoke(this, new DataEventArgs <CreatedNetworkTaskData>(_taskData)); }); }
/// <summary> /// Checks the queue for new tasks and pops the next available task /// </summary> private void PopQueue() { if (!IsEnabled) { return; } lock (_taskQueue) { Task = null; if (!_taskQueue.Any()) { return; } Task = _taskQueue[0]; _taskQueue.RemoveAt(0); } // Start a thread to execute the task _taskFactory.StartNew(() => { // Reset values IsAbortPending = false; TaskStarted?.Invoke(this, new TaskEventArgs(Task)); ResetStatus(); Logger.Record($"Executing task {Task.Type} for {Task.ModID}"); // Execute task bool result = ExecuteTask(); // Reset values ResetStatus(); Logger.Record($"Task executed {(result ? "successfully" : "unsuccessfully")}"); TaskEnded?.Invoke(this, new TaskEndedEventArgs(Task, result)); // Pop queue again PopQueue(); }); }
public void RunTask() { if (!readyToGo) { throw new ArgumentException("Not ready to go!"); } else { if (TaskStarted != null) { TaskStarted.Invoke(this, new EventArgs()); } } Active = true; Status = "Analyzing source"; var urlGen = SetupTask(); var urls = urlGen.Get(0, NumberToDownload); using (repo = new Repository()) { // pass on the events repo.DownloadFileCompleted += OnSingleDownloadCompleted; repo.DownloadProgressChanged += OnDownloadProgressChanged; repo.MultipleDownloadsCompleted += OnMultipleDownloadsCompleted; // set number downloaded to zero NumberDownloaded = 0; // begin (blocks) repo.Download(urls); // repo.Active is set and unset automatically } }
/// <summary> /// 启动服务 /// </summary> public async Task Start() { cts = new CancellationTokenSource(); await Task.Run(() => { int times = 0; TaskStarted?.Invoke(this, new TaskEventArgs(TaskName)); while (!cts.Token.IsCancellationRequested) { times++; if (times *Interval >= TaskCheckInterval) { Log.Information($"{TaskName}正在运行"); times = 0; } Repository = new AppRepository(); lastTime = DateTime.Now; try { Run(); } catch (Exception ex) { Log.Error(ex, $"{TaskName}抛出异常"); } try { Task.Delay(Interval).Wait(cts.Token); } catch (OperationCanceledException) { } } Log.Warning($"{TaskName}已取消"); TaskStopped?.Invoke(this, new TaskEventArgs(TaskName)); }, cts.Token); }
/// <summary> /// Handles background task cancellation. Task cancellation happens due to : /// 1. Another Media app comes into foreground and starts playing music /// 2. Resource pressure. Your task is consuming more CPU and memory than allowed. /// In either case, save state so that if foreground app resumes it can know where to start. /// </summary> private void OnCanceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason) { // You get some time here to save your state before process and resources are reclaimed Debug.WriteLine("MyBackgroundAudioTask " + sender.Task.TaskId + " Cancel Requested..."); try { TaskStarted.Reset(); if (_queueManager != null) { QueueManager.TrackChanged -= playList_TrackChanged; _queueManager = null; } _appSettingsHelper.Write(PlayerConstants.BackgroundTaskState, PlayerConstants.BackgroundTaskCancelled); _backgroundtaskrunning = false; //unsubscribe event handlers _systemmediatransportcontrol.ButtonPressed -= systemmediatransportcontrol_ButtonPressed; BackgroundMediaPlayer.Shutdown(); // shutdown media pipeline } catch (Exception ex) { Debug.WriteLine(ex.ToString()); } if (_deferral != null) { _deferral.Complete(); // signals task completion. Debug.WriteLine("AudioPlayer Cancel complete..."); } QueueManager.ErrorHandler -= QueueManager_ErrorHandler; TileUpdateManager.CreateTileUpdaterForApplication("App").Clear(); }
private async Task TaskLoop(CancellationToken ct) { try { while (!ct.IsCancellationRequested) { State = NetworkServiceState.Finding; var result = await _netService.WaitForOneConnection(ct); var connection = result.Key; var commingType = result.Value; var writer = new BinaryWriter(connection.GetStream()); var reader = new BinaryReader(connection.GetStream()); if (commingType == ConnectionCommingType.FromListen) { var jsontask = reader.ReadString(); var task = JsonConvert.DeserializeObject <CreatedNetworkTaskData>(jsontask); TaskCreated?.Invoke(this, new DataEventArgs <CreatedNetworkTaskData>(task)); } else { //todo: generate task... var task = new CreatedNetworkTaskData() { Frequency = 33100, FrequencyNumber = new Random().Next(0, 10), Id = Guid.NewGuid() }; var jsontask = JsonConvert.SerializeObject(task); writer.Write(jsontask); writer.Flush(); TaskCreated?.Invoke(this, new DataEventArgs <CreatedNetworkTaskData>(task)); } State = NetworkServiceState.RequestForConfirm; var remoteConfirm = TaskEx.Run(() => { var confirmationResult = reader.ReadString(); var isConfirmed = JsonConvert.DeserializeObject <ConfirmationResult>(confirmationResult); return(isConfirmed); }); var localConfirm = _completationConfirm.Task.ContinueWith(t => { var cjs = JsonConvert.SerializeObject(t.Result); writer.Write(cjs); writer.Flush(); return(t.Result); }, TaskContinuationOptions.NotOnFaulted | TaskContinuationOptions.NotOnCanceled); var bothConfirmation = await TaskEx.WhenAll(remoteConfirm, localConfirm); bool isBothConfimed = bothConfirmation.All(x => x.Result); if (isBothConfimed) { TaskStarted?.Invoke(this, new DataEventArgs <CreatedNetworkTaskData>()); } connection.Close(); } } catch (TaskCanceledException) { } catch (Exception ex) { SimpleLogger.Log(ex); } }
internal virtual void ProcessTask(ScheduledTask scheduledTask) { if (scheduledTask.IsQueued && !scheduledTask.AllowMultipleInstance) { GlobalConfiguration.Logger.Warn("scheduled task {0} is in queue and not allow multiple instance", scheduledTask.Name); return; } if (!scheduledTask.AllowMultipleInstance) { if (TasksHost.IsRunning(scheduledTask.Name)) { GlobalConfiguration.Logger.Warn("scheduled task {0} is already running and not allow multiple instance", scheduledTask.Name); return; } } var id = Guid.NewGuid(); scheduledTask.IsQueued = true; TasksHost.Enqueue( id , scheduledTask.Name , scheduledTask.TaskType , scheduledTask.Parameters , (dic) => { GlobalConfiguration.Logger.Info("scheduled task {0} completed", scheduledTask.Name); scheduledTask.IsQueued = false; try { if (scheduledTask.Completed != null) { scheduledTask.Completed(dic); } } catch (Exception ex) { GlobalConfiguration.Logger.Error(ex); } finally { scheduledTask.IsForced = false; if (scheduledTask.NextRunningDateFactory != null) { try { scheduledTask.NextRunningDate = scheduledTask.NextRunningDateFactory.Invoke(); } catch (Exception ex) { GlobalConfiguration.Logger.Error(ex); } } } } , (ex) => { scheduledTask.Exception = ex; GlobalConfiguration.Logger.Error(ex); if (TaskFailed != null) { try { TaskFailed.Invoke(scheduledTask.Name, ex); } catch { } } }, null, () => { GlobalConfiguration.Logger.Info("scheduled task {0} started", scheduledTask.Name); scheduledTask.StartedCount += 1; if (TaskStarted != null) { try { TaskStarted.Invoke(scheduledTask.Name); } catch { } } }, true, scheduledTask.IsForced); }
/// <summary> /// Called to notify task controller that a task has started. /// </summary> /// <param name="taskStarted"> /// The <see cref="TaskStarted"/> notification message. /// </param> void OnTaskStarted(TaskStarted taskStarted) { if (taskStarted == null) throw new ArgumentNullException("taskStarted"); Log.Information( "{ActorPath}: Task started by task-runner '{TaskRunnerName}': {What} ({TotalTaskCount} tasks now active)", Self.Path.ToUserRelativePath(), taskStarted.ByWho, taskStarted.What, _outstandingTaskCount ); }
private void Apply(TaskStarted e) { lastStartTime = e.StartTime; }
private void RaiseTaskStarted(IBackgroundTask task, object state) => TaskStarted?.Invoke(task, state);
// ReSharper disable once UnusedMember.Local private void OnTaskStarted(TaskStartedEventArgs e) { TaskStarted?.Invoke(this, e); }
private void TaskRunner_TaskStarted(object sender, EventArgs e) { TaskStarted?.Invoke(sender, e); }