Question

Is it safe to left task unreferenced if i know for sure that it doesn’t throw an exception? Will GC wait untill a task completes before collects it?

Here is an example of my method that converts an array of the tasks into one task that completes (is canceled or failed) when all tasks completes. My application fails with task unobserved exception (by logging Task.Id at any place where I use tasks I found that the task that left unobserved is the one supplied to this method or at least has the same id). I have no idea why this happens except the garbage collector collects the task returned from Task.Factory.ContinueWhenAll not waiting when it is completed as such it may also collect all my tasks from the array left unreferenced and if there are at least one failed task it will lead task unobserved exception. Sounds crazy but i don’t see another explanation to what heppens. So is it possible?

        public static Task ToWhenAllTask(this Task[] tasks, bool cancelIfAnyCanceled = true)
    {
        if (tasks != null && tasks.Length == 0)
            throw new ArgumentException();

        var tcs = new TaskCompletionSource<object>();

        Task.Factory.ContinueWhenAll(tasks, ts => {
            try
            {
                List<Exception> errors = null;
                bool canceled = false;

                foreach (Task task in ts)
                {
                    AggregateException ex = task.Exception;

                    if (ex != null)
                    {
                        if (errors == null)
                            errors = new List<Exception>();

                        errors.Add(ex.Flatten());
                    }

                    if (task.IsCanceled)
                        canceled = true;
                }

                if (errors != null)
                    tcs.TrySetException(errors);
                else if (cancelIfAnyCanceled && canceled)
                    tcs.TrySetCanceled();
                else
                    tcs.TrySetResult(null);
            }
            catch(Exception ex)
            {

                // there is nothing to fail in this method but just in case
                tcs.TrySetException(ex);
            }

        }, TaskContinuationOptions.ExecuteSynchronously);

        return tcs.Task;
    }

PS. To be honest I thought that until task is completed TaskScheduller holds a reference to it (and in my case the continuation task also holds a reference to the tasks array). So GC can’t collect the continuation task and all the tasks from array until all of them completes.

Answer 1

Finally I’ve found the reason for my problem. And the direct answer to my question posted at first lines is – yes, it is safe to left task unreferenced if you know for sure it won’t fail with error. And yes, tasks will not be collected by GC untill they complete BUT only if they started (i.e. they were scheduled on TaskScheduler)

Word ‘BUT’ in capital letters above means that there can be a problem for very particular case: if you left an instance of Task in uscheduled state and loose all references to it.

Here is concrete example (actually what happened with me when I posted the question here) if you do ContinueWhenAll on a few tasks, one of which failed with a error and at least one is not scheduled (and the remaining ones are completed if there are any) and you loose references to all of that tasks and also don’t save a reference to the one returned by ContinueWhenAll then all of them will be collected by GC next time it collects garbage. And that failed task from the ones passed in ContinueWhenAll will lead Task Unobserved Exception.

Not scheduled task above means it was created by either of the ways:

1. Just new Task(…) was called (without further call of Start
   method)
2. it was created by TaskCompleteionSource but not set to
   completion, failed state or canceled.

Such behavior looks consistent from TPL point of view. Just because you should not supply tasks that will never be scheduled to ContinueWhenAll method and wait forever. So in fact if none of other tasks passed in ContinueWhenAll were failed the continuation will just never happen rather than Task Unobserved Exception occured. That’s it!