TaskScheduler | Use functors , lambdas and std : :chrono to schedule tasks

From the package documentation:

You are missing @EnableIntegration. That one adds a broader Spring Integration infrastructure , included a required TaskScheduler. See docs foer more info: https://docs.spring.io/spring-integration/docs/current/reference/html/overview.html#configuration-enable-integration

if [the unusual happens], there is still a chance (0.01%) that the main thread can execute Sum method, is my understanding correct?

The answer is possibly!

This involves some serious deep-diving into the specific implementation details of how the TaskScheduler handles tasks that are queued and how the compiler and subsequent smoke and mirrors that run in the back-end of the MSDN language have implemented the state-machines that handle Tasks and async operations.

But in the basic sense you're conclusion, in my opinion, is correct! Per MSDN, if you are using the default TaskScheduler, the TaskScheduler implements certain optimizations on your behalf such as Task Inlining, like you described, and other optimizations like Work Stealing.

If work stealing and task inlining are not desirable, consider specifying a synchronization context of the tasks that you are creating, to prevent them from performing work on threads other than the ones you specify.

If every interface you are creating has exactly one method then you are doing something wrong.

Suppose something wants to find the number of tasks in a period, and add a new task if the number is above or below some arbitrary threshold. With your design, it's impossible. You can either talk to a finder, or an executor, but not a FinderAndExecutor. In such case, you would just need to speak to TaskService directly, completely undermining the point of the interfaces.

Suppose Java's Collection interface were broken up into these interfaces:

You should be passing TaskCreationOptions.RunContinuationsAsynchronously, not TaskContinuationOptions.RunContinuationsAsynchronously.

Passing TaskContinuationOptions.RunContinuationsAsynchronously will call the overload that takes an object parameter, treating it as a "state" object and not as a flag controlling the TCS behavior.

It's all about encoding, maybe some kind of mojibake:

It's best to always use a full path for files as then you can be sure that it is looking where you want it to look.

You can use the filename returned by:

IO.Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData), "yourProgramsDataDirectoryGoesHere", "enabled")

That and the other Windows "special folders" known to .NET are listed in Environment.SpecialFolder Enum.

Another thing to check for is that the account the task is running under has permission to access the file.

[Also, to create a file it's easier to use IO.File.WriteAllText(fullPathToTheFile, "") as then you don't have to remember to call .Dispose() on the FileStream.]

You shouldn't use tasks to launch fire-and-forget jobs, since there is nobody to cache exceptions from it. You also won't be able to use scoped services from there (like the DB), since it'll mess the scope management. To get the background-running process you can use HostedService

The linked solution only works when using a named mutex to synchronize asynchronous code across processes. It won't work to synchronize code within the same process. Mutexes allow recursive acquisition, so by moving all acquisitions on the same thread, it's the same as if the mutex isn't there at all.

I'd have to keep all my semaphores in a Dictionary and that would be too cumbersome to manage.

If you need a non-recursive named mutex, named Semaphores (which don't work on Linux) or managing your own dictionary is really the only way to go.

I have an AsyncCache that I've been working on but isn't prod-ready yet. It tries to look like a cache of Task instances but is actually a cache of TaskCompletionSource instances.