C# fetching async tasks

Question

Is there a way to fetch currently running task by ID once you get out of the method where you initially started the task? I would like to get somehow current tasks so I can stop some of them mid-execution without interrupting the flow of the program.

For example:

class Test
{
    List<Task> listOfTasks = new List<Task>();


    void taskCaller()
    {
        try
        {
            var myTask = Task.Factory.StartNew(()=> testMethod());
            listOfTasks.Add(myTask);
        }
        catch (System.Exception)
        {
            //...
            throw;
        }
    }


    void taskGetter()
    {
        foreach (var item in listOfTasks)
        {
            if(item == something)
            {
                item.KillExecution();
            }
        }
    }


    private void testMethod()
    {
        // doing something
        throw new NotImplementedException();
    }
}

EDIT

I want it done without cancellation tokens if possible as it doesn't work for me as I want it to because I am running a timer fetching DLL from DB and cancellation tokens work only if I immediately kill the task with token.Cancel() however if I try token.CancelAfter() it doesn't work because it gets triggered only after the task finished with the execution, which kind of isn't the idea.

EDIT2:

Not to copy tons of code, here is the pseudo of the whole flow:

new timer(repeat method every xx time units)
    open DB
    do some work
    save DB

Continuing with plast1k suggestion...

When I check the dictionary if the cancellation is requested in this scenario, it says true but it doesn't do anything to the running task

private void getActiveTasks()
{
    if (!ListOfTasks.Any())
        return;
    Console.WriteLine("Currently running:");
    foreach (var task in ListOfTasks)
    {
        Console.WriteLine("\t" + task.Key);
        Console.WriteLine("\t" + task.Value.MyTask.Id);
        task.Value.Token.Cancel();
        Console.WriteLine("\t" + task.Value.Token.IsCancellationRequested);


        ListOfTasks.Remove(task.Key);
        return;
    }
}

Answer 1

As you might have already researched, by far the only way to cancel a task is to make it aware of the cancellation using the cancellationtoken and making it cancellation-aware. Also, that is the preferred way to do it as well.However, as your question mentions that you can't use a cancellation source you may use the technique mentioned in another SO answer (link included).

A gist from the link, You may create those tasks and run them on a different thread and abort the thread whenever you may want to cancel the task

How do I force a Task to stop?

Answer 2

Make sure you are actually handling cancellation inside your task (via cancelToken.ThrowIfCancellationRequested() ) as calling Cancel on the token source only cancels the task scheduling, it does not actually stop execution.

The proper way to stop a task would be to use cancellation tokens. See an example here

https://msdn.microsoft.com/en-us/library/dd997396(v=vs.110).aspx

and here

https://blogs.msdn.microsoft.com/andrewarnottms/2014/03/19/recommended-patterns-for-cancellationtoken/

Answer 3

While you should see usaipavan's answer and link for proper cancellation technique, in order to keep track of your threads or tasks you could simply add them to a Dictionary instead of a List and assign the ID of your choosing. It could be an integer or a string or anything, in this example its a GUID.

Dictionary<Guid, Task> listofTasks = new Dictionary<Guid, Task>();

public Guid StartTask()
{
    Task myTask = Task.Factory.StartNew(()=> testMethod());
    Guid taskID = Guid.NewGuid();
    listOfTasks.Add(taskID, myTask);
    return taskID;
}

public void CancelTask(Guid id)
{
    // listOfTasks[id].choose_your_own_task_cancellation_adventure()
}

If you could use cancellation tokens you could store those in the dictionary/another dictionary/as a tuple. If you wanted to identify groups of these tasks (i.e., cancel all of the asks for the "DB Query" operation) you could do something like this

public class TaskWrapper
{
    public TaskWrapper(string operationID, Task task, CancellationTokenSource cancellationSource)
    {
        this.OperationID = operationID;
        this.Task = task;
        this.CancellationSource = cancellationSource;
    }
    public string OperationID { get; set; }
    public Task Task { get; set; }
    public CancellationTokenSource CancellationSource { get; set; }
}


private Dictionary<Guid, TaskWrapper> ListOfTasks = new Dictionary<Guid, TaskWrapper>();


// populate the list


public void CancelAll(string operation)
{
    listOfTasks.Where(a => a.OperationID == operation).CancellationSource.Cancel();
}