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. がMyReceiver内のイベントを含める
3. は、コマンドに「BeginExecute」と「EndExecute」が含まれるコマンドの状態制御のいくつかの並べ替えを実装し、コマンドをサブスクライブします
   012：彼らに物事をラップするために、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 
} 

コマンドの受信者が何らかのアクションを実行し、アンドゥスタックにプッシュする準備ができていることを確認する手段があります。しかし、イベント・スパムには、非同期操作を含むすべての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クラスコンシューマに通知します。

第2に、メソッドの非同期呼び出し完了と呼ばれるAction<T>のようなパラメータを追加します。したがって、非同期呼び出しが終了したときに、このメソッド呼び出し側に通知することができます。

編集

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

Answer 3

制御がExecuteメソッドに戻る前にすべての処理が完了し、呼び出しコードの動作を変更せずに、アクションを実行するという方法を変更する必要がある場合は、

最初に、すべての非同期呼び出しを初期化し、現在のスレッドでブロックして（待機）呼び出しを返します。私は、あなたが気づいているスレッドにあるか、任意のスレッドで返されるかのように、あなたの非同期呼び出しの性質が何であるか分かりませんが、何らかのスレッドを思いつくことができるはずですあなたの問題の同期。

Semaphoreを使用して（現在の非同期メソッドを呼び出した後に）現在のスレッドをブロックし、すべての非同期メソッドが応答を返したときにセマフォを解放してみてください。これにより、非同期呼び出しを「再同期」する効果があります。

他の同期方法を使用することもできますが、セマフォは分かりやすいほどシンプルです。

Answer 4

あなたは1つのクラスであまりにも多くのことをやっていると思います。ここでの大きな利点は、あなたが明示的にハンドラに行くすべての依存関係に沿ってドラッグすることなく、クライアントへのあなたのコマンドを配布できるということです

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

：私はこのようにそれを打破するでしょう。ハンドラはクライアントに知られるべきではありません。すべてのクライアントが知る必要があるのは、コマンドを送信したことであり、すべてのコマンドは成功すると見なされます。