拡張メソッド (C# プログラミングガイド)

[アーティクル]
03/12/2013

拡張メソッドを使用すると、新規の派生型の作成、再コンパイル、または元の型の変更を行うことなく既存の型にメソッドを "追加" できます。拡張メソッドは特別な種類の静的メソッドですが、拡張された型のインスタンスメソッドのように呼び出します。C# および Visual Basic で作成されたクライアントコードの場合は、拡張メソッドの呼び出しと、型で実際に定義されたメソッドの呼び出しに明確な違いはありません。

共通の拡張メソッドは System.Collections.Generic.IEnumerable<T> の既存の System.Collections.IEnumerable と型でクエリ機能を追加 LINQ の標準クエリ演算子です。標準クエリ演算子を使用するには、最初に using System.Linq のディレクティブを使用して、が存在します。IEnumerable<T> を実装するすべての型は、GroupBy、OrderBy、Average などのインスタンスメソッドを持っていると考えられます。List<T>、Array などの IEnumerable<T> 型のインスタンスの後に "ドット" を入力すると、IntelliSense により、ステートメントの入力候補としてこれらの追加メソッドが表示されます。

整数の配列において、標準クエリ演算子の OrderBy メソッドを呼び出す方法を次の例に示します。かっこ内の式はラムダ式です。標準クエリ演算子の多くはパラメーターとしてラムダ式を受け取りますが、拡張メソッドでは、これは必須ではありません。詳細については、「ラムダ式 (C# プログラミングガイド)」を参照してください。

class ExtensionMethods2    
{

    static void Main()
    {            
        int[] ints = { 10, 45, 15, 39, 21, 26 };
        var result = ints.OrderBy(g => g);
        foreach (var i in result)
        {
            System.Console.Write(i + " ");
        }           
    }        
}
//Output: 10 15 21 26 39 45

拡張メソッドは、静的メソッドとして定義しますが、インスタンスメソッドの構文を使用して呼び出します。最初のパラメーターでは、メソッドが操作する型を指定します。このパラメーターの前には this 修飾子を付加します。using ディレクティブを使用して名前空間をソースコードに明示的にインポートした場合、拡張メソッドはそのスコープでのみ有効です。

System.String クラスに対して拡張メソッドを定義する例を次に示します。入れ子になっていない、非ジェネリックの静的クラス内で定義されていることに注意してください。

namespace ExtensionMethods
{
    public static class MyExtensions
    {
        public static int WordCount(this String str)
        {
            return str.Split(new char[] { ' ', '.', '?' }, 
                             StringSplitOptions.RemoveEmptyEntries).Length;
        }
    }   
}

この using ディレクティブを使用することで、WordCount 拡張メソッドをスコープに取り込むことができます。

using ExtensionMethods;

また、この構文を使用することで、アプリケーションから呼び出すことができます。

string s = "Hello Extension Methods";
int i = s.WordCount();

コードでは、インスタンスメソッドの構文を使用して拡張メソッドを呼び出します。ただし、コンパイラが生成する中間言語 (IL: Intermediate Language) により、コードは静的メソッドに対する呼び出しに変換されます。したがって、カプセル化の原則には実質的に違反していません。実際に、拡張メソッドは、それらが拡張している型のプライベート変数にはアクセスできません。

詳細については、「方法 : カスタム拡張メソッドを実装して呼び出す (C# プログラミングガイド)」を参照してください。

一般的には、独自の拡張メソッドを実装するよりも、拡張メソッドを呼び出すことの方がはるかに多くなります。拡張メソッドは、インスタンスメソッドの構文を使用して呼び出すので、特別な知識がなくてもクライアントコードからそれらを使用できます。メソッドが定義されている名前空間に関する using ディレクティブを追加するだけで、特定の型の拡張メソッドを使用できるようになります。たとえば、標準クエリ演算子を使用するには、次の using ディレクティブをコードに追加します。

using System.Linq;

場合によっては、System.Core.dll への参照も追加する必要があります。ほとんどの IEnumerable<T> 型で利用できる追加メソッドとして、標準クエリ演算子が IntelliSense により表示されるようになりました。

[!メモ]

String の場合、IntelliSense により標準クエリ演算子は表示されませんが、利用できます。

コンパイル時の拡張メソッドのバインディング

拡張メソッドを使用してクラスまたはインターフェイスを拡張することはできますが、これらをオーバーライドすることはできません。インターフェイスメソッドまたはクラスメソッドと同じ名前およびシグネチャを持つ拡張メソッドは決して呼び出されません。コンパイル時に、型自体で定義されているインスタンスメソッドよりも低い優先順位が拡張メソッドには必ず設定されます。つまり、型に Process(int i) という名前のメソッドがあり、これと同じシグネチャの拡張メソッドがある場合、コンパイラは必ずインスタンスメソッドにバインドします。コンパイラは、メソッド呼び出しを検出すると、最初に型のインスタンスメソッドから一致するものを探します。一致するものが見つからない場合、型に対して定義されている拡張メソッドを検索し、見つかった最初の拡張メソッドにバインドします。次の例は、コンパイラが拡張メソッドとインスタンスメソッドのどちらにバインドするかを決定する方法を示しています。

使用例

次の例は、C# のコンパイラがメソッド呼び出しを型のインスタンスメソッドにバインドするか、拡張メソッドにバインドするかを決定するときに従う規則を示しています。Extensions 静的クラスには、IMyInterface を実装する型に対して定義された拡張メソッドが含まれています。A、B、および C の各クラスはすべてこのインターフェイスを実装しています。

MethodB 拡張メソッドは、その名前とシグネチャがクラスにより既に実装されているメソッドと完全に一致しているため、呼び出されることはありません。

コンパイラは、一致するシグネチャを持つインスタンスメソッドを検出できない場合、一致する拡張メソッド (存在する場合) にバインドします。

// Define an interface named IMyInterface.
namespace DefineIMyInterface
{
    using System;

    public interface IMyInterface
    {
        // Any class that implements IMyInterface must define a method
        // that matches the following signature.
        void MethodB();
    }
}


// Define extension methods for IMyInterface.
namespace Extensions
{
    using System;
    using DefineIMyInterface;

    // The following extension methods can be accessed by instances of any 
    // class that implements IMyInterface.
    public static class Extension
    {
        public static void MethodA(this IMyInterface myInterface, int i)
        {
            Console.WriteLine
                ("Extension.MethodA(this IMyInterface myInterface, int i)");
        }

        public static void MethodA(this IMyInterface myInterface, string s)
        {
            Console.WriteLine
                ("Extension.MethodA(this IMyInterface myInterface, string s)");
        }

        // This method is never called in ExtensionMethodsDemo1, because each 
        // of the three classes A, B, and C implements a method named MethodB
        // that has a matching signature.
        public static void MethodB(this IMyInterface myInterface)
        {
            Console.WriteLine
                ("Extension.MethodB(this IMyInterface myInterface)");
        }
    }
}


// Define three classes that implement IMyInterface, and then use them to test
// the extension methods.
namespace ExtensionMethodsDemo1
{
    using System;
    using Extensions;
    using DefineIMyInterface;

    class A : IMyInterface
    {
        public void MethodB() { Console.WriteLine("A.MethodB()"); }
    }

    class B : IMyInterface
    {
        public void MethodB() { Console.WriteLine("B.MethodB()"); }
        public void MethodA(int i) { Console.WriteLine("B.MethodA(int i)"); }
    }

    class C : IMyInterface
    {
        public void MethodB() { Console.WriteLine("C.MethodB()"); }
        public void MethodA(object obj)
        {
            Console.WriteLine("C.MethodA(object obj)");
        }
    }

    class ExtMethodDemo
    {
        static void Main(string[] args)
        {
            // Declare an instance of class A, class B, and class C.
            A a = new A();
            B b = new B();
            C c = new C();

            // For a, b, and c, call the following methods:
            //      -- MethodA with an int argument
            //      -- MethodA with a string argument
            //      -- MethodB with no argument.

            // A contains no MethodA, so each call to MethodA resolves to 
            // the extension method that has a matching signature.
            a.MethodA(1);           // Extension.MethodA(object, int)
            a.MethodA("hello");     // Extension.MethodA(object, string)

            // A has a method that matches the signature of the following call
            // to MethodB.
            a.MethodB();            // A.MethodB()

            // B has methods that match the signatures of the following
            // method calls.
            b.MethodA(1);           // B.MethodA(int)
            b.MethodB();            // B.MethodB()

            // B has no matching method for the following call, but 
            // class Extension does.
            b.MethodA("hello");     // Extension.MethodA(object, string)

            // C contains an instance method that matches each of the following
            // method calls.
            c.MethodA(1);           // C.MethodA(object)
            c.MethodA("hello");     // C.MethodA(object)
            c.MethodB();            // C.MethodB()
        }
    }
}
/* Output:
    Extension.MethodA(this IMyInterface myInterface, int i)
    Extension.MethodA(this IMyInterface myInterface, string s)
    A.MethodB()
    B.MethodA(int i)
    B.MethodB()
    Extension.MethodA(this IMyInterface myInterface, string s)
    C.MethodA(object obj)
    C.MethodA(object obj)
    C.MethodB()
 */

一般的なガイドライン

拡張メソッドは、一般的に、必要な場合に限り注意して実装することをお勧めします。クライアントコードで既存の型を拡張する必要がある場合、可能であれば既存の型から派生した新しい型を作成することで行ってください。詳細については、「継承 (C# プログラミングガイド)」を参照してください。

拡張メソッドを使用して、変更できないソースコードのある型を拡張する場合、型の実装の変更により拡張メソッドが破損するというリスクを負うことになります。

特定の型の拡張メソッドを実装する場合、followingpoints に注意してください:

拡張メソッドが型で定義されているメソッドと同じシグネチャを持つ場合、その拡張メソッドは呼び出されません。
拡張メソッドは名前空間レベルでスコープ内に取り込まれます。たとえば、Extensions という名前の単一の名前空間に、拡張メソッドを含む複数の静的クラスがある場合、using Extensions; ディレクティブによって、それらのすべての拡張メソッドがスコープ内に取り込まれます。

実装したクラスライブラリでは、アセンブリのバージョン番号をインクリメントすることを避けるために、拡張メソッドを使用する必要があります。、ソース・コードを所有するライブラリの重要な機能を追加する場合は、アセンブリのバージョン管理のための .NET Framework の標準的なガイドラインに従う必要があります。詳細については、「アセンブリのバージョン管理」を参照してください。