CodeGym /コース /C# SELF /デリゲート: 発展的なシナリオ

デリゲート: 発展的なシナリオ

C# SELF
レベル 54, レッスン 3
使用可能

1. コールバックと非同期プログラミング

コールバック (callback) は、ある操作が終わったときに呼ばれるメソッドを渡す仕組みだ。非同期操作、タイマー、データ処理、UIでよく使う。

例 1: コールバック付きの非同期操作

たとえば、ユーザーがクエリを入力して結果が遅延して返ってくる(例えばインターネット経由)アプリを想定する。データを受け取った後に画面を更新したい場合。


// コールバック用のデリゲート
public delegate void DataReceivedHandler(string result);

// データを非同期でダウンロードする仕組み(シミュレーション)
public void DownloadDataAsync(DataReceivedHandler callback)
{
    // ダウンロードに時間がかかると仮定(タイマーでシミュレート)
    Task.Delay(1000).ContinueWith(_ =>
    {
        string data = "検索結果: <データ>";
        callback(data); // コールバックデリゲートの呼び出し
    });
}

// 使用例:
DownloadDataAsync(result =>
{
    Console.WriteLine("受信: " + result);
});

このアプローチだと、結果を受け取った後のロジックを取得の仕組みから完全に切り離して柔軟に書ける。

2. メソッドのパラメータとしてのデリゲート:ストラテジーとコンパレータ

よくある課題:ユーザーがあなたのメソッドに“ロジック”(関数)を渡せるようにして、要素の比較・フィルタ・変換方法を自由に決められるようにすること。

例 2: デリゲートを使った Strategy パターンの実装

たとえば、ソートがあって、ユーザーが名前順、日付順、サイズ順など色々な基準でソートできるようにしたい場合。


public delegate bool CompareFunc(int a, int b);

