【Unity】Unityで学ぶデザインパターン09: Decorator パターン【デザパタ】

# はじめに
様々な言語で「デザインパターン」の本が世の中にありますが、筆者個人の経験では
`いまいちピンとこない例` `いまいちピンとこないコード` で説明されてることが多く、
`結局これっていつ使うの？` という疑問に答えるには仕事仲間等との議論をしないと
辿り着けないことが多々ありました。

そこで特に「ゲーム開発ではどう使うか？」にフォーカスを当てて、実践的な例を交えて
デザインパターンの説明の需要があると思い記事を作りました。

## デザインパターンを学ぶ理由

デザインパターンを学ぶ理由としては
1. 車輪の再発明の防止
1. 長文で読みにくいコード（可読性の低いコード）を減らす
1. コードを疎結合にして変更に強くなる(変更時のコスト・変更箇所を減らす)
1. モジュールとして使いまわせるように、コードの再利用性を高める
といった効果を期待できます。

## 対象読者
Unity 全くの初心者(インストールしただけで触ったことがないような方)はお断りです。
最低限以下のことは理解・経験を積んでおくことが必須になります。

- MonoBehaviour 継承クラスでコードを書いたことがある
- C# のピュアクラスを用いた自作クラスを作ったことがある
- クラスの継承という概念は知っている

そのため、`脱・初心者` `中級者へのステップアップ` として `デザインパターンを学ぶ` のが良いと思います。


