共享资源和异步的Web API调用

Question

我有一个看起来像这样一个简单的Web API方法：

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是decalared这样的：

public async Task Run(int id) 

我期待它返回“任务被启动“消息后立即TaskManager.Run(taskId)但请求继续同步运行。

但如果更换电话TaskManager.Run(taskId)有：

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

然后异步运行。

所以我认为这与TaskManager和主线程共享的资源有关。共享资源可以锁定执行吗？

我正在使用温莎城堡。一个WindsorContainer容器在Web API项目中声明。 TaskManager在其内部使用BaseTaskRunner类。在BaseTaskRunner中声明了另外一个WindsorContainer。 Web API的容器对所有组件使用LifeStyle.PerWebRequest。 BaseTaskRunner的容器使用LifeStyle.Singleton（不确定它是否正确LifeStyle）。可以通过DdContext或其他在这两个容器中声明的类来锁定该调用吗？

UPD： 我不想等待TaskManager.Run完成。但是会发生什么情况是，return语句仍然等待TaskManager.Run完成（即使没有在TaskManager.Run上等待语句）。 换句话说，它不会不管我怎么叫TaskManager.Run：

TaskManager.Run(taskId); 

或

await TaskManager.Run(taskId); 

它等待TaskManager.Run在这两种情况下完成。

这里是任务管理器的代码：

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;      
      }     
     } 
} 

和一些其他类：

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>>(); 
     } 
    } 

我仍然认为这是值得做的WindsorContainer以及在几个不同的线程中解决的常见类。

Answer 1

问题在于，您在调用TaskManager.Run函数时返回的Task上没有使用await。考虑以下内容：

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.") 
    }; 
} 

现在它会像您期望的那样异步工作。await在async状态机中设置了一个继续标记，指示它在完成TaskManager.Run中定义的异步操作后返回到该方法的这一部分。

UPDATE

你缺少大量的await报表，并有你需要没有方法标记为async倍。看起来好像有一些误解，因为它与这些关键字有关。这是你的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 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;      
      }     
     } 
    } 
} 

理想的情况下，如果该方法被标记为Task返回类型和方法并不需要放松其执行的任何任务，它可以简单地返回Task功能及其实施。例如，请注意我的TaskManager课程与您的不同之处 - 我只将方法标记为async，实际上需要await。这两个关键字应该已结婚，如果方法使用async，则应该有一个await。但如果方法需要展开并使用异步操作，则只能使用await。