Stopping a process using CancellationToken

Question

I am trying to enable a Kill option for a case that runs asynchronously from the calling thread, as a Process. My example looks like @svick's answer here. I am trying to implement the recommendation by @svick in this post. But when I click on Kill in the UI, it appears to do nothing (i.e., the process simply runs to completion as usual).

As per @TimCopenhaver's response, this is expected. But if I commented that out, it still doesn't do anything, this time because the CancellationTokenSource object cts is null, which is unexpected since I instantiate it in the Dispatch method of the CaseDispatcher class before trying to kill it. Here is my code snippet:

UI class:

private void OnKillCase(object sender, EventArgs args)
{
    foreach (var case in Cases)
    {
        Args caseArgs = CaseAPI.GetCaseArguments(case);
        CaseDispatcher dispatcher = CaseAPI.GetCaseDispatcher(case);
        dispatcher.Kill();
        CaseAPI.Dispose(caseArgs); 
    }
}

CaseDispatcher class:

    private Task<bool> task;
    private CancellationTokenSource cts;
    public override bool IsRunning
    {
        get { return task != null && task.Status == TaskStatus.Running; }
    }
    public override void Kill()
    {
        //if (!IsRunning)
        //{
        //    return;
        //}
        if (cts != null)
        {
            cts.Cancel();
        }
    }
    public override async Task<bool> Dispatch()
    {
        cts = new CancellationTokenSource();
        task = CaseAPI.Dispatch(Arguments, cts.Token);
        return await task;
    }

CaseAPI class:

public static async Task<bool> Dispatch(CaseArgs args, CancellationToken ctoken)
{
    bool ok = true;
    BatchEngine engine = new BatchEngine()
        {
            Spec = somespec,
            CaseName = args.CaseName,
            CaseDirectory = args.CaseDirectory
        };
    ok &= await engine.ExecuteAsync(ctoken);
    return ok;
}

BatchEngine class (here is where I invoke the CancellationToken Register method, but not sure exactly where to position it, assuming it matters):

public virtual Task<bool> ExecuteAsync(CancellationToken ctoken)
{
    var tcs = new TaskCompletionSource<bool>();
    string exe = Spec.GetExecutablePath();
    string args = string.Format("--input={0} {1}", Input, ConfigFile);

    try
    {
        var process = new Process
        {
            EnableRaisingEvents = true,
            StartInfo =
            {
                UseShellExecute = false,
                FileName = exe,
                Arguments = args,
                CreateNoWindow = true,
                RedirectStandardOutput = true,
                RedirectStandardError = true,
                WorkingDirectory = CaseDirectory
            }
        };
        ctoken.Register(() =>
            { 
                process.Kill();
                process.Dispose();
                tcs.SetResult(false);
            });
        process.Exited += (sender, arguments) =>
        {
            if (process.ExitCode != 0)
            {
                string errorMessage = process.StandardError.ReadToEnd();
                tcs.SetResult(false);
                tcs.SetException(new InvalidOperationException("The batch process did not exit correctly. Error message: " + errorMessage));
            }
            else
            {
                File.WriteAllText(LogFile, process.StandardOutput.ReadToEnd());
                tcs.SetResult(true);
            }
            process.Dispose();
        };
        process.Start();
    }
    catch (Exception e)
    {
        Logger.InfoOutputWindow(e.Message);
        tcs.SetResult(false);
        return tcs.Task;
    }
    return tcs.Task;
}

Thanks for your interest and appreciate any ideas on this.

Answer 1

I believe the IsRunning property is the problem. Because the TaskCompletionSource doesn't really know you started the external process, it is stuck in the WaitingForActivation state. Here's a simplified example to demonstrate:

var tsc = new TaskCompletionSource<int>();

Task.Factory.StartNew(() =>
{
    Thread.Sleep(10000);
    tsc.SetResult(10);
});

var tmp = tsc.Task;

TaskStatus status = tmp.Status;
while (status != TaskStatus.RanToCompletion)
{
    status = tmp.Status;
    Thread.Sleep(1000);
    Console.WriteLine(status);
}

Notice it will keep saying WaitingForActivation up until it switches to RanToCompletion. See this answer for more discussion on this. In short, if the task is created by a TaskCompletionSource, it will never enter the running state. You will have to manage the IsRunning property yourself.