Shared resource and async Web API call

Question

I have a simple Web API method that looks like this:

public async Task<HttpResponseMessage> RunTask(TaskType taskType)
{
    var taskId = await TaskManager.CreateTask(taskType);
    TaskManager.Run(taskId);

    return new HttpResponseMessage
    {
        StatusCode = HttpStatusCode.OK,
        Content =
            new StringContent($"Task {taskType.GetDescription()} was started.")
    };
}

TaskManager.Run is decalared like this:

public async Task Run(int id)

I was expecting it to return "Task was started" message immediately after TaskManager.Run(taskId) But the request continues to run synchronously.

But if to replace the call TaskManager.Run(taskId) with:

 Task.Run(() => Thread.Sleep(TimeSpan.FromSeconds(100)));

Then it runs asynchronously.

So I believe this is something to do with the resources shared by TaskManager and main thread. Can a shared resource lock the execution?

I'm using Castle Windsor. One WindsorContainer container is declared in Web API project. TaskManager utilizes BaseTaskRunner class inside of it. One more WindsorContainer is declared in BaseTaskRunner. Web API's container uses LifeStyle.PerWebRequest for all components. BaseTaskRunner's container uses LifeStyle.Singleton (not sure if it's correct LifeStyle). Could the call be locked for example by DdContext or other classes declared in both of the containers?

UPD: I don't want to wait the TaskManager.Run to complete. But what happens is that return statement still waits for the TaskManager.Run to complete (even without await statement on TaskManager.Run). In other words it does not matter how I call the TaskManager.Run:

TaskManager.Run(taskId);

or

await TaskManager.Run(taskId);

It waits for TaskManager.Run to complete in both cases.

Here is the code of TaskManager:

 public class TaskManager : ITaskManager
    {
        public IRepository<BackgroundTask> TaskRepository { get; set; }
        public async Task<int> CreateTask(TaskType type, byte[] data = null, object config = null)
        {
            var task = new BackgroundTask
            {
                Type = type,
                Status = BackgroundTaskStatus.New,
                Config = config?.SerializeToXml(),
                Created = DateTime.Now,
                Data = data
            };

            TaskRepository.Add(task);
            TaskRepository.SaveChanges();

            return task.Id;
        }

        public async Task Run(int id, bool removeOnComplete = true)
        {
            var task = TaskRepository.GetById(id);
            Run(task, removeOnComplete);
        }

        public async Task Run(TaskType type, bool removeOnComplete = true)
        {
            var tasksToRun = TaskRepository.Get(t => t.Type == type);
            tasksToRun.ForEachAsync(t => Run(t, removeOnComplete));
        }

        public async Task Run(BackgroundTask task, bool removeOnComplete = true)
        {
            switch (task.Type)
            {
                case TaskType.SpreadsheetImport:
                    new SpreadsheetImportTaskRunner().Run(task);
                    break;                    
            }                  
        }
}

And some other classes:

public class SpreadsheetImportTaskRunner : BaseTaskRunner
    {
        public IForecastSpreadsheetManager SpreadsheetManager { get; set; }
        protected override void Execute()
        {
            SpreadsheetManager.ImportActuals(Task.Data);
        }

        protected override void Initialize()
        {
            base.Initialize();
            SpreadsheetManager = _container.Resolve<IForecastSpreadsheetManager>();
        }
    }

BaseTaskRunner:

public class BaseTaskRunner
    {
        public IRepository<BackgroundTask> TaskRepository { get; set; }

        protected IWindsorContainer _container = new WindsorContainer();
        protected BackgroundTask Task { get; set; }

        public async Task Run(BackgroundTask task)
        {
            Initialize();
            Task = task;

            try
            {               
                Execute();               
            }
            catch (Exception ex)
            {
                SetError(ex.ToString());
            }
        }

        protected virtual void Execute()
        {

        }

        protected virtual void Initialize()
        {
            _container.Install(new TaskRunnerComponentsInstaller());
            TaskRepository = _container.Resolve<IRepository<BackgroundTask>>();
        }   
    }

I still believe this is something to do with the WindsorContainer and common classes which are resolved in several different threads.

Answer 1

The issue is that you're not using await on the Task being returned from the invocation of the TaskManager.Run function. Consider the below:

public async Task<HttpResponseMessage> RunTask(TaskType taskType)
{
    var taskId = await TaskManager.CreateTask(taskType);
    await TaskManager.Run(taskId);

    return new HttpResponseMessage
    {
        StatusCode = HttpStatusCode.OK,
        Content =
            new StringContent($"Task {taskType.GetDescription()} was started.")
    };
}

Now it will work asynchronously as you'd expect. The await sets a continuation marker in the async state-machine, instructing it to return to this portion of the method upon completion of the asynchronous operation defined in the TaskManager.Run.

UPDATE

You are missing lots of await statements, and there are times where you need to not mark methods as async. It appears as though there are some mis-understandings as it pertains to these keywords. Here is what your TaskManager class should look like.

public class TaskManager : ITaskManager
{
    public IRepository<BackgroundTask> TaskRepository { get; set; }

    public async Task<int> CreateTask(TaskType type, 
                                      byte[] data = null, 
                                      object config = null)
    {
        var task = new BackgroundTask
        {
            Type = type,
            Status = BackgroundTaskStatus.New,
            Config = config?.SerializeToXml(),
            Created = DateTime.Now,
            Data = data
        };

        TaskRepository.Add(task);
        TaskRepository.SaveChanges();

        return task.Id;
    }

    public ask Run(int id, bool removeOnComplete = true)
    {
        var task = TaskRepository.GetById(id);
        return Run(task, removeOnComplete);
    }

    public Task Run(TaskType type, bool removeOnComplete = true)
    {
        var tasksToRun = TaskRepository.Get(t => t.Type == type);
        return tasksToRun.ForEachAsync(t => Run(t, removeOnComplete));
    }

    public Task Run(BackgroundTask task, bool removeOnComplete = true)
    {
        switch (task.Type)
        {
            case TaskType.SpreadsheetImport:
                return new SpreadsheetImportTaskRunner().Run(task);
                break;                    
            }                  
        }
    }
}

Ideally, if the method is marked as a return type of Task and the method doesn't need to unwind any tasks within its execution it can simply return the Task functionality for its implementation. For example, notice how dramatically my TaskManager class differs from yours -- I'm only marking methods as async that need to actually await. These two keywords should be married, if a method uses async there should be an await. But only use await if the method needs to unwind and use the asynchronous operation.