在C＃中处理异步操作的命令模式和异步操作

Question

我想听听有关处理与Command模式异步操作的最佳方式的意见。假设我们有下面的例子：

public class MyCommand 
{ 
    // Sets up receiver and does whatever stuff 

    public void Execute() 
    { 
     _myReceiver.DoSomething(); 
    } 
} 

的问题是：mycommand的不知道MyReceiver.DoSomething（）是否有代码的异步部分。如果我想在执行后将MyCommand推入撤消堆栈，我无法保证其接收器操作已完全执行，因此无法确定MyCommand是否达到撤销可能或不可撤销的状态。

我个人认为以下解决方案：

1. 实现某种在命令国家控制的
2. 在命令中包含“BeginExecute”和“EndExecute”
3. 纳入MyReceiver事件和make命令订阅他们（似乎臭我）

为了总结的东西了，mycommand的会变成：

public class MyCommand 
{ 
    public MyCommand(MyReceiver receiver) 
    { 
     _myReceiver = receiver; 
     _myReceiver.DoSomethingFinished +=() => this.EndExecute(); 
    } 

    public void BeginExecute() 
    { 
     this.EnterExecutionState(); 

     _myReceiver.DoSomething(); 
    } 

    public void EndExecute() 
    { 
     this.LeaveExecutionState(); 
    } 

    // State handling related stuff 
} 

我现在有办法确保Command的接收器已经完成执行任何动作，并且它已准备好被推入撤消堆栈。但是，对于事件垃圾邮件，每个包含异步操作的Receiver类都会让我感到不安。

我在互联网上没有发现太多有关这个主题的内容，并且很想听听不同的方法。

OBS：使命令管理所有与异步相关的代码不是一个选项:)。

Answer 1

像这样的事情？

public interface ICommand 
{ 
    void Execute(); 
    event EventHandler Finished; 
} 

public class MyCommand : ICommand 
{ 
    public MyCommand(MyReceiver receiver) 
    { 
     _myReceiver = receiver; 
     _myReceiver.DoSomethingFinished +=() => Finished(); // dont forget null check here. 
    } 

    public void Execute() 
    {  
     _myReceiver.DoSomething(); 
    } 

    public event EventHandler Finished; 
} 

这样一来，该命令的用户可以注册，所以它知道当命令已经完成它的异步行为，可以acordingly采取行动，完成事件。

或者如果你不想使用事件，那么回调呢？

public class MyCommand : ICommand 
{ 
    public MyCommand(MyReceiver receiver) 
    { 
     _myReceiver = receiver; 
    } 

    public void Execute() 
    {  
     _myReceiver.DoSomething(() => Finished()); // dont forget null check here. 
    } 

    public event EventHandler Finished; 
} 

无论采用哪种方式，只需要有一种方式让MyReciever通知其调用者它已完成。没有办法绕过它。

Answer 2

首先，我会添加方法Async的名称，以明确地向您的Command类消费者发信号通知该方法以异步方式执行。

其次，我会添加像参数一个Action<T>这将被称为方法异步调用完成。因此，当异步结束时，可以通知此方法调用方。

编辑

obj.DoSomethingAsync(... params, Action<T> onComplete)

Answer 3

如果要强制要求在控制返回到Execute方法之前完成所有处理，而不修改调用代码的行为，则可以修改操作的执行方式。

首先初始化所有异步调用，并在当前线程上阻塞（等待）以返回调用。我不确定异步调用的本质是什么，就像它们在您知道的线程中，或者将在任意线程中返回一样，但您应该能够创建某种线程同步您的问题。

尝试使用Semaphore来阻止当前线程（在调用异步方法之后），并在所有异步方法返回响应时释放信号量。这将会产生“重新同步”异步调用的效果。

您可以使用另一种同步方法，但信号量很容易理解。

Answer 4

我觉得你在单个课堂上的表现太多了。我想打破它，就像这样：

// An immutable command, to be handled in-process. 
// ICommand is a marker interface with no members. 
public class DoSomething : ICommand 
{ 
    public readonly Id; 

    public DoSomething(Guid id) 
    { 
     Id = id; 
    } 
} 

// To be handled out-of-process. 
[AsynchronousCommand] 
public class DoSomethingThatTakesAReallyLongTime : ICommand 
{ 
    public readonly Id; 

    public DoSomethingThatTakesAReallyLongTime(Guid id) 
    { 
     Id = id; 
    } 
} 

// This guy could take any number of dependencies: ISomethingRepository, DbContext, etc. 
// Doesn't matter, but it's probably gonna have dependencies. 
public class DoSomethingHandler : IHandler<DoSomething> 
{ 
    public void Handle(DoSomething command) // IHandler<T>'s only member 
    { 
     // CRUD or call call a domain method 
    } 
} 

public class CommandService : ICommandService 
{ 
    public void Execute(params ICommand[] commands) // ICommandService's only member 
    { 
     foreach(var command in commands) 
     { 
      var handler = GetHandler(command); // Could use your IOC container. 

      if (HasAsyncAttribute()) 
       new Action(() => handler.Handle(command)).BeginInvoke(null, null); 
      else 
       handler.Handle(command); 
     } 
    } 
} 

// Something that might consume these 
public class SomethingController 
{ 
    private readonly ICommandService _commandService; 

    public SomethingController(ICommandService commandService) 
    { 
     _commandService = commandService; 
    } 

    [HttpPost] 
    public void DoSomething(Guid id) 
    { 
     _commandService.Execute(new DoSomething(id)); 
    } 

    [HttpPost] 
    public void DoSomethingThatTakesAReallyLongTime(Guid id) 
    { 
     _commandService.Execute(new DoSomethingThatTakesAReallyLongTime(id)); 
    } 
} 

这里最大的好处是，你可以不沿着所有与处理程序走的依赖性明确拖动分发您的命令给客户。客户不应该知道处理程序。所有客户端需要知道的是它发送了一个命令，并且所有的命令都应该被假定为成功。