型パラメーターの制約 (C# プログラミング ガイド)Constraints on type parameters (C# Programming Guide)

• 04/12/2018
• • B
  • o
  • O
  • y
  • S

制約では、型引数に必要な機能をコンパイラに通知します。Constraints inform the compiler about the capabilities a type argument must have. 制約のない型引数は、任意の型にすることができます。Without any constraints, the type argument could be any type. コンパイラは、.NET 型の最終的な基底クラスになる、System.Object のメンバーを見なすことができるだけです。The compiler can only assume the members of System.Object, which is the ultimate base class for any .NET type. 詳細については、「制約を使用する理由」を参照してください。For more information, see Why use constraints. クライアント コードが制約を満たさない型を使用している場合、コンパイラではエラーが発行されます。If client code uses a type that doesn't satisfy a constraint, the compiler issues an error. 制約を指定するには、where コンテキスト キーワードを使用します。Constraints are specified by using the where contextual keyword. 次の表は、さまざまな制約の種類の一覧です。The following table lists the various types of constraints:

制約を使用する理由Why use constraints

制約では、型パラメーターの能力と期待を指定します。Constraints specify the capabilities and expectations of a type parameter. これらの制約を宣言することで、制約型の操作とメソッドの呼び出しを使用できるようになります。Declaring those constraints means you can use the operations and method calls of the constraining type. お使いのジェネリック クラスまたはメソッドが、単純な割り当てや、System.Object でサポートされていない任意のメソッド呼び出しでジェネリック メンバーに対して任意の操作を使用する場合、型パラメーターに制約を適用する必要があります。If your generic class or method uses any operation on the generic members beyond simple assignment or calling any methods not supported by System.Object, you'll have to apply constraints to the type parameter. たとえば、この基底クラスの制約は、この型のオブジェクト、またはこの型から派生したオブジェクトのみを型引数として使用することをコンパイラに指示しています。For example, the base class constraint tells the compiler that only objects of this type or derived from this type will be used as type arguments. コンパイラがこの保証を獲得したら、その型のメソッドをジェネリック クラスで呼び出すことができるようになります。Once the compiler has this guarantee, it can allow methods of that type to be called in the generic class. 基底クラスの制約を適用して GenericList<T> クラス (「ジェネリックの概要」を参照) に追加できる機能を説明するコード例を次に示します。The following code example demonstrates the functionality you can add to the GenericList<T> class (in Introduction to Generics) by applying a base class constraint.

public class Employee
{
    public Employee(string name, int id) => (Name, ID) = (name, id);
    public string Name { get; set; }
    public int ID { get; set; }
}

public class GenericList<T> where T : Employee
{
    private class Node
    {
        public Node(T t) => (Next, Data) = (null, t);

        public Node Next { get; set; }
        public T Data { get; set; }
    }

    private Node head;

    public void AddHead(T t)
    {
        Node n = new Node(t) { Next = head };
        head = n;
    }

    public IEnumerator<T> GetEnumerator()
    {
        Node current = head;

        while (current != null)
        {
            yield return current.Data;
            current = current.Next;
        }
    }

    public T FindFirstOccurrence(string s)
    {
        Node current = head;
        T t = null;

        while (current != null)
        {
            //The constraint enables access to the Name property.
            if (current.Data.Name == s)
            {
                t = current.Data;
                break;
            }
            else
            {
                current = current.Next;
            }
        }
        return t;
    }
}

この制約ではジェネリック クラスで Employee.Name プロパティを使用できるようにします。The constraint enables the generic class to use the Employee.Name property. 制約では、型 T のすべての項目が、Employee オブジェクトまたは Employee から継承するオブジェクトのいずれかになることが保証されることを指定します。The constraint specifies that all items of type T are guaranteed to be either an Employee object or an object that inherits from Employee.

同じ型パラメーターに複数の制約を適用できます。また、制約自体をジェネリック型にすることもできます。次に例を示します。Multiple constraints can be applied to the same type parameter, and the constraints themselves can be generic types, as follows:

class EmployeeList<T> where T : Employee, IEmployee, System.IComparable<T>, new()
{
    // ...
}

where T : class 制約を適用する場合は、型パラメーターに == および != 演算子を使用しないでください。これらの演算子でテストされるのは、値の等価性ではなく、参照 ID についてのみです。When applying the where T : class constraint, avoid the == and != operators on the type parameter because these operators will test for reference identity only, not for value equality. これらの演算子が、引数として使用されている型内でオーバーロードされている場合でも、この動作が発生します。This behavior occurs even if these operators are overloaded in a type that is used as an argument. この点を説明するコードを次に示します。String クラスが == 演算子をオーバーロードしている場合でも、出力は false です。The following code illustrates this point; the output is false even though the String class overloads the == operator.

public static void OpEqualsTest<T>(T s, T t) where T : class
{
    System.Console.WriteLine(s == t);
}

private static void TestStringEquality()
{
    string s1 = "target";
    System.Text.StringBuilder sb = new System.Text.StringBuilder("target");
    string s2 = sb.ToString();
    OpEqualsTest<string>(s1, s2);
}

コンパイラは T がコンパイル時に参照型であることしか認識しておらず、すべての参照型で有効な既定の演算子を使用する必要があります。The compiler only knows that T is a reference type at compile time and must use the default operators that are valid for all reference types. 値の等価性をテストする必要がある場合は、where T : IEquatable<T> または where T : IComparable<T> 制約も適用し、ジェネリック クラスの制約に使用されるすべてのクラスでそのインターフェイスを実装することをお勧めします。If you must test for value equality, the recommended way is to also apply the where T : IEquatable<T> or where T : IComparable<T> constraint and implement the interface in any class that will be used to construct the generic class.

複数のパラメーターを制約するConstraining multiple parameters

複数のパラメーターに制約を適用できます。また、複数の制約を 1 つのパラメーターに適用することができます。次に例を示します。You can apply constraints to multiple parameters, and multiple constraints to a single parameter, as shown in the following example:

class Base { }
class Test<T, U>
    where U : struct
    where T : Base, new()
{ }

非バインド型パラメーターUnbounded type parameters

パブリック クラス SampleClass<T>{} の T など、制約がない型パラメーターは、非バインド型パラメーターと呼ばれます。Type parameters that have no constraints, such as T in public class SampleClass<T>{}, are called unbounded type parameters. 非バインド型パラメーターには次の規則があります。Unbounded type parameters have the following rules:

• != および == 演算子は使用できません。これは、具象型引数によってこれらの演算子がサポートされるという保証がないためです。The != and == operators can't be used because there's no guarantee that the concrete type argument will support these operators.
• これらの演算子は System.Object との間で相互に変換できます。また、任意のインターフェイス型に明示的に変換できます。They can be converted to and from System.Object or explicitly converted to any interface type.
• これらは null と比較することができます。You can compare them to null. 非バインド型パラメーターと null を比較し、その型引数が値の型の場合、比較結果として常に false が返されます。If an unbounded parameter is compared to null, the comparison will always return false if the type argument is a value type.

制約としての型パラメーターType parameters as constraints

制約としてジェネリック型パラメーターを使用する方法は、独自の型パラメーターがあるメンバー関数が、含まれる型の型パラメーターにそのパラメーターを制約する必要がある場合に便利です。次に例を示します。The use of a generic type parameter as a constraint is useful when a member function with its own type parameter has to constrain that parameter to the type parameter of the containing type, as shown in the following example:

public class List<T>
{
    public void Add<U>(List<U> items) where U : T {/*...*/}
}

前の例の T は、Add メソッドのコンテキストでは型の制約ですが、List クラスのコンテキストでは非バインド型パラメーターです。In the previous example, T is a type constraint in the context of the Add method, and an unbounded type parameter in the context of the List class.

型パラメーターは、ジェネリック クラス定義の制約としても使用できます。Type parameters can also be used as constraints in generic class definitions. 型パラメーターは、他の型パラメーターと共に山かっこ内で宣言する必要があります。The type parameter must be declared within the angle brackets together with any other type parameters:

//Type parameter V is used as a type constraint.
public class SampleClass<T, U, V> where T : V { }

ジェネリック クラスで制約として型パラメーターを使用する方法が便利なのは、限られた場合のみです。コンパイラでは、System.Object から派生したことを除き、型パラメーターに関して何も仮定できないためです。The usefulness of type parameters as constraints with generic classes is limited because the compiler can assume nothing about the type parameter except that it derives from System.Object. 2 つの型パラメーター間に継承関係を適用するシナリオには、ジェネリック クラスの制約として型パラメーターを使用してください。Use type parameters as constraints on generic classes in scenarios in which you want to enforce an inheritance relationship between two type parameters.

NotNull 制約NotNull constraint

C# 8.0 以降の null 許容コンテキストでは、notnull 制約を使用して、型引数が null 非許容値型または null 非許容参照型である必要があることを指定できます。Beginning with C# 8.0 in a nullable context, you can use the notnull constraint to specify that the type argument must be a non-nullable value type or non-nullable reference type. notnull 制約は、nullable enable コンテキストでのみ使用できます。The notnull constraint can only be used in a nullable enable context. null 許容が未指定のコンテキストに notnull 制約を追加すると、コンパイラにより警告が生成されます。The compiler generates a warning if you add the notnull constraint in a nullable oblivious context.

他の制約とは異なり、型引数が notnull 制約に違反すると、そのコードが nullable enable コンテキストでコンパイルされるときにコンパイラにより警告が生成されます。Unlike other constraints, when a type argument violates the notnull constraint, the compiler generates a warning when that code is compiled in a nullable enable context. null 許容が未指定のコンテキストでコードがコンパイルされた場合、コンパイラによって警告やエラーは生成されません。If the code is compiled in a nullable oblivious context, the compiler doesn't generate any warnings or errors.

C# 8.0 以降の null 許容コンテキストでは、class 制約を使用して、型引数が null 非許容型である必要があることを指定できます。Beginning with C# 8.0 in a nullable context, the class constraint specifies that the type argument must be a non-nullable reference type. null 許容コンテキストでは、型パラメーターが null 許容参照型である場合、コンパイラによって警告が生成されます。In a nullable context, when a type parameter is a nullable reference type, the compiler generates a warning.

アンマネージド制約Unmanaged constraint

C# 7.3 以降、unmanaged 制約を指定して、型パラメーターが null 非許容でアンマネージド型である必要があることを指定できます。Beginning with C# 7.3, you can use the unmanaged constraint to specify that the type parameter must be a non-nullable unmanaged type. unmanaged 制約では、次の例のように、メモリのブロックとして操作できる型を処理する再利用可能なルーチンを記述できます。The unmanaged constraint enables you to write reusable routines to work with types that can be manipulated as blocks of memory, as shown in the following example:

unsafe public static byte[] ToByteArray<T>(this T argument) where T : unmanaged
{
    var size = sizeof(T);
    var result = new Byte[size];
    Byte* p = (byte*)&argument;
    for (var i = 0; i < size; i++)
        result[i] = *p++;
    return result;
}

ビルトイン型ではない型で sizeof 演算子を使用するため、先行するメソッドは unsafe コンテキストでコンパイルされる必要があります。The preceding method must be compiled in an unsafe context because it uses the sizeof operator on a type not known to be a built-in type. unmanaged 制約なしで、sizeof 演算子を使用することはできません。Without the unmanaged constraint, the sizeof operator is unavailable.

unmanaged 制約は struct 制約を意味するため、これと組み合わせることはできません。The unmanaged constraint implies the struct constraint and can't be combined with it. struct 制約は new() 制約を意味するため、unmanaged 制約を new() 制約と組み合わせることもできません。Because the struct constraint implies the new() constraint, the unmanaged constraint can't be combined with the new() constraint as well.

制約をデリゲートするDelegate constraints

また、C# 7.3 以降、基底クラスの制約として System.Delegate または System.MulticastDelegate を使用することもできます。Also beginning with C# 7.3, you can use System.Delegate or System.MulticastDelegate as a base class constraint. CLR では常にこの制約を許可していますが、C# 言語では許可されていません。The CLR always allowed this constraint, but the C# language disallowed it. System.Delegate 制約では、タイプ セーフな方法でデリゲートを処理するコードを記述できます。The System.Delegate constraint enables you to write code that works with delegates in a type-safe manner. 次のコードでは、2 つのデリゲートが同じ型である場合にそれらを組み合わせる拡張メソッドを定義します。The following code defines an extension method that combines two delegates provided they're the same type:

public static TDelegate TypeSafeCombine<TDelegate>(this TDelegate source, TDelegate target)
    where TDelegate : System.Delegate
    => Delegate.Combine(source, target) as TDelegate;

上述のメソッドを使用して、同じ型のデリゲートを組み合わせることができます。You can use the above method to combine delegates that are the same type:

Action first = () => Console.WriteLine("this");
Action second = () => Console.WriteLine("that");

var combined = first.TypeSafeCombine(second);
combined();

Func<bool> test = () => true;
// Combine signature ensures combined delegates must
// have the same type.
//var badCombined = first.TypeSafeCombine(test);

最後の行のコメントを解除した場合、コンパイルされません。If you uncomment the last line, it won't compile. first と test は両方ともデリゲート型ですが、これらは異なるデリゲート型です。Both first and test are delegate types, but they're different delegate types.

列挙の制約Enum constraints

C# 7.3 以降、基底クラスの制約として System.Enum 型を指定することもできます。Beginning in C# 7.3, you can also specify the System.Enum type as a base class constraint. CLR では常にこの制約を許可していますが、C# 言語では許可されていません。The CLR always allowed this constraint, but the C# language disallowed it. System.Enum を使用するジェネリックは、System.Enum の静的メソッドの使用から結果をキャッシュするために、タイプ セーフのプログラミングを提供します。Generics using System.Enum provide type-safe programming to cache results from using the static methods in System.Enum. 次の例では、列挙型の有効な値をすべて見つけて、それらの値をその文字列表記にマップするディクショナリをビルドします。The following sample finds all the valid values for an enum type, and then builds a dictionary that maps those values to its string representation.

public static Dictionary<int, string> EnumNamedValues<T>() where T : System.Enum
{
    var result = new Dictionary<int, string>();
    var values = Enum.GetValues(typeof(T));

    foreach (int item in values)
        result.Add(item, Enum.GetName(typeof(T), item));
    return result;
}

Enum.GetValues と Enum.GetName ではリフレクションが使用されます。これは、パフォーマンスに影響を与えます。Enum.GetValues and Enum.GetName use reflection, which has performance implications. リフレクションを必要とする呼び出しを繰り返すのではなく、EnumNamedValues を呼び出してキャッシュおよび再利用されるコレクションを作成できます。You can call EnumNamedValues to build a collection that is cached and reused rather than repeating the calls that require reflection.

次の例で示すように、このメソッドを使用して、列挙を作成し、その値と名前のディクショナリをビルドできます。You could use it as shown in the following sample to create an enum and build a dictionary of its values and names:

enum Rainbow
{
    Red,
    Orange,
    Yellow,
    Green,
    Blue,
    Indigo,
    Violet
}

var map = EnumNamedValues<Rainbow>();

foreach (var pair in map)
    Console.WriteLine($"{pair.Key}:\t{pair.Value}");

関連項目See also

• System.Collections.Generic
• C# プログラミング ガイドC# Programming Guide
• ジェネリックの概要Introduction to Generics
• ジェネリック クラスGeneric Classes
• new 制約new Constraint