public bool Run(TimeSpan tCurrentTime, bool tManageCamera = false) { bool ret = StartTime.TotalMilliseconds <= tCurrentTime.TotalMilliseconds && tCurrentTime.TotalMilliseconds <= EndTime.TotalMilliseconds; if (ret) { if (_executionCount < 2) { _executionCount += 1; } if (_setSpeed) { CalculateCurrentSpeed(); } if (_setFloat) { CalculateCurrentFloat(); } if (tManageCamera && IsSettingCamera && !_disableUpdate) { PlaceCamera(); } OnExecute?.Invoke(this); } return(ret); }
public virtual void Schedule(ushort step) { if (Trigger(step)) { OnExecute?.Invoke(this, null); } }
public void Execute() { try { if (!Api.IsAuthorized) { Auth(); } OnExecute?.Invoke(); } catch (Exception e) { if (e is AccessTokenInvalidException) { Logger.Error("Trying to renew token..."); Auth(); OnExecute?.Invoke(); } else { Logger.Error(e); } } }
/// <summary> /// Logic to determine when to execute the actions tied to this processor. /// </summary> public bool Process(T t) { if (IsFulfilled(t)) { OnExecute?.Invoke(t); return(true); } return(false); }
public void Execute(object parameter = default) { Parameter = parameter.Cast <TParameter>(); Result = _execute.Invoke(Parameter, Result); History.Snapshot(ToSnapShot()); Result = default; OnExecute?.Invoke(Parameter); Parameter = default; }
public Specter Execute(string code, string filename, IEnumerable <string> args) { Filename = filename; Arguments = args; OnExecute?.Invoke(); engine.Execute(filename, code); return(this); }
private void ExecuteProc() { try { OnExecute?.Invoke(m_client); OnCompleted?.Invoke(m_client); } catch (Exception) { OnCompleted?.Invoke(m_client); } }
private void InnerWork() { _lock.Wait(); for (int i = 0; i < _stubCounter; i++) { Thread.Sleep(Random.Get(max: 1200)); _lock.Wait(); OnExecute?.Invoke(Id); } _lock.Wait(); Thread.Sleep(Random.Get(max: 1200)); OnComplete?.Invoke(Id); }
/// <summary> /// Starts the Task with the specified token. /// </summary> /// <param name="token">The token.</param> /// <param name="interval">The interval.</param> /// <returns></returns> private async Task Start(CancellationToken token, int interval) { while (true) { if (token.IsCancellationRequested) { break; } OnExecute?.Invoke(); await Task.Delay(interval, token); } }
public Task ExecuteAsync(QueryContext query) { if (OnExecute != null) { OnExecute.Invoke(query); return(Task.CompletedTask); } if (OnExecuteAsync != null) { return(OnExecuteAsync.Invoke(query)); } return(Task.CompletedTask); }
public void Execute(object parameter = default) { Parameters = parameter.Cast <TParameter>(); Result = this._execute(Parameters, Result).Cast <TResult>(); ICommandWithUndoRedo.AddInUndo(this.Clone() as ICommandWithUndoRedo); ICommandWithUndoRedo.StackRedo.Clear(); Result = default(TResult); Parameters = default(TParameter); OnExecute?.Invoke(); }
// TODO Kill generator if any part of execution fails? public void Execute() { List <UserMoneyTransfer> transfersToExecute; lock (_locker) { transfersToExecute = new List <UserMoneyTransfer>(_openTransfers); _openTransfers.Clear(); OnExecute?.Invoke(this, new EventArgs()); } var groups = transfersToExecute.GroupBy(transfer => new { transfer.UserId, transfer.UserAccount, transfer.Currency }).ToList(); foreach (var group in groups) { var taskData = new UserMoneyTransferTask { Amount = group.Sum(transfer => transfer.Amount), Currency = group.Key.Currency, Status = UserMoneyTransferTaskStatus.Open, UserId = group.Key.UserId, UserAccount = group.Key.UserAccount, Transfers = group.ToList() }; using (var scope = new TransactionScope()) { _dalTask.Insert(taskData); taskData.Transfers.ForEach(transfer => _dalTransfer.UpdateStatus(transfer, UserMoneyTransferStatus.Tasked)); scope.Complete(); } new Tasks.UserMoneyTransferTask(_dependencyFactory, _engine, taskData).Enqueue(); } }
internal override void OnCommand(ICommandArgs command) { OnExecute?.Invoke(command); }
public void Execute() { executed = true; orderAction.Invoke(Target); OnExecute?.Invoke(); }
public Task <ExecutionResult> ExecuteCodeAsync(string text) { OnExecute?.Invoke(this, text); return(Task.FromResult(ExecutionResult.Success)); }
public void ExecuteAction(EventArgs e) { btnExecute.Enabled = false; OnExecute?.Invoke(this, e); btnExecute.Enabled = true; }
public async Task Execute(PageAction pageAction, IEnumerable <ImageEntity> images, UserEntity user, SettingEntity settings, CancellationToken ct) { try { foreach (var image in images) { try { OnStartExecuted.Invoke(image, pageAction); image.ImageState = ImageState.InProcesses; var pageContext = new ImageContext { User = user, Settings = settings }; foreach (var page in _pages.Where(a => a.Action == pageAction).OrderBy(a => a.Order)) { if (ct.IsCancellationRequested) { break; } await page.ExecuteAsync(image, pageContext, ct); if (page.GetImageState(image) == ImageState.Failed) { _logger.LogWarning(string.Format(LogTemplate, page.Order, page.Action)); break; } _logger.LogStep(page.Action.ToString(), image.ImagePath, page.Order.ToString()); OnStateChanged.Invoke(image.ImageState, image.Id); await Task.Delay(TimeSpan.FromSeconds(2), ct); // to simulate user action } await _repository.AddOrUpdateAsync(image, ct); OnExecute.Invoke(image, pageAction); await Task.Delay(TimeSpan.FromSeconds(settings.WaitingBetweenUploadingImage), ct); } catch (TaskCanceledException) { break; } catch (Exception ex) { _logger.LogWarning(ex.Message); image.ImageState = ImageState.Failed; } } if (images.Any(entity => entity.ImageState == ImageState.Failed) && _retryCount < settings.RetryCount) { _retryCount++; await Execute(pageAction, user.Images !.Where(entity => entity.ImageState == ImageState.Failed), user, settings, ct); } } catch (Exception ex) { _logger.LogError(ex.Message); if (_retryCount > settings.RetryCount) { throw; } } }
private void ExecuteCommand(object sender, EventArgs e) { OnExecute?.Invoke(Type); }
public void Trigger(IGraphFlow flow) { OnExecute?.Invoke(); }
protected virtual void Execute() { OnExecute?.Invoke(this, null); }
public override void Execute(params string[] args) { OnExecute?.Invoke(args); }
public void Execute() { OnExecute?.Invoke(); }
public void Execute(object parameter) { OnExecute?.Invoke(this, parameter); }
public void Execute(object parameter = null) { OnExecute?.Invoke(parameter); }
public void OnCommandExecute(CommandArguments cmdArgs) { OnExecute?.Invoke(cmdArgs); }
public void Execute(TSender sender, TEventArgs eventArgs) { OnExecute?.Invoke(sender, eventArgs); }
public override void Execute(object parameter) { OnExecute?.Invoke(); Action?.Invoke((T)parameter); }
public void Execute(EventArgs args) => OnExecute?.Invoke(args);