Manually executable TaskScheduler

[Denis535]

Default TaskScheduler just puts all the tasks into the thread pool.
But for this reason I need TaskScheduler which stores all my tasks until I will execute them manually.

Unfortunately, I did not find any solution. So, I tried to write it myself.

public class ManualTaskScheduler : TaskScheduler {

    private ConcurrentQueue<Task> Tasks { get; } = new ConcurrentQueue<Task>();
    public override int MaximumConcurrencyLevel => 1;

    public void Execute() {
        while (Tasks.TryDequeue( out var task )) {
            TryExecuteTask( task );
        }
    }
    protected override bool TryExecuteTaskInline(Task task, bool taskWasPreviouslyQueued) {
        return false;
    }

    protected override void QueueTask(Task task) {
        Tasks.Enqueue( task );
    }
    protected sealed override bool TryDequeue(Task task) {
        return false;
    }

    protected override IEnumerable<Task> GetScheduledTasks() {
        return Tasks.ToArray();
    }

}

Firstly, I want to ask you if I wrote it correctly? Or could there be a problem here?
Secondly, it would be nice if you added this to your library.

[Denis535]

Here is the version with locks and ManualResetEvent allowing you to wait for a task.
It looks like it works, but I'm afraid there might be bugs in some rare cases. Can you tell me if I did it right?

public class ManualTaskScheduler : TaskScheduler {

    private Queue<Task> Tasks { get; } = new Queue<Task>();
    private ManualResetEvent Event { get; } = new ManualResetEvent( false );
    public override int MaximumConcurrencyLevel => 1;


    public void Wait() {
        Event.WaitOne();
    }

    public void Execute() {
        lock (Tasks) {
            while (Tasks.TryDequeue( out var task )) {
                TryExecuteTask( task );
            }
            Event.Reset();
        }
    }
    protected override bool TryExecuteTaskInline(Task task, bool taskWasPreviouslyQueued) {
        return false;
    }

    protected override void QueueTask(Task task) {
        lock (Tasks) {
            Tasks.Enqueue( task );
            Event.Set();
        }
    }
    protected sealed override bool TryDequeue(Task task) {
        return false;
    }

    protected override IEnumerable<Task> GetScheduledTasks() {
        lock (Tasks) {
            return Tasks.ToArray();
        }
    }

}

[Denis535]

Now tasks are executed outside of lock.

    public void Execute() {
        var tasks = default( Task[] );
        lock (Tasks) {
            tasks = Tasks.ToArray();
            Tasks.Clear();
            Event.Reset();
        }
        var exceptions = default( List<Exception> );
        foreach (var task in tasks) {
            try {
                TryExecuteTask( task );
            } catch (Exception ex) {
                exceptions ??= new List<Exception>();
                exceptions.Add( ex );
            }
        }
        if (exceptions?.Count == 1) {
            throw exceptions[ 0 ];
        }
        if (exceptions?.Count >= 2) {
            throw new AggregateException( exceptions );
        }
    }

[AArnott]

I would recommend you throw AggregateException always. Otherwise your caller will have to deal with non-deterministic exception types being thrown based just on timing conditions around how many tasks are in the queue at the time they execute.

It's also not clear to me what Event is for and what Wait() is expected to wait on. It seems it will wait until Execute is called (but unblock before those tasks execute), and block again as soon as the next task gets scheduled. If that's your intent, then the rest of your code loks accurate.

[Denis535]

Thank you!
It will wait until QueueTask(task) is called.
See example: https://stackoverflow.com/a/72718874/4805491

public void Execute() {
    var tasks = default( Task[] );
    lock (Tasks) {
        tasks = Tasks.ToArray();
        Tasks.Clear();
        Event.Reset();
    }
    var exceptions = default( List<Exception> );
    foreach (var task in tasks) {
        try {
            TryExecuteTask( task );
        } catch (Exception ex) {
            exceptions ??= new List<Exception>();
            exceptions.Add( ex );
        }
    }
    if (exceptions != null && exceptions.Any()) {
        throw new AggregateException( exceptions );
    }
}

[Denis535]

By the way, I did not implement the TryExecuteTaskInline and TryDequeue methods. Can it lead to problems or it's okay?

[AArnott]

It looks to me from your initial code snippet that you did indeed implement them (to return false). That should be fine. I mean, it'll have impact, but I think it's the impact you want.