Pausing a task within Task.Factory.StartNew

Question

In my Asp.Net MVC 5 project I have a ~3 minute task that I pass to Task.Factory.StartNew().

I would like to pause the task from within the task if there is a validation issue in one of the steps of my code running in the task. I don't want to delay it async because the rest of the task will continue to run, which can't happen.

Could I use thread.sleep() without any repercussions since I'm within a task? I read that I may have to use TaskScheduler.Default to have the Task.Factory create a new thread for each task.

I'm using a PauseToken similar to a CancellationToken so I'll be able to resume the task or cancel this task based on user input.

Multithreading really scares me, and I don't want to overlook something.

Here is an example of the Thread.Sleep implementation:

public void WaitIfPaused(PauseToken pauseToken, CancellationToken cancellationToken, IProgressBar progressBar)
    {
        //TODO: If paused for an hour notify user via noty and abort the task to keep it from completing by cancellation via cancellationToken.
        //wait for 1 hour
        for (int i = 0; i < 3600; i++)
        {
            ThrowExceptionIfCancelled(cancellationToken, progressBar);
            if (pauseToken.IsPaused)
            {
                Thread.Sleep(1000);
            }
            else
            {
                break;
            }

        }
    }

PauseToken: http://blogs.msdn.com/b/pfxteam/archive/2013/01/13/cooperatively-pausing-async-methods.aspx

---

Requested: Implementation of task structure in shared code library.

public void StartTask(params object[] data)
    {
        //throw an exception if no ITask was found
        if (_taskToRun == null)
            throw new Exception("Task cannot be null");

        //set up task cancellation
        CancellationTokenSource = new CancellationTokenSource();
        var cancellationToken = CancellationTokenSource.Token;

        //set up task pausing
        PauseTokenSource = new PauseTokenSource();
        var pauseToken = PauseTokenSource.Token;

        //start a new task using the Task that was set
        _task = Task.Factory.StartNew(() => _taskToRun.Execute(cancellationToken, pauseToken, data), cancellationToken);
}

My Execute method that is invoked by _taskToRun.Execute:

Public override void Execute(CancellationToken cancellationToken, PauseToken pauseToken, params object[] data)
    {
        var managerList = (List<IFileManager>) data[0];
        var instr = (List<InstructionSet>) data[1];

        ProcessInstructions(managerList, instr, cancellationToken, pauseToken);
    }

---

Update due to comments:

Code example: 3 instructions

For(var instruction in instructions)
{
    instruction.Execute();
}

In my execute method I run into a scenario for pause and call WaitWhilePausedAsync from within the execute. It will continue to execute the other two instructions, but pause the only the current instructions execute method.

Edit: By awaiting instruction.Execute() it will wait until instruction.Execute() completes or is unpaused.

---

Final Edit: I was able to resolve the issue by awaiting the Execute method and making it async like Servy and I3arnon suggested.

Final Code Sample:

foreach(var instruction in instructions)
{
    try 
    {
        await instruction.Execute(pauseToken);
    }
    catch(InvalidOperationException)
    {
        pauseTokenSource.IsPaused = true;
        //ask if user wants to cancel or resume.
    }
}
//Simplified
public async Task<bool> Execute(PauseToken pauseToken)
{
    await pauseToken.WaitWhilePausedAsync();
    //do work
}

Answer 1

You can safely use Thread.Sleep. The only drawback is that the thread would be wasted blocking synchronously.

You should be using await Task.Delay(1000) instead. The code after that line would not execute until the wait is complete, but you won't be wasting a thread in the meantime:

public async Task WaitIfPausedAsync(PauseToken pauseToken, CancellationToken cancellationToken, IProgressBar progressBar)
{
    for (int i = 0; i < 3600; i++)
    {
        ThrowExceptionIfCancelled(cancellationToken, progressBar);
        if (pauseToken.IsPaused)
        {
            await Task.Delay(1000)
        }
        else
        {
            break;
        }
    }
}

Edit: I was unaware of PauseToken.WaitWhilePausedAsync. You should definitly use that instead of replicating that yourself with polling over PauseToken.IsPaused