public void BubbleSort(int[] arr, CompareFunc compare)
{
    for (int i = 0; i < arr.Length; i++)
    {
        for (int j = 0; j < arr.Length - 1; j++)
        {
            if (compare(arr[j], arr[j + 1]))
            {
                // 交換する
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

// 降順ソート
CompareFunc descending = (a, b) => a < b;

// 使用例
int[] numbers = { 3, 1, 4, 2 };
BubbleSort(numbers, descending);
Console.WriteLine(string.Join(", ", numbers)); // 出力: 4, 3, 2, 1

こういう手法は、元のコードを変えずに外部から“戦略”を注入する一般的な方法だ。

3. 匿名メソッド、ラムダ式とデリゲート

C# の発展によって、毎回別クラスやメソッドを用意するのが不便になった。幸い、匿名メソッドやラムダ式があってデリゲートをその場で作れる。

例 3: ラムダをデリゲートとして使う


Func<int, int, int> operation = (x, y) => x * y;
int result = operation(3, 5); // 15

例 4: 名前で操作を選ぶ(switch + Delegates)


Func<int, int, int> op;
string userInput = "sum"; // "sub", "mul", "div"

switch (userInput)
{
    case "sum": op = (a, b) => a + b; break;
    case "sub": op = (a, b) => a - b; break;
    case "mul": op = (a, b) => a * b; break;
    case "div": op = (a, b) => a / b; break;
    default: throw new Exception("不明な操作です!");
}
Console.WriteLine(op(6, 2));

入力のバリデーションは忘れずに — デリゲートはここで柔軟性と可読性を与えてくれる。

4. デリゲートと処理のチェーン(“責任の連鎖”)

デリゲートはマルチキャストをサポートしているので、処理ハンドラのチェーンを簡単に作れる。

例 5: フィルタのチェーン呼び出し

文字列を順に処理する“フィルタ”があると想定しよう。


public delegate string StringFilter(string input);

string RemoveDigits(string input) => new string(input.Where(ch => !char.IsDigit(ch)).ToArray());
string ToUpper(string input) => input.ToUpper();

StringFilter filters = RemoveDigits;
filters += ToUpper;

// デリゲートを通して文字列をすべてのフィルタで処理する
string text = "こんにちは123";
foreach (StringFilter filter in filters.GetInvocationList())
{
    text = filter(text);
}
Console.WriteLine(text); // 出力: "こんにちは"(数値が削除され、その後に ToUpper が適用される)

注意: もし単に filters(text) と呼ぶと、チェーンの 最後の ハンドラの戻り値だけが返されるよ。値を逐次伝播させたいときは上のように GetInvocationList() で明示的にイテレートしてね。

5. 実行時に振る舞いを動的に差し替えるデリゲート

以前は振る舞いを差し替えるために別クラスやインターフェイスを用意していた。デリゲートとラムダで“小さな”ポリモーフィズムの多くを関数で表現できる。

例 6: 動的なコマンドを受け取るロボットの振る舞い


public class Robot
{
    public event Action<string>? OnCommandReceived;

    public void ReceiveCommand(string command)
    {
        OnCommandReceived?.Invoke(command);
    }
}

// 使用例:
var robot = new Robot();

robot.OnCommandReceived += cmd => Console.WriteLine($"ロボット実行中: {cmd}");
robot.OnCommandReceived += cmd =>
{
    if (cmd == "起動")
        Console.WriteLine("システムを起動中...");
};
// 試してみる
robot.ReceiveCommand("起動");
robot.ReceiveCommand("前進");

この手法はテストやプロトタイプ、DI(dependency injection)コンテナ、ビジネスロジックをパラメータで渡す際によく使われる。

6. デリゲートを状態購読に使う

あるクラスが状態を持っていて、その変更時に全サブスクライバーへ通知したい場合、デリゲート(とイベント)で簡単に実現できる。

例 7: 値の変更を購読するクラス


public class Notifier<T>
{
    private T _value = default!;
    public event Action<T>? ValueChanged;

    public T Value
    {
        get => _value;
        set
        {
            if (!Equals(_value, value))
            {
                _value = value;
                ValueChanged?.Invoke(_value);
            }
        }
    }
}

// 使用例:
var intValue = new Notifier<int>();
intValue.ValueChanged += v => Console.WriteLine($"新しい値: {v}");
intValue.Value = 5; // イベントがトリガーされる
intValue.Value = 10;

このやり方は「ミニマムなリアクティブプログラミング」と言える基礎で、MVVM や data binding、現代の多くの UI フレームワークの基礎になる。

7. デリゲート、クロージャ、レキシカルスコープ

ラムダ式や匿名メソッドは外側のコンテキストの変数をキャプチャできる(クロージャ)。便利だが、時に予期しないバグの原因になる。

例 8: 変数キャプチャとループの“罠”


Action[] actions = new Action[3];

for (int i = 0; i < 3; i++)
{
    actions[i] = () => Console.WriteLine(i);
}

foreach (var a in actions)
    a(); // 3 が三回出力される (!)

なぜ?クロージャが同じ変数 i を参照していて、ループ後に i は 3 になっているから。0,1,2 を記憶させたい場合はどうする?


for (int i = 0; i < 3; i++)
{
    int loopValue = i; // 現在の値を「固定」する
    actions[i] = () => Console.WriteLine(loopValue);
}

これで期待通りに動く。こういう罠はラムダ初心者がよく引っかかるポイントだよ!

8. デリゲートの結合(コンバイン)

マルチキャストデリゲートはメソッドのリストを持つので、ハンドラを追加(+=)したり削除(-=)したりできる。

特徴: 削除は参照とシグネチャで行われる


void Handler1() => Console.WriteLine("1");
void Handler2() => Console.WriteLine("2");

Action a = Handler1;
a += Handler2;
a -= Handler1; // Handler2 のみが残る
a?.Invoke();   // "2" が出力される

例: ハンドラの動的管理


Action a = Handler1;
a += Handler1;
a -= Handler1; // これでリストには Handler1 が 1 個残る!

9. デリゲートの拡張性と制御の反転(IoC)

大規模アプリでは、コンポーネントが外部のコードを呼べるようにしつつ疎結合を保ちたい場面が多い。デリゲートは拡張やプラグイン、コールバックを tight coupling なしで組み込むのに便利だ。

例: コンストラクタで振る舞いを注入する


public class Greeter
{
    private readonly Func<string> _getName;

    public Greeter(Func<string> getName)
    {
        _getName = getName;
    }

    public void Greet() => Console.WriteLine($"こんにちは, {_getName()}!");
}

// 様々な振る舞いの注入:
var greeter1 = new Greeter(() => "アーニャ");
var greeter2 = new Greeter(() => DateTime.Now.ToShortTimeString());

greeter1.Greet(); // "こんにちは, アーニャ!"
greeter2.Greet(); // "こんにちは, 14:35!"

実際の開発では、テスト可能で保守しやすいコードを書くためにこの手法がよく使われる。

10. 便利な注意点

標準インターフェイスや LINQ におけるデリゲート

もし LINQ、コレクション、非同期処理を扱うならデリゲートとは必ず出会う。

  • 多くのメソッド、例えば List<T>.Find、Array.Sort、Where、Select はデリゲート(Func<T, bool>、Comparison<T> 等)を受け取る。
  • LINQ メソッドはフィルタ、変換、集約のロジックをクラスを作らずに渡せるようにする。

例: オブジェクトのソート用コンパレータ


var people = new[] { "イワン", "マリヤ", "ペトル" };
Array.Sort(people, (a, b) => a.Length.CompareTo(b.Length));
Console.WriteLine(string.Join(", ", people)); // イワン, ペトル, マリヤ

デリゲートとカリー化(引数の部分適用)

匿名メソッドやラムダを使えば、引数の一部を固定して新しい関数を作れる。

例: 部分適用


Func<int, int, int> sum = (x, y) => x + y;

// 常に 10 を足す関数を作る
Func<int, int> add10 = y => sum(10, y);

Console.WriteLine(add10(5)); // 15

デリゲートの比較に関する注意

C# ではデリゲートは等価比較(==)でき、呼び出しリスト(invocation list)が同じなら等しいとみなされる。


void Handler1() { }
void Handler2() { }

Action a1 = Handler1;
Action a2 = Handler1;
Console.WriteLine(a1 == a2); // True

Action a3 = Handler1; a3 += Handler2;
Action a4 = Handler1; a4 += Handler2;
Console.WriteLine(a3 == a4); // True

ただし、匿名メソッドやラムダから作られたデリゲートはインスタンスごとに比較される点に注意。

デリゲートのシリアライズ

デリゲートはシリアライズできるが、参照しているメソッドがシリアライズ可能なクラスに定義されていて、全ての型が利用可能である場合に限られる。 .NET 8 以降、BinaryFormatter はデフォルトで無効化されており非推奨で、将来的に削除される予定なので、本番でデリゲートのシリアライズはほとんど使われない。

デリゲートとイベントの関係:どちらを使うべきか?

  • デリゲートは呼び出せる型/変数で、外部から直接 Invoke できる。
  • イベント(event)はデリゲートへのアクセスを制限する方法で、外部からは購読/解除(+=/-=)だけが可能で、呼び出しはクラス内部だけに制御できる。
  • イベントは常にデリゲート型だが、全てのデリゲートがイベントというわけではない。

使い分けはこう考えるといい:ロジックをクラス外で定義させたいだけならデリゲート。購読の管理や変数の保護が必要ならイベントを使う。

11. デリゲートの扱いでよくあるミス

ミス #1: デリゲートとイベントの混同。
公開フィールドとしてデリゲートを公開する(public Action MyAction;)のは、イベント(public event Action MyAction;)にすべきところでインカプセル化を壊すことになる。外部コードが意図的に全購読者を上書き(instance.MyAction = null;)したり、直接呼び出したりできてしまい、クラスのロジックが壊れる。

ミス #2: マルチキャストデリゲートの戻り値の扱いを間違う。
例えばデリゲートが値を返す(Func<string, int> など)場合、普通に呼ぶと(myDelegate("test"))チェーンの最後のメソッドの結果だけが返る。全ての購読者の結果を得たいなら GetInvocationList() を使って列挙する必要がある。


// 全ての購読者の結果を列挙する例
var list = myDelegate.GetInvocationList();
foreach (var d in list)
{
    var r = ((Func<string, int>)d)("test");
    Console.WriteLine(r);
}

ミス #3: ループ内での変数キャプチャ。
ラムダをループ内で作るときにイテレータ変数自体をキャプチャしてしまい、その時点の値ではなく最終的な値を参照してしまうのは典型的な罠だ。


// NG: すべてのアクションが最後の i を表示する
for (int i = 0; i < 3; i++) 
{
    actions[i] = () => Console.WriteLine(i);
}

// OK: 各イテレーションでローカルコピーを作る
for (int i = 0; i < 3; i++) 
{
    int copy = i;
    actions[i] = () => Console.WriteLine(copy);
}

ミス #4: メモリリークを作る。
インスタンスメソッドが長寿命オブジェクトのデリゲートに登録され、その後解除されないとリークが発生する。長寿命なオブジェクトが購読者への参照を保持し続けるため、ガベージコレクタは購読者を回収できなくなる。特に UI コンポーネントのようにライフサイクルが限られているクラスでは購読解除を忘れないこと。

2
タスク
C# SELF, レベル 54, レッスン 3
ロック未解除
デリゲートを使ったテキスト処理のパイプライン
デリゲートを使ったテキスト処理のパイプライン
コメント
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION