C# で async/await する：N秒後に発火するイベント 

# C# で async/await する：N秒後に発火するイベント 

こんにちは、@studio_meowtoon です。今回は、WSL の Ubuntu 環境の C# から async/await を用いてイベント処理を行う方法を紹介します。  
![csharp_on_ubuntu.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3206449/23c7c71f-e5f1-3bb8-45b6-60ad19e41238.png)

## はじめに
皆さんはN秒後に爆発する爆弾のプログラムと聞いてどのような実装を想像しますか？この記事では爆弾プログラムの実装を進めていく過程から、非同期処理・イベント処理について確認していこうと思います。

## 実装したいこと

爆弾の導火線に火を付けたらN秒後に爆発する処理を実装します。

:::note info
実際に爆弾を作るわけには行かないので以下の仕様に置き換えてみます😋
:::

:::note alert
C# には本来[厳格なコーディング規則](https://learn.microsoft.com/ja-jp/dotnet/csharp/fundamentals/coding-style/coding-conventions)がありますが、この記事では可読性のために、一部規則に沿わない表記方法を使用しています。ご注意ください。
:::

## 開発環境

+ Windows 11 Home 22H2 を使用しています。  

:::note info
[WSL](https://learn.microsoft.com/ja-jp/windows/wsl/about) の Ubuntu を操作していきますので macOS の方も参考にして頂けます。  
:::

<details>

WSL (Microsoft Store アプリ版) [※ こちらの関連記事からインストール方法をご確認いただけます](https://qiita.com/studio_meowtoon/items/2aaa6579cb8e4fa1d874)

```sh
> wsl --version
WSL バージョン: 1.0.3.0
カーネル バージョン: 5.15.79.1
WSLg バージョン: 1.0.47
```

Ubuntu [※ こちらの関連記事からインストール方法をご確認いただけます](https://qiita.com/studio_meowtoon/items/2aaa6579cb8e4fa1d874)

```sh
$ lsb_release -a
No LSB modules are available.
Distributor ID: Ubuntu
Description:    Ubuntu 22.04.1 LTS
Release:        22.04
```

.NET SDK [※ こちらの関連記事からインストール方法をご確認いただけます](https://qiita.com/studio_meowtoon/items/d68031c91462f6808dff)

```sh
$ dotnet --list-sdks
7.0.202 [/usr/share/dotnet/sdk]
$ dotnet --version
7.0.202
```

</details>

:::note warn
この記事では基本的に Ubuntu のターミナルで操作を行います。**Vim を使用してコピペする方法**を初めて学ぶ人のために、以下の記事で手順を紹介しています。ぜひ挑戦してみてください。
:::

https://qiita.com/studio_meowtoon/items/7771ad48676926e41463

## Bomb クラスの仕様

メソッド

|no |name   |accessibility|役割        |動作|
|:--|:--    |:--          |:--         |:--|
|1  |Fire   |public       |導火線に着火する|爆弾起動|
|2  |explode|private      |爆発する    |標準出力にテキストを出力|

プロパティ

|no |name    |accessibility|役割          |種類|
|:--|:--     |:--          |:--           |:-- |
|1  |Interval|public       |爆発までの間隔|数値|

:::note info 
explode メソッドのアクセス修飾子が private なのがポイントです。**爆発する**のは Bomb オブジェクトに実行する責任があると思います。
:::

## 実装のアウトライン

続いて実装のアウトラインを考えてみましょう。

Bomb クラスのアウトライン

```csharp
public class Bombv1 {
    float _interval;
    public void Fire() {
        // TODO:
    }
    public float Interval {
        set => _interval = value;
    }
    void explode() {
        // TODO:
    }
}
```

Bomb オブジェクトを実行するコード

```csharp
class Program {
    static void Main(string[] args) {
        Bombv1 bomb = new() { Interval = 5.0f };
        bomb.Fire();
        ReadLine(); // stop the console.
    }
}
```

:::note info
このように処理の中身はありませんがコードのインタフェース、アウトラインから実装することはよくあります。※ 今回の記事では単体テストには言及いたしません🙇‍♂️
:::

## 初期実装

それでは早速処理の中身を実装していきましょう！

まずシンプルにに実装してみました。

```csharp
public class Bombv1 {
    float _interval;
    public void Fire() {
        WriteLine(value: "fire!");
        explode();
    }
    public float Interval {
        set => _interval = value;
    }
    void explode() {
        Sleep((int) _interval * 1000);
        WriteLine(value: "a bomb has exploded.");
    }
}
```

コマンドラインから実行してみます。

```sh
$ cd go_to_this_app_dir
$ dotnet run v1
```

出力結果

```sh
fire!
a bomb has exploded.
```

:::note info
爆弾プログラムを起動して 5秒後に爆発したテキストが表示されました。とても原始的な処理ですが爆弾っぽい？動作をしました😅
:::

## 最初の重大な問題点

:::note alert
皆さんお気づきかも知れませんが、このプログラムには**重大な問題点**があります😭
:::

それは Bomb オブジェクトの Fire メソッドを呼び出したら、爆発するまで制御が返ってこないことです。このような実装を**同期処理**と呼びます。**同期処理**自体が悪いということはないですが、爆弾の実装という観点からは不適切だと思われます。

:::note warn
導火線に火を付けたら全世界がフリーズする状況を考えてみて下さい😱
:::

## 非同期処理

ここでは現状の問題点の解決策として、実装に非同期処理を導入します。

非同期処理には async/await を使用します。

```csharp
public class Bombv2 {
    float _interval;
    public async void Fire() {
        WriteLine(value: "fire!");
        await explode();
    }
    public float Interval {
        set => _interval = value;
    }
    async Task explode() {
        await Delay((int) _interval * 1000);
        WriteLine(value: "a bomb has exploded.");
    }
}
```

|内容|
|:--|
|N秒**待つ**処理を System.Threading.Thread.Sleep() から System.Threading.Tasks.Task.Delay() に変更しています。|
|これは Sleep() が同期処理のメソッドだからです、一方 Delay() は非同期処理のメソッドです。|
|このように同じような動作をするメソッドで**同期処理**版、**非同期処理**版が存在するケースがあります。|

呼び出し元の実装です。

```csharp
static void run_v2() {
    Bombv2 bomb = new() { Interval = 5.0f };
    bomb.Fire();
    WriteLine(value: "waiting...");
    ReadLine();
}
```

非同期版では Fire メソッドが非同期処理なので、後続の WriteLine メソッドが呼ばれるはずです。

コマンドラインから実行します。

```sh
$ cd go_to_this_app_dir
$ dotnet run v2
```

出力結果

```sh
fire!
waiting...
a bomb has exploded.
```

:::note info
想定通りに爆弾が爆発する前に **waiting...** という文字列が表示されました😋
:::

## ここまでのまとめ

+ 同期処理と非同期処理の違いが分かりました。
+ 非同期処理には async / await 構文を使用します。

## 次の重大な問題点

:::note alert
まだこのプログラムには重大な問題点があります。それは爆弾の出力処理を Bomb クラスに直書きしていることです、この実装だと再利用しにくいと思います😭
:::

それでは Bomb クラスを再利用が可能な実装にする方法はないでしょうか？

まずシンプルにクラスを継承してサブクラスを作るという方法を考えてみます。

## 基底クラスを継承

あるクラスを継承したサブクラスを実装することは、オブジェクト指向プログラミングの基本的な考え方の一つです。

基底クラスを作成します。

```csharp
public abstract class BombBase {
    float _interval;
    public async void Fire() {
        onFire();
        await explode();
    }
    public float Interval {
        set => _interval = value;
    }
    protected virtual void onFire() {
    }
    protected virtual void onExplode() {
    }
    async Task explode() {
        await Delay((int) _interval * 1000);
        onExplode();
    }
}
```

継承クラスを作成します。

```csharp
public class Bombv3 : BombBase {
    protected override void onFire() {
        WriteLine(value: "fire!");
    }
    protected override void onExplode() {
        WriteLine(value: "a bomb has exploded.");
    }
}
```

:::note info
基底クラスの抽象メソッド onFire()、onExplode() メソッドを継承クラスで実装しています。このような実装は GOF の TemplateMethod パターンにカテゴライズされます。継承クラスで基底クラスのフックメソッドを実装するパターンです😋
:::

呼び出し元の実装です。

```csharp
static void run_v3() {
    Bombv3 bomb = new() { Interval = 5.0f };
    bomb.Fire();
    WriteLine(value: "waiting...");
    ReadLine();
}
```

コマンドラインから実行します。

```sh
$ cd go_to_this_app_dir
$ dotnet run v3
```

出力結果

```sh
fire!
waiting...
a bomb has exploded.
```

:::note info
このように、 N秒後に爆発するという Bomb クラスの**普遍的**動作は基底クラスで実装し、発火・爆発といった動作のタイミングで標準出力に文字列を出力するといった、**その状況で必要とされる**動作を継承クラスに切り出すことが出来ました😋
:::

|内容|
|:--|
|上記の例はとてもオブジェクト指向的だと思います。|
|実際に様々なフレームワークでこのような思想で実装されているの見かけます。|
|Bomb クラスを例に挙げれば、発火・爆発といった動作のタイミングで別の処理を行う継承クラスをいくらでも作れます。|

## ここまでのまとめ
基底クラスと継承クラスを作成することにより拡張性の高い実装になりました。

## 次の問題点

:::note alert
でも継承クラスを書くのってめんどくさくないですか？😭
:::

**基底クラスとその継承クラス**を使う実装方法自体に問題はありません、時と場合によりとても有用です。しかしこのN秒後に爆発する爆弾といった例題では、別の方法でも拡張性が高い実装を行うことが出来ます。

## イベントで実装

C# では**イベント**を使用します。  
※他の言語でも似たような実装が可能かも知れません。

イベントを持つクラスを実装します。

```csharp
public class Bombv4 {
    float _interval;
    public event Action? OnFire;
    public event Action? OnExplode;
    public async void Fire() {
        OnFire?.Invoke();
        await explode();
    }
    public float Interval {
        set => _interval = value;
    }
    async Task explode() {
        await Delay((int) _interval * 1000);
        OnExplode?.Invoke();
    }
}
```

:::note info
Action デリゲート型の OnFire、OnExplode イベントを定義しています。
:::

呼び出し元の実装です。

```csharp
static void run_v4() {
    Bombv4 bomb = new() { Interval = 5.0f };
    bomb.OnFire += () => { WriteLine(value: "fire!"); };
    bomb.OnExplode += () => { WriteLine(value: "a bomb has exploded."); };
    bomb.Fire();
    WriteLine(value: "waiting...");
    ReadLine();
}
```

:::note info
イベントに直接ラムダ式で Action デリゲート型の処理を設定しています。
:::

コマンドラインから実行します。

```sh
$ cd go_to_this_app_dir
$ dotnet run v4
```

出力結果

```sh
fire!
waiting...
a bomb has exploded.
```

## ここまでのまとめ

C# のイベントを使うことで拡張性の高い実装をシンプルに記述することが出来ました。
※他の言語でも似たような実装が可能かも知れません。

## まとめ

+ 同期処理と非同期処理の違いと、またなぜ非同期処理が必要になるか理解することが出来ました。
+ (C#の)イベントを使用することにより拡張性の高い実装をオブジェクト指向的手法とは別の方法で行うことが出来ました。
    + ※C言語の頃から関数ポインタで渡すという手法はありましたが、それらはオブジェクト指向的とは認識されてなかったと思います。
+ N秒後に爆発する爆弾を実装するという例題から様々な知見を得ることが出来ました。

どうでしたか？ Window 11 の WSL Ubuntu に、.NET の開発環境を手軽に構築することができます。ぜひお試しください。今後も .NET の開発環境などを紹介していきますので、ぜひお楽しみにしてください。