# デザパタ記事リンク
## 生成系
1. [AbstractFactory パターン](https://qiita.com/Cova8bitdot/items/e863cecf48c0529ba05a)
1. [Builder パターン](https://qiita.com/Cova8bitdot/items/9dcdfeb0641bc774b1f8)
1. [FactoryMethod パターン](https://qiita.com/Cova8bitdot/items/61a38fd51735f321e564)
1. [Prototype パターン](https://qiita.com/Cova8bitdot/items/0bc251bc36201985c204)
1. [Singleton パターン](https://qiita.com/Cova8bitdot/items/29b7064c7472a6f34972)

## 構造系
1. [Adapter パターン](https://qiita.com/Cova8bitdot/items/f09776957073cf64902b)
1. [Bridge パターン](https://qiita.com/Cova8bitdot/private/5b528216952c74436045)
1. [Composite パターン](https://qiita.com/Cova8bitdot/items/1c57d856027a33e99eb0)
1. [Decorator パターン](https://qiita.com/Cova8bitdot/items/e1373a756b3dfd86c920)（本記事）
1. [Facade パターン](https://qiita.com/Cova8bitdot/items/bdf0976bdfa83e57f121)
1. [Flyweight パターン](https://qiita.com/Cova8bitdot/items/7f1f1f04b46ebaf43c5e)
1. [Proxy パターン](https://qiita.com/Cova8bitdot/items/8a27137812e103ec1ee3)

## 様態・ふるまい系
1. [Chain of Responsibility パターン](https://qiita.com/Cova8bitdot/items/66c62dd96adffda7e72e)
1. [Command パターン](https://qiita.com/Cova8bitdot/items/9a88f7fc0782c729f97c)
1. [Interpreter パターン](https://qiita.com/Cova8bitdot/items/a871c1de813d14049934)
1. [Iterator パターン](https://qiita.com/Cova8bitdot/items/302f19863cc3b2235625)
1. [Mediator パターン](https://qiita.com/Cova8bitdot/items/be33b97f35c84e814df7)
1. [Memento パターン](https://qiita.com/Cova8bitdot/items/ae7e6f5d2da7b07d379b)
1. [Observer パターン](https://qiita.com/Cova8bitdot/items/632782ad5264baf6a366)
1. [State パターン](https://qiita.com/Cova8bitdot/items/ab9fc16ac3a6657fdce0)
1. [Strategy パターン](https://qiita.com/Cova8bitdot/items/28dd773075cf6e9fefee)
1. [TemplateMethod パターン](https://qiita.com/Cova8bitdot/items/f0bed164ef6563b489d0)
1. [Visitor パターン](https://qiita.com/Cova8bitdot/items/15c56d40435adf63891d)


# Decorator　パターンについて

Decorator パターンとは、ある関数を引数にもらい、その関数の機能を拡張させ、同名関数として返すような機能の事です。
偽コードで解説すると以下のような形です。

```DecoratorSample

function SomeDecorator( function funcA )
{
    return ()=>{
        PreMethod();
        funcA();
        PostMethod();
        };
}
```

何かの関数に対して前処理や後処理を追加した状態で関数を返す機能です。

## C# におけるDecoratorパターン
C#でDecorator パターンは残念ながら実装しづらいです。
一応関数の override によって実現は可能なのですが、他の言語に比べて使用感がイマイチであることは否めません。

やりたいこととしては `前処理や後処理を追加` したいので、以下のような実装になります。

```Decorator.cs
    public abstract class BaseDecorator
    {
        private BaseDecorator m_internalDecorator = null;
        private Action m_mainFunc = null;
        public BaseDecorator(Action mainFunc )
        {
            m_mainFunc = mainFunc;
        }
        public BaseDecorator(BaseDecorator deco)
        {
            m_internalDecorator = deco;
        }
        public void Invoke()
        {
            PreMethod();
            m_internalDecorator?.Invoke();
            m_mainFunc?.Invoke();
            PostMethod();
        }
        protected abstract void PreMethod();
        protected abstract void PostMethod();
    }

    public class LogDecorator : BaseDecorator
    {
        private string m_name = "";
        public LogDecorator(BaseDecorator deco, string name): base(deco)
        {
            m_name = name;
        }
        public LogDecorator(Action act, string name): base(act)
        {
            m_name = name;
        }
        protected override void PreMethod()
        {
            Debug.Log("[Pre]:"+m_name);
        }

        protected override void PostMethod()
        {
            Debug.Log("[Post]:"+m_name);
        }
    }

```

これを用いて以下のようにMonoBehaviour 継承クラスで実行してみましょう。
```DecoratorTest.cs
public class DecoratorTest : MonoBehaviour
{
    void Start()
    {
        Action mainProcess = () => { Debug.LogWarning("Main処理だよ"); };
        LogDecorator log1 = new LogDecorator(mainProcess, "Log1");
        LogDecorator log2 = new LogDecorator(log1, "Log2");
        Debug.Log("==== DO LOG1 ====");
        log1.Invoke();
        Debug.Log("==== DO LOG2 ====");
        log2.Invoke();
    }
}
```

結果はこのように表示され、Decoratorによって処理が積み重なっているのがわかります。

![スクリーンショット 2023-06-15 15.25.01.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/65257/b737d476-ebd2-da3a-fff8-9181f8e7e2ce.png)


## (参考)Python によるDecorator
他の言語の例として Python はどうでしょうか。

PythonではDecoratorを用意しておけば、関数やクラスに対して `@Hoge` という冒頭に`@` をつけるだけでデコレータを適用できます。

```deco.py
def logger(tag):
    def _logger(function):
        def wrapper(*args, **kwargs):
            print("[Pre]:"+tag)
            function(*args, **kwargs)
            print("[Post]:"+tag)
        return wrapper
    return _logger


def sample_api(message: str):
    print("MainMessage:"+message)


@logger("LOG1")
def sample_api02(message: str):
    print("MainMessage:"+message)


@logger("LOG1")
@logger("LOG2")
def sample_api03(message: str):
    print("MainMessage:"+message)


def main():
    sample_api("This is Sample 01")
    print()
    sample_api02("This is Sample 02")
    print()
    sample_api03("This is Sample 03")


if __name__ == "__main__":
    main()
```
先ほどのC#のようにlogger という名前のデコレータを用意しました。
sample_api ではデコレータなし、02、03とデコレータの数を増やしたサンプルです。

これを実行すると以下のようになります。
![スクリーンショット 2023-06-15 16.44.21.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/65257/dd047c2e-ba6d-9a7b-4906-b99a7e18cfee.png)

このように既存の関数定義の直前に `@~~` を追加するだけでデコレータを適用できるため、C#よりはもっとカジュアルに利用可能です。また、デコレータ自体の再利用性も高く、基底クラスに縛られたり、設計に縛られるようなこともありません。


## ゲームにおける Decorator

先ほどの例でも分かる通り C# ではデコレータは少し設計的な問題があるためカジュアルには使われないことが多いでしょう。
そのためゲーム開発でもデコレータを利用した設計はあまりなく、現場では即戦力になることは珍しいと思います。

ちなみに、Pythonのようにカジュアルにデコレータが使える環境だと、処理フローの可視化ログの適応などはとても簡単に実装できますね。

# まとめ
言語使用上、C#でdecoratorパターンを実装しようとするとクラス設計に縛りを設けることになります。
そのため関数のoverride等で実現することになるため、virtualキーワードをつけた仮想関数として公開されない限りはデコレータのよる機能拡張はできません。

ただし、他言語ではカジュアルにできるため、知識としては覚えておくと良いでしょう。