/// <summary>
/// Остановить.
/// </summary>
public void Stop()
{
lock (_syncObject)
{
State = TaskStates.Stopping;
_syncObject.Pulse();
}
}
public ProgressUpdateEventArgs(string taskId, string filepath,
int percentage, TaskStates state, DateTime[] timestamps = null)
{
TaskId = taskId;
Filepath = filepath;
Percentage = percentage;
State = state;
Timestamps = timestamps;
}
private static void ApplyStatusFilter(NameValueCollection query, TaskStates statusFilter)
{
var statesToCheck = new[] { TaskStates.Queued, TaskStates.Running, TaskStates.Complete, TaskStates.Error, TaskStates.Cancelled, TaskStates.Killed, TaskStates.Timeout };
foreach (TaskStates state in statesToCheck.Where(x => statusFilter.HasFlag(x)))
{
query.Add(Convert.ToString(state).ToLower(), "1");
}
}
/// <exception cref="ArgumentOutOfRangeException">The queue identifier should be great than 0.</exception>
protected TaskStateModel(Int64 queueId)
{
if (queueId <= 0)
{
throw new ArgumentOutOfRangeException("queueId", "The queue identifier should be great than 0.");
}
Id = 0;
QueueId = queueId;
ServerId = 0;
TaskState = TaskStates.New;
}
/// <summary>
/// Обработать ошибку.
/// </summary>
/// <param name="error">Ошибка.</param>
protected void HandleError(Exception error)
{
this.AddErrorLog(error);
if (Settings.MaxErrorCount == 0 || ++_currentErrorCount < Settings.MaxErrorCount)
{
return;
}
this.AddErrorLog(LocalizedStrings.Str2193);
State = TaskStates.Stopping;
}
private void handleStatusChanged(LogEntry entry)
{
TaskStates state = (TaskStates)int.Parse(entry.props[1]);
foreach (ListViewItem item in lsvTasks.Items)
{
if (item.SubItems[0].Text == entry.props[0])
{
item.SubItems[3].Text = state.ToString();
ganttChart.changeState(uint.Parse(entry.props[0]), state, state == TaskStates.RUNNING);
break;
}
}
}
public void changeState(uint index, TaskStates state, bool nextTick)
{
if (tasks[index].spans.Count == 0 || state != (tasks[index].spans.Last().type))
{
tasks[index].spans.Add(new GanttSpan()
{
type = state, start = sliceCount
});
}
if (nextTick)
{
sliceCount++;
}
chart.Invalidate();
}
public void Save(ITaskState state)
{
if (state.ID == 0)
{
if (states.Count > 0)
{
state.ID = TaskStates.Max(s => s.ID) + 1;
}
else
{
state.ID = 1;
}
states.Add(state);
}
}
/// <summary>
/// Set task's state.
/// </summary>
/// <param name="id">The task's identifier.</param>
/// <param name="taskState">New task's state that we are going to set.</param>
public void SetTaskState(Int64 id, TaskStates taskState)
{
//TODO: if [id] == null then task should be mark as cancelled.
const string updateStatement = "UPDATE {0}.{1} SET [State]={2}, [CompletedAt]='{3}' WHERE [Id] = {4}";
string sqlCommand = string.Format(updateStatement, sqlSettings.WiseQueueDefaultSchema, taskTableName, (short)taskState, DateTime.UtcNow.ToString("s"), id);
using (IDbConnection connection = connectionFactory.CreateConnection())
{
using (IDbCommand command = connectionFactory.CreateCommand(connection))
{
command.CommandText = sqlCommand;
command.ExecuteNonQuery();
}
}
}
public TaskState Add(TaskState newParam)
{
using (var scope = _serviceProvider.CreateScope())
{
var _ctx = scope.ServiceProvider.GetService(typeof(SQLHoshinCoreContext)) as SQLHoshinCoreContext;
var taskState = new TaskStates();
taskState.Active = newParam.Active;
taskState.Code = newParam.Code;
taskState.Color = newParam.Color;
taskState.Name = newParam.Name;
_ctx.TaskStates.Add(taskState);
_ctx.SaveChanges();
newParam.TaskStateID = taskState.TaskStateID;
return(newParam);
}
}
public void Delete(ITaskState state)
{
ITaskState newState = TaskStates.FirstOrDefault(s => s.Flag == TaskStateFlag.Initial);
foreach (ITask task in Tasks.Where(t => t.State == state).ToArray())
{
if (newState != null)
{
task.State = newState;
}
else
{
tasks.Remove(task);
}
}
states.Remove(state);
}
public void SetNewState(TaskStates newState)
{
switch (newState)
{
case TaskStates.New:
break;
case TaskStates.Committed:
break;
case TaskStates.InProgress:
break;
case TaskStates.Done:
break;
default:
break;
}
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="queueId">The queue's identifier where the task will be put.</param>
/// <param name="activationData">Task's activation data.</param>
/// <param name="scheduleInformation"></param>
/// <exception cref="ArgumentOutOfRangeException">The queue identifier should be greate than 0.</exception>
/// <exception cref="ArgumentNullException"><paramref name="activationData"/> is <see langword="null" />.</exception>
/// <remarks>This constructor should be used only for new tasks entities.</remarks>
public TaskModel(long queueId, ActivationData activationData, ScheduleInformation scheduleInformation)
{
if (queueId <= 0)
{
throw new ArgumentOutOfRangeException("queueId", "The queue identifier should be greate than 0.");
}
if (activationData == null)
{
throw new ArgumentNullException("activationData");
}
if (scheduleInformation == null)
{
throw new ArgumentNullException(nameof(scheduleInformation));
}
this.queueId = queueId;
ActivationData = activationData;
ScheduleInformation = scheduleInformation;
taskState = TaskStates.New;
}
public void SetTaskStates(IEnumerable <ITaskState> taskStates)
{
if (TaskStates == null)
{
TaskStates = new ObservableCollection <ITaskState>();
}
if (CheckableTaskStates == null)
{
CheckableTaskStates = new ObservableCollection <Checkable <ITaskState> >();
}
if (taskStates != null)
{
TaskStates.Clear();
TaskStates.AddRange(taskStates);
CheckableTaskStates.AddRange(Checkable.Create(taskStates, true));
}
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="taskId">Task's identifier.</param>
/// <param name="queueId">The queue's identifier where the task will be put.</param>
/// <param name="serverId">The server's identifier that is used for processing the task.</param>
/// <param name="taskState">Task's state.</param>
/// <exception cref="ArgumentOutOfRangeException">The task identifier should be great than 0.</exception>
/// <exception cref="ArgumentOutOfRangeException">The queue identifier should be great than 0.</exception>
/// <exception cref="ArgumentOutOfRangeException">The server identifier should be great than 0.</exception>
public TaskStateModel(Int64 taskId, Int64 queueId, Int64 serverId, TaskStates taskState)
{
if (taskId <= 0)
{
throw new ArgumentOutOfRangeException("taskId", "The task identifier should be great than 0.");
}
if (queueId <= 0)
{
throw new ArgumentOutOfRangeException("queueId", "The queue identifier should be great than 0.");
}
if (serverId <= 0)
{
throw new ArgumentOutOfRangeException("serverId", "The server identifier should be great than 0.");
}
Id = taskId;
QueueId = queueId;
ServerId = serverId;
TaskState = taskState;
}
private static String FormatMessage(TaskStates current, params TaskStates[] expected)
{
Contracts.Require.AtLeastOneParam<TaskStates>("expected", expected);
String sexp = expected[0].ToString();
for (int i = 0; i < expected.Length; ++i)
{
if (i == expected.Length - 1)
sexp += "or " + expected[i].ToString();
else
sexp += ", " + expected[i].ToString();
}
return String.Format(Properties.Resources.Error_TaskStateInvalidExpect, sexp, current);
}
/// <summary>
/// Вызвать событие <see cref="Started"/>.
/// </summary>
protected void RaiseStarted()
{
State = TaskStates.Started;
Started.SafeInvoke(this);
}
public ActionResult List(TaskStates state)
{
var workers = Scheduler.LoadWorkers().Where(w => w.State.Equals(state));
ViewBag.TaskState = state;
return PartialView(workers);
}
/// <summary>
/// Запустить.
/// </summary>
public void Start()
{
if (State != TaskStates.Stopped)
{
return;
}
_currentErrorCount = 0;
ThreadingHelper.Thread(() =>
{
try
{
WaitIfNecessary(TimeSpan.Zero);
State = TaskStates.Starting;
OnStarting();
var attempts = 60;
while (State == TaskStates.Starting && attempts-- > 0)
{
WaitIfNecessary(TimeSpan.FromSeconds(1));
}
if (State == TaskStates.Starting)
{
this.AddErrorLog(LocalizedStrings.Str2191);
}
while (State == TaskStates.Started)
{
try
{
var interval = OnProcess();
if (interval == TimeSpan.MaxValue)
{
Stop();
break;
}
// сбрасываем счетчик при успешной итерации
_currentErrorCount = 0;
WaitIfNecessary(interval);
}
catch (Exception ex)
{
HandleError(ex);
WaitIfNecessary(TimeSpan.FromSeconds(5));
}
}
}
catch (Exception ex)
{
this.AddErrorLog(ex);
this.AddErrorLog(LocalizedStrings.Str2192);
}
finally
{
try
{
OnStopped();
}
catch (Exception ex)
{
this.AddErrorLog(ex);
}
Stopped.SafeInvoke(this);
State = TaskStates.Stopped;
}
})
.Name("{0} Task thread".Put(Name))
.Launch();
}
/// <summary>
/// Enables retry policy to process.
/// </summary>
/// <param name="cancellationToken">The optional cancellation token.</param>
/// <returns>The processing retry result.</returns>
public async Task <RetryResult> ProcessAsync(CancellationToken cancellationToken = default)
{
State = TaskStates.Initializing;
var result = new RetryResult();
var retry = RetryPolicy?.CreateInstance() ?? new InternalRetryInstance();
State = TaskStates.Working;
while (true)
{
try
{
cancellationToken.ThrowIfCancellationRequested();
}
catch (OperationCanceledException)
{
State = TaskStates.Canceled;
throw;
}
catch (ObjectDisposedException)
{
State = TaskStates.Canceled;
throw;
}
try
{
await OnProcessAsync(cancellationToken);
Processing?.Invoke(this, new RetryEventArgs(retry.ProcessTime));
State = TaskStates.Done;
result.Success();
return(result);
}
catch (Exception ex)
{
State = TaskStates.WaitingToRetry;
result.Fail(ex);
try
{
ex = ExceptionHandler.GetException(ex);
}
catch (Exception)
{
State = TaskStates.Faulted;
throw;
}
if (ex != null)
{
State = TaskStates.Faulted;
throw ex;
}
}
var span = retry.Next();
if (!span.HasValue)
{
State = TaskStates.Faulted;
result.End();
return(result);
}
await Task.Delay(span.Value, cancellationToken);
State = TaskStates.Retrying;
}
}
/// <summary>
/// Get next execution time.
/// </summary>
/// <param name="currentExecutionTime">The date and time when this task has been executed.</param>
/// <param name="taskState">Current task state</param>
/// <returns>The datetime when task should be executed.</returns>
public DateTime GetNextExecutionTime(DateTime currentExecutionTime, TaskStates taskState)
{
return(executeAt);
}
/// <summary> /// Gets a value indicating whether the task is end. /// </summary> /// <param name="state">The task state.</param> /// <returns>true if the task is end; otherwise, false.</returns> public static bool IsEnd(TaskStates state) => state == TaskStates.Done || state == TaskStates.Canceled || state == TaskStates.RolledBack || state == TaskStates.Faulted;
private static void ApplyStatusFilter(NameValueCollection query, TaskStates statusFilter)
{
var statesToCheck = new[] {TaskStates.Queued, TaskStates.Running, TaskStates.Complete, TaskStates.Error, TaskStates.Cancelled, TaskStates.Killed, TaskStates.Timeout};
foreach (TaskStates state in statesToCheck.Where(x => statusFilter.HasFlag(x)))
{
query.Add(Convert.ToString(state).ToLower(), "1");
}
}
public void StartTask(int arg)
{
id = arg;
InitDefault(id);
state = TaskStates.NEW;
clearPlayerPrefs();
}
/// <summary>
/// Read properties from specified url.
/// </summary>
/// <param name="url"></param>
public void Read(string url)
{
var xmlDoc = XDocument.Load(url);
var ns = xmlDoc.Root.GetDefaultNamespace();
DateTime startAt = DateTime.MinValue;
DateTime nextStart = DateTime.MinValue;
var root = xmlDoc.Root;
CommandData = new Dictionary<string, object>();
DateTime.TryParse(root.Element(ns + "startAt").Value, out startAt);
DateTime.TryParse(root.Element(ns + "nextStart").Value, out nextStart);
var fstr = root.Element(ns + "recurs").StrAttr("frequency");
if (string.IsNullOrEmpty(this.Name))
this.Name= System.IO.Path.GetFileNameWithoutExtension(url);
this.Frequency = !string.IsNullOrEmpty(fstr) ? (Frequencies)Enum.Parse(typeof(Frequencies), fstr) : Frequencies.Minutely;
this.JobType = Type.GetType(root.Element(ns + "command").StrAttr("type"));
this.Recurs = root.Element(ns + "recurs").IntAttr("value");
if (root.Element(ns + "title") != null)
this.Title = root.Element(ns + "title").Value;
if (root.Element(ns + "desc") != null)
this.Description = root.Element(ns + "desc").Value;
if (root.Element(ns + "state") != null)
{
var stateStr = root.Element(ns + "state").Value;
if (!string.IsNullOrEmpty(stateStr))
{
this.State = (TaskStates)Enum.Parse(typeof(TaskStates), stateStr);
}
}
var recurringDaysOfWeek = root.Element(ns + "recurs").StrAttr("daysOfWeek");
var recurringDaysOfMonth = root.Element(ns + "recurs").StrAttr("daysOfMonth");
var recurringMonths = root.Element(ns + "recurs").StrAttr("months");
if (!string.IsNullOrEmpty(recurringDaysOfWeek))
this.RecurringDaysOfWeek = recurringDaysOfWeek.Split(',').Select(a => Convert.ToInt32(a)).ToArray();
if (!string.IsNullOrEmpty(recurringDaysOfMonth))
this.RecurringDaysOfWeek = recurringDaysOfMonth.Split(',').Select(a => Convert.ToInt32(a)).ToArray();
if (!string.IsNullOrEmpty(recurringMonths))
this.RecurringMonths = recurringMonths.Split(',').Select(a => Convert.ToInt32(a)).ToArray();
foreach (var param in root.Element(ns + "command").Elements())
CommandData.Add(param.StrAttr("name"), param.Value);
this.StartAt = startAt;
this.NextStart = nextStart;
this.File = url;
}
public void CheckTasks()
{
if(tasksBuffer != null) {
tasksBuffer.Clear();
} else {
tasksBuffer = new ArrayList();
}
state = TaskStates.IN_PROCESS;
if(activeTasks != null) {
int activeTasksCount = 0;
foreach(Task task in activeTasks) {
if(!task.Check(fishesInfo)) {
tasksBuffer.Add(task.getTitle(fishesInfo));
activeTasksCount++;
}
}
if(activeTasksCount <= 0) {
state = TaskStates.COMPLETE;
}
} else {
state = TaskStates.NONE;
}
}
/// <summary>
/// Put the work item to work.
/// </summary>
public void Run()
{
this.State = TaskStates.Running;
if (job == null)
job = GetJob();
try
{
job.Execute();
this.LastRunTime = DateTime.Now;
}
catch (Exception e)
{
this.State = TaskStates.Stop;
//Fail and retry ? Should we need to handle the retry ?
job.OnError(e);
Logger.Error(e);
}
//Counter++;
if (Frequency == Frequencies.OneTime)
this.State = TaskStates.Completed;
else
{
StartAt = NextStart;
this.State = TaskStates.Ready;
NextStart = GetNextStart(StartAt);
}
this.Save();
}
/// <summary> /// Gets a value indicating whether the task is not finished. /// </summary> /// <param name="state">The task state.</param> /// <returns>true if the task is not finished; otherwise, false.</returns> public static bool IsPendingOrWorking(TaskStates state) => !IsEnd(state);
public TaskStateInvalidException(TaskStates current, params TaskStates[] expected)
: base(TaskStateInvalidException.FormatMessage(current, expected))
{
}
private void ErrorHandle(TaskStates state, Exception ex)
{
State = state;
exception = ex;
Finished?.Invoke(this, new ResultEventArgs <T>(ex, state));
}
/// <summary>
/// Get available task from the storage.
/// </summary>
/// <param name="specification">The <see cref="TaskRequestSpecification"/> instance.</param>
/// <param name="taskModels">List of <see cref="WiseQueue.Core.Common.Models.Tasks.TaskStateModel"/> instances if it has been found</param>
/// <returns>True if the list of TaskModel instances has been populated. Otherwise, false.</returns>
public bool TryGetAvailableTask(TaskRequestSpecification specification, out List <TaskModel> taskModels)
{
if (specification == null)
{
throw new ArgumentNullException("specification");
}
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.Append("Declare @TempTable table ([Id] [bigint], ");
stringBuilder.Append("[QueueId] [bigint], ");
stringBuilder.Append("[ServerId] [bigint] NULL, ");
stringBuilder.Append("[State] [smallint], ");
stringBuilder.Append("[CompletedAt] [datetime] NULL, ");
stringBuilder.Append("[ExecuteAt] [datetime] NOT NULL, ");
stringBuilder.Append("[RepeatCrashCount] [int] NOT NULL, ");
stringBuilder.Append("[InstanceType] [nvarchar](4000), ");
stringBuilder.Append("[Method] [nvarchar](4000), ");
stringBuilder.Append("[ParametersTypes] [nvarchar](4000), ");
stringBuilder.AppendLine("[Arguments] [nvarchar](4000)); ");
stringBuilder.AppendFormat("UPDATE TOP ({0}) {1}.{2} ", specification.MaxTasks, sqlSettings.WiseQueueDefaultSchema, taskTableName);
stringBuilder.AppendFormat("SET State = {0}, ", (short)TaskStates.Pending);
stringBuilder.AppendFormat("ServerId = {0} ", specification.ServerId);
//stringBuilder.Append("RepeatCount = RepeatCount - 1 ");
stringBuilder.Append("OUTPUT inserted.* INTO @TempTable ");
stringBuilder.AppendFormat("Where (State = {0} ", (short)TaskStates.New);
stringBuilder.AppendFormat("OR ( (State = {0} OR State = {1}) AND [ServerId] IS NULL)) ", (short)TaskStates.Pending, (short)TaskStates.Running);
stringBuilder.AppendFormat("AND (QueueId = {0}) AND ([ExecuteAt] <= GETUTCDATE()) AND [RepeatCrashCount] > 0;", specification.QueueId);
stringBuilder.AppendLine();
stringBuilder.AppendLine("SELECT * FROM @TempTable");
using (IDbConnection connection = connectionFactory.CreateConnection())
{
using (IDbTransaction transaction = connection.BeginTransaction(IsolationLevel.Serializable))
{
using (IDbCommand command = connectionFactory.CreateCommand(connection, transaction))
{
command.CommandText = stringBuilder.ToString();
using (IDataReader rdr = command.ExecuteReader())
{
taskModels = new List <TaskModel>();
while (rdr.Read())
{
Int64 id = (Int64)rdr["Id"];
Int64 queueId = (Int64)rdr["QueueId"];
Int64 serverId = (Int64)rdr["ServerId"];
TaskStates taskState = (TaskStates)(short)rdr["State"];
int repeatCrashCount = (int)rdr["RepeatCrashCount"];
string typeDetails = (string)rdr["InstanceType"];
string methodDetails = (string)rdr["Method"];
string parameterDetails = (string)rdr["ParametersTypes"];
string argumentDetails = (string)rdr["Arguments"];
TaskEntity taskEntity = new TaskEntity
{
Id = id,
QueueId = queueId,
ServerId = serverId,
TaskState = taskState,
InstanceType = typeDetails,
Method = methodDetails,
ParametersTypes = parameterDetails,
Arguments = argumentDetails,
RepeatCrashCount = repeatCrashCount
};
TaskModel taskModel = taskConverter.Convert(taskEntity);
taskModels.Add(taskModel);
}
}
}
if (taskModels.Count > 0)
{
transaction.Commit();
return(true);
}
}
return(false);
}
}
/// <summary> /// Gets a value indicating whether the task is pending to process. /// </summary> /// <param name="state">The task state.</param> /// <returns>true if the task is pending to process; otherwise, false.</returns> public static bool IsPending(TaskStates state) => state == TaskStates.Pending;
private void updateDisplay(byte[] s)
{
LogEntry entry = new LogEntry();
entry.msg = (LogMsg)s[0];
if (entry.msg == LogMsg.LOG_START)
{
phils = new List <Philosopher>();
}
else
{
if (phils == null)
{
return;
}
Philosopher p;
entry.props = Encoding.ASCII.GetString(s, 5, s.Length - 5).Split(';');
switch (entry.msg)
{
case LogMsg.LOG_NEW_TASK:
p = new Philosopher();
p.tid = uint.Parse(entry.props[0]);
if (p.tid == 0)
{
return;
}
p.name = entry.props[1];
phils.Add(p);
break;
case LogMsg.LOG_TASK_STATUS_CHANGE:
TaskStates state = (TaskStates)int.Parse(entry.props[1]);
uint tid = uint.Parse(entry.props[0]);
if (tid == 0)
{
return;
}
p = (from temp in phils where temp.tid == tid select temp).First();
switch (state)
{
case TaskStates.READY:
p.state = PhilStates.EATING;
break;
case TaskStates.SUSPENDED:
p.state = PhilStates.WAITING;
break;
case TaskStates.SLEEPING:
p.state = PhilStates.THINKING;
break;
case TaskStates.RUNNING:
p.state = PhilStates.EATING;
break;
}
break;
}
Refresh();
}
}
/// <summary> /// Gets a value indicating whether the task is processing. /// </summary> /// <param name="state">The task state.</param> /// <returns>true if the task is processing; otherwise, false.</returns> public static bool IsWorking(TaskStates state) => state == TaskStates.Working || state == TaskStates.WaitingToRetry || state == TaskStates.Retrying;
/// <summary> /// Gets a value indicating whether the task is pending to process. /// </summary> /// <param name="state">The task state.</param> /// <returns>true if the task is pending to process; otherwise, false.</returns> public static bool IsWaiting(TaskStates state) => state == TaskStates.Pending || state == TaskStates.Initializing || state == TaskStates.WaitingToRetry || state == TaskStates.Pausing || state == TaskStates.Paused || state == TaskStates.Resuming;
/// <summary>
/// Performs a state transition on the task.
/// </summary>
/// <param name="state">The task's new state.</param>
/// <exception cref="TaskStateInvalidException">
/// thrown if the task is in a state that makes the state transition
/// invalid.</exception>
protected void SetTaskState(TaskStates state)
{
switch (state)
{
case TaskStates.Pending:
AssertState(TaskStates.Idle);
break;
case TaskStates.PendingScheduled:
AssertState(TaskStates.Idle);
break;
case TaskStates.PendingCancel:
case TaskStates.Executing:
AssertState(TaskStates.Pending, TaskStates.PendingScheduled);
break;
case TaskStates.Yielding:
case TaskStates.Completed:
case TaskStates.CompletedSuccess:
AssertState(TaskStates.Executing);
break;
case TaskStates.CompletedWithError:
AssertState(TaskStates.PendingScheduled, TaskStates.Yielding, TaskStates.Executing);
break;
case TaskStates.CompletedCanceled:
AssertState(TaskStates.PendingCancel);
break;
case TaskStates.Idle:
default:
throw new ArgumentOutOfRangeException();
}
_taskState.SetState(state);
}
public Tasks(int arg_id, GameObject arg_go)
{
id = arg_id;
if(arg_go != null) {
tasksText = (GUIText)arg_go.GetComponent(typeof(GUIText));
}
InitTasks();
InitDefault(id);
state = TaskStates.NONE;
}
/// <summary> /// Gets a value indicating whether the task is cancelled. /// </summary> /// <param name="state">The task state.</param> /// <returns>true if the task is cancelled; otherwise, false.</returns> public static bool IsCanceled(TaskStates state) => state == TaskStates.Canceled;
public void setStarted()
{
state = TaskStates.IN_PROCESS;
}
/// <summary> /// Gets a value indicating whether the task is done. /// </summary> /// <param name="state">The task state.</param> /// <returns>true if the task is done; otherwise, false.</returns> public static bool IsDone(TaskStates state) => state == TaskStates.Done;
public TaskStates Update(float arg)
{
string result = "";
if(activeTasks != null && tasksText != null) {
timer += arg;
result += "Time : " + (int)(taskTime - timer) + "\n";
foreach(string task in tasksBuffer) {
result += task + "\n";
}
tasksText.text = result;
}
if(timer > taskTime) {
state = TaskStates.FAIL;
}
return state;
}
/// <summary> /// Gets a value indicating whether the task is failed. /// </summary> /// <param name="state">The task state.</param> /// <returns>true if the task is failed; otherwise, false.</returns> public static bool IsFailed(TaskStates state) => state == TaskStates.Faulted;
