C# RemoteTask类代码示例

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

            result = TaskResult.Inconclusive;
        }

 public static TaskMessages OfTask(this IEnumerable<TaskMessage> taskMessages, RemoteTask task)
 {
     var sameTasks = from tm in taskMessages
         where Equals(tm.Task, task) && tm.Task.Id == task.Id
         select tm;
     return new TaskMessages(task, "same", sameTasks.ToList());
 }

 public TaskMessages(RemoteTask task, string taskMatchStyle, IList<TaskMessage> taskMessages)
 {
     this.task = task;
     this.taskMatchStyle = taskMatchStyle;
     messages = taskMessages.Select(tm => tm.Message).ToList();
     serverActions = taskMessages.Select(tm => tm.ServerAction).ToList();
 }

        public void TaskStarting(RemoteTask remoteTask)
        {
            Assert.NotNull(remoteTask);

            tasks.Push(remoteTask);
            TaskStartingCalls.Add(remoteTask);
        }

 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 override bool Equals(RemoteTask other)
        {
            if (other == null) return false;

            return ReferenceEquals(this, other) ||
                Equals(other as LoadContextAssemblyTask);
        }

 public static TaskMessages OfEquivalentTask(this IEnumerable<TaskMessage> taskMessages, RemoteTask task)
 {
     var equivalentTasks = from tm in taskMessages
         where Equals(tm.Task, task)
         select tm;
     return new TaskMessages(task, "equal", equivalentTasks.ToList());
 }

        private IStorEvilJob GetJob(RemoteTask remoteTask, IScenario scenario)
        {
            InPlaceStoryRunner handler = BuildInPlaceRunner(remoteTask);
            IStoryProvider provider = new SingleScenarioStoryProvider(scenario);

            return new StorEvilJob(provider, handler);
        }

        private InPlaceStoryRunner BuildInPlaceRunner(RemoteTask remoteTask)
        {
            _listener = new ResharperResultListener(_server, remoteTask);
            IScenarioPreprocessor preprocessor = new ScenarioPreprocessor();

            return new InPlaceStoryRunner(_listener, preprocessor, new ScenarioInterpreter(new InterpreterForTypeFactory(new ExtensionMethodHandler())), new IncludeAllFilter(), _factory );
        }

        public string GetFullMethodName(RemoteTask task)
        {
            var typeName = task.GetProperty<string>("TypeName");
            var shortName = task.GetProperty<string>("ShortName");

            return string.Format("{0}.{1}", typeName, shortName);
        }

 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;
 }

        private TaskMessage(RemoteTask task, ServerAction serverAction, params object[] parameters)
        {
            Assert.NotNull(task);

            Task = task;
            ServerAction = serverAction;
            Message = ServerMessage.Format(serverAction, parameters);
        }

        public IUnitTestElement GetDynamicElement(RemoteTask remoteTask, Dictionary<RemoteTask, IUnitTestElement> tasks)
        {
            var caseTask = remoteTask as TestCaseTask;
            if (caseTask != null)
                return GetDynamicCaseElement(tasks, caseTask);

            return null;
        }

        public bool TaskStarting(RemoteTask remoteTask)
        {
            Assert.NotNull(remoteTask);

            tasks.Push(remoteTask);
            TaskStartingCalls.Add(remoteTask);

            return true;
        }

        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);
        }