Stop the long-term task safely

My question is how can I stop a long running task (.net 4)? I have implemented TPL and tried using the CancellationTokenSource but it doesn’t seem to work for my scenario. All examples I’ve seen assume you’re doing work in a while-loop so that you can check if the task has been cancelled, whereas I just have a single operation that takes long. I cannot wait for the work to be completed as I need to assume it might never complete. Here is the code I have tried:

bool? result = null;

        var cs = new CancellationTokenSource();
        var ct = cs.Token;

        var doWorkTask = new Task(() =>
        {
            Console.WriteLine("start dowork task");

            result = Work.LongRunning();
         }, ct);

        doWorkTask.Start();

        Task.WaitAny(new Task[] { doWorkTask }, timetowait);

        if (doWorkTask.IsCompleted)
        {
        Console.WriteLine("dowork task completed");

            doWorkTask.Dispose();
        }
        else
        {
        Console.WriteLine("dowork task has timedout");

            cs.Cancel();

            throw new TimeoutException("Timeout hit.");
        }

The code works but the task is never disposed if the “timeout” happens and the work that is being done accesses “unmanaged code” i.e. resources. That said the IsCancelledRequested cannot be used in Work.LongRunning() so I cannot ThrowIfCancellationRequested.

I am open to other ideas as well as I have tried BackgroundWorker but that also doesn’t seem to fit.

New example:

var service = new System.ServiceProcess.ServiceController(ServiceName, ServerName);

        var serviceTask = Task.Factory.StartNew(() =>
        {
            result = (service.Status == ServiceControllerStatus.Running
                 || service.Status == ServiceControllerStatus.StartPending);
        }, cs.Token);

        serviceTask.Wait(2000, cs.Token);

        if (!serviceTask.IsCompleted)
        {
            cs.Cancel();
        }

Task Parallel Library is designed for CPU intensive work. CPU intensive work is done in a while look. If your Work.LongRunning() is CPU intensive you should be able to pass the cancellation token inside and cancel it. If it is not CPU intensive then you can simply discard the result in an eventual callback and not bother with stopping the actual work since it is just waiting.

BTW if you have waiting (for database call or something) you probably have asynchronous methods somewhere at the bottom. You can surface the Begin/End pattern and wrap it in a Task. This question explains how: TPL TaskFactory.FromAsync vs Tasks with blocking methods This way you will avoid hogging a general purpose thread since IO waiting is done in a special way handled by the OS.