[C#] デリゲートの基本的な使い方を初心者向けに解説

デリゲートは、C#でメソッドを参照するための型です。

デリゲートを使うことで、メソッドを引数として渡したり、動的にメソッドを呼び出すことができます。

デリゲートは以下のように定義します。

delegate 戻り値の型 デリゲート名(引数の型);

例えば、intを返し、intを引数に取るデリゲートは次のように定義します。

delegate int MyDelegate(int x);

デリゲートを使うには、まずメソッドを定義し、そのメソッドをデリゲートに割り当てます。

割り当てたデリゲートを通じてメソッドを呼び出すことができます。

デリゲートはイベント処理やコールバック関数でよく使われます。

目次から探す

デリゲートとは何か
デリゲートの定義と使い方
デリゲートの種類
デリゲートの実践例
デリゲートとイベントの関係
デリゲートの応用例
まとめ

デリゲートとは何か

デリゲートは、C#における型安全なメソッド参照を表すオブジェクトです。

デリゲートを使用することで、メソッドを引数として渡したり、メソッドを戻り値として返したりすることが可能になります。

これにより、柔軟で再利用可能なコードを書くことができます。

デリゲートの基本

デリゲートは、特定のメソッドのシグネチャ(戻り値の型と引数の型)を持つ型です。

デリゲートを定義することで、そのデリゲート型に一致するメソッドを参照することができます。

// デリゲートの定義
public delegate int MyDelegate(int a, int b);
// メソッドの定義
public static int Add(int x, int y)
{
    return x + y;
}
// メイン関数
public static void Main()
{
    MyDelegate del = Add; // デリゲートのインスタンス化
    int result = del(5, 3); // メソッドの呼び出し
    Console.WriteLine(result); // 結果を表示
}

デリゲートの役割と用途

デリゲートは、以下のような役割や用途があります。

役割・用途	説明
コールバック関数	非同期処理やイベント処理で使用される。
メソッドの引数として渡す	メソッドを引数として受け取ることができる。
イベント処理	イベントの発生時に特定のメソッドを呼び出す。

デリゲートとメソッドの関係

デリゲートは、特定のメソッドを参照するための「ポインタ」のような役割を果たします。

デリゲートを使用することで、メソッドを動的に選択したり、異なるメソッドを同じデリゲートで呼び出すことができます。

using System;

public class App
{
    // デリゲートの定義
    public delegate int MyDelegate(int a, int b);
    // メソッドの定義
    public static int Add(int x, int y)
    {
        return x + y;
    }
    // メイン関数
    public static void Main()
    {
        MyDelegate del = Add; // デリゲートのインスタンス化
        int result = del(5, 3); // メソッドの呼び出し
        Console.WriteLine(result); // 結果を表示
    }
}

8
2

デリゲートとイベントの違い

デリゲートとイベントは密接に関連していますが、異なる概念です。

デリゲートはメソッドの参照を持つ型であり、イベントはデリゲートを使用して特定のアクションが発生したことを通知する仕組みです。

デリゲート: メソッドを参照するための型。
イベント: デリゲートを使用して、特定のアクションが発生したことを通知する仕組み。

デリゲートは、イベントの実装において重要な役割を果たします。

イベントは、デリゲートを使用して、リスナーに通知を送ることができます。

デリゲートの定義と使い方

デリゲートは、特定のメソッドを参照するための型であり、C#プログラミングにおいて非常に重要な役割を果たします。

ここでは、デリゲートの定義方法や使い方について詳しく解説します。

デリゲートの基本的な定義方法

デリゲートは、delegateキーワードを使用して定義します。

デリゲートの定義には、戻り値の型と引数の型を指定します。

// デリゲートの定義
public delegate void MyDelegate(string message);

この例では、MyDelegateという名前のデリゲートを定義しています。

このデリゲートは、string型の引数を受け取り、戻り値はありません。

デリゲートを使ったメソッドの呼び出し

デリゲートを使用して、特定のメソッドを呼び出すことができます。

以下の例では、デリゲートを使ってメソッドを呼び出しています。

// デリゲートの定義
public delegate void MyDelegate(string message);
// メソッドの定義
public static void ShowMessage(string message)
{
    Console.WriteLine(message);
}
// メイン関数
public static void Main()
{
    MyDelegate del = ShowMessage; // デリゲートのインスタンス化
    del("こんにちは、デリゲート！"); // メソッドの呼び出し
}

こんにちは、デリゲート！

デリゲートのインスタンス化

デリゲートを使用するには、まずデリゲートのインスタンスを作成する必要があります。

デリゲートのインスタンスは、特定のメソッドを参照します。

// メソッドの定義
public static void Greet(string name)
{
    Console.WriteLine($"こんにちは、{name}さん！");
}
// メイン関数
public static void Main()
{
    MyDelegate del = Greet; // デリゲートのインスタンス化
    del("太郎"); // メソッドの呼び出し
}

こんにちは、太郎さん！

デリゲートを引数として渡す方法

デリゲートは、メソッドの引数として渡すことができます。

これにより、メソッドの動作を柔軟に変更することができます。

// メソッドの定義
public static void Execute(MyDelegate del, string message)
{
    del(message); // デリゲートを使ってメソッドを呼び出す
}
// メイン関数
public static void Main()
{
    MyDelegate del = ShowMessage; // デリゲートのインスタンス化
    Execute(del, "デリゲートを引数として渡しました！"); // メソッドの呼び出し
}

デリゲートを引数として渡しました！

デリゲートを戻り値として返す方法

デリゲートを戻り値として返すことも可能です。

これにより、メソッドの実行結果に基づいて異なるメソッドを選択することができます。

// デリゲートの定義
public delegate int MathOperation(int a, int b);
// メソッドの定義
public static MathOperation GetOperation(string operation)
{
    if (operation == "add")
    {
        return Add; // 加算メソッドを返す
    }
    else
    {
        return Subtract; // 減算メソッドを返す
    }
}
// メイン関数
public static void Main()
{
    MathOperation operation = GetOperation("add"); // 加算メソッドを取得
    int result = operation(5, 3); // メソッドの呼び出し
    Console.WriteLine(result); // 結果を表示
}

このように、デリゲートを使うことで、メソッドの定義や呼び出しを柔軟に行うことができます。

デリゲートは、C#プログラミングにおいて非常に強力な機能です。

デリゲートの種類

C#には、デリゲートの種類がいくつかあります。

ここでは、シングルキャストデリゲート、マルチキャストデリゲート、匿名メソッド、ラムダ式について詳しく解説します。

シングルキャストデリゲート

シングルキャストデリゲートは、1つのメソッドのみを参照するデリゲートです。

シンプルな構造で、特定のメソッドを呼び出すために使用されます。

// シングルキャストデリゲートの定義
public delegate void SingleCastDelegate(string message);
// メソッドの定義
public static void DisplayMessage(string message)
{
    Console.WriteLine(message);
}
// メイン関数
public static void Main()
{
    SingleCastDelegate del = DisplayMessage; // デリゲートのインスタンス化
    del("シングルキャストデリゲートの例です。"); // メソッドの呼び出し
}

シングルキャストデリゲートの例です。

マルチキャストデリゲート

マルチキャストデリゲートは、複数のメソッドを参照できるデリゲートです。

+=演算子を使用して、複数のメソッドをデリゲートに追加することができます。

// マルチキャストデリゲートの定義
public delegate void MultiCastDelegate(string message);
// メソッドの定義
public static void MethodOne(string message)
{
    Console.WriteLine($"Method One: {message}");
}
public static void MethodTwo(string message)
{
    Console.WriteLine($"Method Two: {message}");
}
// メイン関数
public static void Main()
{
    MultiCastDelegate del = MethodOne; // デリゲートのインスタンス化
    del += MethodTwo; // メソッドの追加
    del("マルチキャストデリゲートの例です。"); // メソッドの呼び出し
}

Method One: マルチキャストデリゲートの例です。
Method Two: マルチキャストデリゲートの例です。

匿名メソッドとデリゲート

匿名メソッドは、名前を持たないメソッドで、デリゲートのインスタンスを作成する際に直接定義することができます。

これにより、簡潔にメソッドを定義できます。

// デリゲートの定義
public delegate void AnonymousDelegate(string message);
// メイン関数
public static void Main()
{
    AnonymousDelegate del = delegate (string message) // 匿名メソッドの定義
    {
        Console.WriteLine(message);
    };
    del("匿名メソッドの例です。"); // メソッドの呼び出し
}

匿名メソッドの例です。

ラムダ式とデリゲートの関係

ラムダ式は、C# 3.0以降で導入された機能で、簡潔にメソッドを定義するための構文です。

デリゲートと組み合わせて使用することができます。

// デリゲートの定義
public delegate void LambdaDelegate(string message);
// メイン関数
public static void Main()
{
    LambdaDelegate del = (message) => // ラムダ式の定義
    {
        Console.WriteLine(message);
    };
    del("ラムダ式の例です。"); // メソッドの呼び出し
}

ラムダ式の例です。

ラムダ式を使用することで、コードがより簡潔になり、可読性が向上します。

デリゲートとラムダ式は、C#プログラミングにおいて非常に強力な組み合わせです。

デリゲートの実践例

デリゲートは、さまざまな場面で活用される強力な機能です。

ここでは、コールバック関数、イベント処理、LINQ、非同期処理におけるデリゲートの実践例を紹介します。

コールバック関数としてのデリゲート

デリゲートは、コールバック関数として使用することができます。

これにより、特定の処理が完了した後に別のメソッドを呼び出すことが可能になります。

// デリゲートの定義
public delegate void CallbackDelegate(string result);
// 処理を行うメソッド
public static void ProcessData(CallbackDelegate callback)
{
    // データ処理の模擬
    string result = "データ処理が完了しました。";
    callback(result); // コールバック関数の呼び出し
}
// メイン関数
public static void Main()
{
    ProcessData((result) => // 匿名メソッドを使用
    {
        Console.WriteLine(result); // 結果を表示
    });
}

データ処理が完了しました。

イベント処理におけるデリゲートの活用

デリゲートは、イベント処理においても重要な役割を果たします。

イベントが発生した際に、特定のメソッドを呼び出すためにデリゲートを使用します。

// デリゲートの定義
public delegate void EventHandlerDelegate(string message);
// イベントを持つクラス
public class Publisher
{
    public event EventHandlerDelegate Notify; // イベントの定義
    public void RaiseEvent()
    {
        Notify?.Invoke("イベントが発生しました！"); // イベントの発生
    }
}
// メイン関数
public static void Main()
{
    Publisher publisher = new Publisher();
    publisher.Notify += (message) => // イベントハンドラ
    {
        Console.WriteLine(message); // メッセージを表示
    };
    publisher.RaiseEvent(); // イベントを発生させる
}

イベントが発生しました！

LINQでのデリゲートの使用

LINQ(Language Integrated Query)では、デリゲートを使用してデータのフィルタリングや変換を行います。

特に、FuncやActionといった組み込みデリゲートがよく使われます。

using System;
using System.Collections.Generic;
using System.Linq;
// メイン関数
public static void Main()
{
    List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
    // LINQを使用して偶数をフィルタリング
    var evenNumbers = numbers.Where(n => n % 2 == 0); // ラムダ式を使用
    foreach (var number in evenNumbers)
    {
        Console.WriteLine(number); // 偶数を表示
    }
}

2
4

非同期処理でのデリゲートの利用

デリゲートは、非同期処理においても活用されます。

特に、BeginInvokeやEndInvokeメソッドを使用して、非同期にメソッドを呼び出すことができます。

// デリゲートの定義
public delegate void AsyncDelegate(string message);
// メソッドの定義
public static void LongRunningProcess(string message)
{
    System.Threading.Thread.Sleep(2000); // 模擬的な長時間処理
    Console.WriteLine(message);
}
// メイン関数
public static void Main()
{
    AsyncDelegate del = LongRunningProcess; // デリゲートのインスタンス化
    del.BeginInvoke("非同期処理が完了しました。", null, null); // 非同期呼び出し
    Console.WriteLine("メイン処理を続行中..."); // メイン処理
    Console.ReadLine(); // 終了を待つ
}

メイン処理を続行中...
非同期処理が完了しました。

このように、デリゲートはさまざまな場面で活用され、プログラムの柔軟性や可読性を向上させる重要な要素です。

デリゲートとイベントの関係

デリゲートとイベントは、C#プログラミングにおいて密接に関連している概念です。

ここでは、イベントの基本、デリゲートとの連携、イベントハンドラとしてのデリゲート、そしてイベントの定義と使用例について解説します。

イベントとは何か

イベントは、特定のアクションが発生したことを通知するための仕組みです。

例えば、ボタンがクリックされたときや、データが更新されたときに発生します。

イベントは、他のクラスやオブジェクトに対して通知を送るために使用されます。

イベントとデリゲートの連携

イベントは、デリゲートを使用して実装されます。

デリゲートは、イベントが発生したときに呼び出されるメソッドのリストを保持します。

これにより、複数のメソッドをイベントに関連付けることができます。

// デリゲートの定義
public delegate void NotifyEventHandler(string message);
// イベントを持つクラス
public class Publisher
{
    public event NotifyEventHandler Notify; // イベントの定義
    public void RaiseEvent()
    {
        Notify?.Invoke("イベントが発生しました！"); // イベントの発生
    }
}

イベントハンドラとしてのデリゲート

デリゲートは、イベントハンドラとして機能します。

イベントが発生したときに、デリゲートが指し示すメソッドが呼び出されます。

これにより、特定のアクションに対して柔軟に反応することができます。

// メイン関数
public static void Main()
{
    Publisher publisher = new Publisher();
    publisher.Notify += (message) => // イベントハンドラ
    {
        Console.WriteLine(message); // メッセージを表示
    };
    publisher.RaiseEvent(); // イベントを発生させる
}

イベントが発生しました！

イベントの定義と使用例

イベントは、クラス内でデリゲートを使用して定義されます。

以下の例では、ボタンがクリックされたときにイベントが発生し、そのイベントに関連付けられたメソッドが呼び出されます。

// デリゲートの定義
public delegate void ButtonClickHandler(string message);
// ボタンを表すクラス
public class Button
{
    public event ButtonClickHandler Click; // イベントの定義
    public void OnClick()
    {
        Click?.Invoke("ボタンがクリックされました！"); // イベントの発生
    }
}
// メイン関数
public static void Main()
{
    Button button = new Button();
    button.Click += (message) => // イベントハンドラ
    {
        Console.WriteLine(message); // メッセージを表示
    };
    button.OnClick(); // ボタンのクリックを模擬
}

ボタンがクリックされました！

このように、デリゲートとイベントは、C#プログラミングにおいて重要な役割を果たし、柔軟で再利用可能なコードを実現するための基盤となります。

イベントを使用することで、特定のアクションに対して適切に反応することが可能になります。

デリゲートの応用例

デリゲートは、C#プログラミングにおいて非常に強力な機能であり、さまざまな応用が可能です。

ここでは、デリゲートチェーン、プラグインシステム、動的なメソッド呼び出し、デザインパターンの実装におけるデリゲートの活用例を紹介します。

デリゲートチェーンの活用

デリゲートチェーンは、複数のメソッドを1つのデリゲートに結合し、順番に呼び出すことができる機能です。

これにより、複数の処理を一度に実行することができます。

// デリゲートの定義
public delegate void ChainDelegate(string message);
// メソッドの定義
public static void MethodOne(string message)
{
    Console.WriteLine($"Method One: {message}");
}
public static void MethodTwo(string message)
{
    Console.WriteLine($"Method Two: {message}");
}
// メイン関数
public static void Main()
{
    ChainDelegate del = MethodOne; // デリゲートのインスタンス化
    del += MethodTwo; // メソッドの追加
    del("デリゲートチェーンの例です。"); // メソッドの呼び出し
}

Method One: デリゲートチェーンの例です。
Method Two: デリゲートチェーンの例です。

デリゲートを使ったプラグインシステムの実装

デリゲートを使用することで、プラグインシステムを簡単に実装できます。

プラグインは、特定のインターフェースを実装したクラスとして定義され、デリゲートを通じて呼び出されます。

// デリゲートの定義
public delegate void PluginDelegate(string message);
// プラグインのインターフェース
public interface IPlugin
{
    void Execute(string message);
}
// プラグインの実装
public class SamplePlugin : IPlugin
{
    public void Execute(string message)
    {
        Console.WriteLine($"プラグイン実行: {message}");
    }
}
// メイン関数
public static void Main()
{
    IPlugin plugin = new SamplePlugin();
    PluginDelegate del = plugin.Execute; // デリゲートのインスタンス化
    del("プラグインシステムの例です。"); // メソッドの呼び出し
}

プラグイン実行: プラグインシステムの例です。

デリゲートを使った動的なメソッド呼び出し

デリゲートを使用することで、動的にメソッドを呼び出すことができます。

これにより、実行時にメソッドを選択することが可能になります。

// デリゲートの定義
public delegate int MathOperation(int a, int b);
// メソッドの定義
public static int Add(int x, int y) => x + y;
public static int Subtract(int x, int y) => x - y;
// メイン関数
public static void Main()
{
    MathOperation operation;
    // 条件に応じてメソッドを選択
    bool useAddition = true;
    operation = useAddition ? Add : Subtract;
    int result = operation(5, 3); // メソッドの呼び出し
    Console.WriteLine(result); // 結果を表示
}

デリゲートを使ったデザインパターンの実装

デリゲートは、デザインパターンの実装にも役立ちます。

例えば、ストラテジーパターンでは、異なるアルゴリズムをデリゲートを通じて切り替えることができます。

// デリゲートの定義
public delegate int StrategyDelegate(int a, int b);
// ストラテジーの実装
public class StrategyContext
{
    private StrategyDelegate _strategy;
    public void SetStrategy(StrategyDelegate strategy)
    {
        _strategy = strategy; // ストラテジーの設定
    }
    public int ExecuteStrategy(int a, int b)
    {
        return _strategy(a, b); // ストラテジーの実行
    }
}
// メイン関数
public static void Main()
{
    StrategyContext context = new StrategyContext();
    context.SetStrategy(Add); // 加算ストラテジーの設定
    Console.WriteLine(context.ExecuteStrategy(5, 3)); // 結果を表示
    context.SetStrategy(Subtract); // 減算ストラテジーの設定
    Console.WriteLine(context.ExecuteStrategy(5, 3)); // 結果を表示
}