C# TaskResult类代码示例

 public TaskState(RemoteTask task, TaskState parentState, string message = "Internal Error (xunit runner): No status reported", TaskResult result = TaskResult.Inconclusive)
 {
     Task = task;
     Message = message;
     Result = result;
     ParentState = parentState;
 }

        public RemoteTaskWrapper(RemoteTask remoteTask, IRemoteTaskServer server)
        {
            RemoteTask = remoteTask;
            this.server = server;

            result = TaskResult.Inconclusive;
        }

 private static void AssertTaskFinishedCalled(FakeRemoteTaskServer.TaskFinishedParameters taskFinishedCall,
                                              RemoteTask remoteTask, string message, TaskResult result)
 {
     Assert.Equal(remoteTask, taskFinishedCall.RemoteTask);
     Assert.Equal(message, taskFinishedCall.Message);
     Assert.Equal(result, taskFinishedCall.Result);
 }

 public void Failed(IExample example, Exception exception)
 {
     LastResult = TaskResult.Exception;
     _server.TaskOutput(CurrentTask, "Failed:", TaskOutputType.STDERR);
     _server.TaskOutput(CurrentTask, exception.ToString(), TaskOutputType.STDERR);
     _server.TaskFinished(CurrentTask, exception.ToString(), TaskResult.Exception);
 }

        /// <summary>
        /// Initializes the <see cref="TaskContext"/>
        /// </summary>
        /// <param name="associatedData"></param>
        public TaskContext(ITask task, object associatedData)
        {
            Task = task;
            Result = new TaskResult();
            AssociatedData = associatedData;

            _progress = 0;
        }

 internal static TaskResult AddDirectoyByNameToZip(Task task, TaskResult result)
 {
     var zip = (ZipFile)Get(task, 0, result);
     foreach (var value in ((List<object>)Get(task, 1, result)))
     {
         zip.AddDirectoryByName(value.ToString());
     }
     return Next(task, result);
 }

 public void EndTarget(IObsoleteTask task, string name, IBounceCommand command, TaskResult result) {
     if (logOptions.ReportTargetEnd) {
         if (result == TaskResult.Success) {
             StdOut.WriteLine("{0} target: {1}", command.PastTense, name);
         } else {
             StdErr.WriteLine("failed to {0} target: {1}", command.InfinitiveTense, name);
         }
     }
 }

 public void EndTask(IObsoleteTask task, IBounceCommand command, TaskResult result) {
     if (logOptions.ReportTaskEnd && task.IsLogged && command.IsLogged) {
         if (result == TaskResult.Success) {
             StdOut.WriteLine("{0} task: {1}", command.PastTense, task);
         } else {
             StdErr.WriteLine("failed to {0} task: {1}", command.InfinitiveTense, task);
         }
     }
 }

        public StorEvilTaskRunner(IRemoteTaskServer server)
            : base(server)
        {
            Logger.Log("StorEvilTaskRunner constructed");
            server.ClientMessage("TaskRunner starting");
            //_isDebug = server.GetConfiguration().IsInInternalDebug;

            _result = TaskResult.Success;
        }

	public void TaskCompleted()
	{
		TaskResult result = new TaskResult();
		result.gridPosition = gridPosition;
		result.completionTime = Time.time - creationTime;
		result.TimeoutTime = LifeTime;
		result.completionPercentage = repetitionNr / TotalReps;
		GameManager.Instance.TaskCompleted(result);
	}

        public void ScenarioFailed(Scenario scenario, string successPart, string failedPart, string message)
        {
            Output(successPart + " [" + failedPart + "] -- failed");
            Output("----------");
            Output(message);

            _server.TaskException(_remoteTask, new[] {new TaskException("StorEvil failure", message, ""),});
            Result = TaskResult.Exception;
        }

        public void CouldNotInterpret(Scenario scenario, string line)
        {
            Output("Could not interpret:\r\n" + line);
            var suggestion = new ImplementationHelper().Suggest(line);

            Output("You could try the following:");
            Output(suggestion);

            Result = TaskResult.Skipped;
        }

        public void TaskFinished(RemoteTask remoteTask, string message, TaskResult result, TimeSpan duration)
        {
            Debug.Assert(result != TaskResult.Inconclusive);

            clientController.TaskFinished(remoteTask);
            if (result == TaskResult.Skipped)
                server.TaskExplain(remoteTask, message);
            if (duration >= TimeSpan.Zero)
                server.TaskDuration(remoteTask, duration);
            server.TaskFinished(remoteTask, message, result);
        }

 public void SetMethodTasks(ICollection<XunitTestMethodTask> value)
 {
     if (value == null || value.Count == 0)
     {
         classResult = TaskResult.Inconclusive;
         methodTasks = new Dictionary<string, XunitTestMethodTask>();
     }
     else
     {
         methodTasks = value.ToDictionary(x => x.ShortName);
     }
 }

        public override TaskResult Execute(TaskExecutionNode node)
        {
            if (node.RemoteTask is RunScenarioTask)
            {
                var result = ExecuteScenario(node);
                if (result.Status != TaskResult.Success)
                    _result = result.Status;
                return result.Status;
            }

            return TaskResult.Success;
        }