型テストとキャスト演算子 (C# リファレンス)Type-testing and cast operators (C# reference)

次の演算子を使って、型のチェックまたは型の変換を実行できます。You can use the following operators to perform type checking or type conversion:

  • is 演算子: 式のランタイム型と指定された型の間に互換性があるかどうかを確認しますis operator: to check if the runtime type of an expression is compatible with a given type
  • as 演算子: 式のランタイム型と指定された型の間に互換性がある場合、式を指定された型に明示的に変換しますas operator: to explicitly convert an expression to a given type if its runtime type is compatible with that type
  • キャスト演算子 (): 明示的な変換を実行しますcast operator (): to perform an explicit conversion
  • typeof 演算子: 型の System.Type インスタンスを取得しますtypeof operator: to obtain the System.Type instance for a type

is 演算子is operator

is 演算子では、式の結果のランタイム型と指定された型の間に互換性があるかどうかが調べられます。The is operator checks if the runtime type of an expression result is compatible with a given type. C# 7.0 以降の is 演算子では、パターンに対する式の結果のテストも行われます。Beginning with C# 7.0, the is operator also tests an expression result against a pattern.

is 型テスト演算子を使用する式の形式は次のとおりですThe expression with the type-testing is operator has the following form

E is T

E は値を返す式であり、T は型または型パラメーターの名前です。where E is an expression that returns a value and T is the name of a type or a type parameter. E を匿名メソッドまたはラムダ式にすることはできません。E cannot be an anonymous method or a lambda expression.

E is T では、true の結果が null ではなく、参照変換、ボックス化変換、またはボックス化解除変換によって型 E に変換できる場合は T が返され、それ以外の場合は false が返されます。The E is T expression returns true if the result of E is non-null and can be converted to type T by a reference conversion, a boxing conversion, or an unboxing conversion; otherwise, it returns false. is 演算子では、ユーザー定義変換は考慮されません。The is operator doesn't consider user-defined conversions.

次の例で示す is 演算子では、式の結果のランタイム型が指定された型から派生する場合、つまり型の間に参照変換が存在する場合は、true が返されます。The following example demonstrates that the is operator returns true if the runtime type of an expression result derives from a given type, that is, there exists a reference conversion between types:

public class Base { }

public class Derived : Base { }

public static class IsOperatorExample
{
    public static void Main()
    {
        object b = new Base();
        Console.WriteLine(b is Base);  // output: True
        Console.WriteLine(b is Derived);  // output: False

        object d = new Derived();
        Console.WriteLine(d is Base);  // output: True
        Console.WriteLine(d is Derived); // output: True
    }
}

次の例で示す is 演算子では、ボックス化変換とボックス化解除変換は考慮されますが、数値変換は考慮されません。The next example shows that the is operator takes into account boxing and unboxing conversions but doesn't consider numeric conversions:

int i = 27;
Console.WriteLine(i is System.IFormattable);  // output: True

object iBoxed = i;
Console.WriteLine(iBoxed is int);  // output: True
Console.WriteLine(iBoxed is long);  // output: False

C# の変換については、C# 言語仕様の「Conversions (変換)」の章をご覧ください。For information about C# conversions, see the Conversions chapter of the C# language specification.

パターン マッチングを使用する型テストType testing with pattern matching

C# 7.0 以降の is 演算子では、パターンに対する式の結果のテストも行われます。Beginning with C# 7.0, the is operator also tests an expression result against a pattern. 具体的には、次の形式の型パターンがサポートされます。In particular, it supports the type pattern in the following form:

E is T v

E は値を返す式、T は型または型パラメーターの名前、vT 型の新しいローカル変数です。where E is an expression that returns a value, T is the name of a type or a type parameter, and v is a new local variable of type T. E の結果が null ではなく、参照変換、ボックス化変換、またはボックス化解除変換によって T に変換できる場合、式 E is T v から true が返され、E の結果の変換された値が変数 v に代入されます。If the result of E is non-null and can be converted to T by a reference, boxing, or unboxing conversion, the E is T v expression returns true and the converted value of the result of E is assigned to variable v.

次の例では、型パターンによる is 演算子の使用方法を示します。The following example demonstrates the usage of the is operator with the type pattern:

int i = 23;
object iBoxed = i;
int? jNullable = 7;
if (iBoxed is int a && jNullable is int b)
{
    Console.WriteLine(a + b);  // output 30
}

型パターンおよび他のサポートされるパターンについて詳しくは、「is を使用したパターン マッチング」をご覧ください。For more information about the type pattern and other supported patterns, see Pattern matching with is.

as 演算子as operator

as 演算子では、式の結果が、指定された参照型または null 許容値型に明示的に変換されます。The as operator explicitly converts the result of an expression to a given reference or nullable value type. 変換できない場合、as 演算子からは null が返されます。If the conversion is not possible, the as operator returns null. キャスト演算子 () とは異なり、as 演算子では例外はスローされません。Unlike the cast operator (), the as operator never throws an exception.

式の形式は次のとおりですThe expression of the form

E as T

E は値を返す式であり、T は型または型パラメーターの名前です。次の式と同じ結果が生成されますwhere E is an expression that returns a value and T is the name of a type or a type parameter, produces the same result as

E is T ? (T)(E) : (T)null

ただし、E が評価されるのは 1 回だけです。except that E is only evaluated once.

as 演算子では、参照、null 許容、ボックス化、およびボックス化解除の各変換だけが考慮されます。The as operator considers only reference, nullable, boxing, and unboxing conversions. as 演算子を使って、ユーザー定義の変換を実行することはできません。You cannot use the as operator to perform a user-defined conversion. それを行うには、キャスト演算子 () を使います。To do that, use the cast operator ().

as 演算子の使用例を次に示します。The following example demonstrates the usage of the as operator:

IEnumerable<int> numbers = new[] { 10, 20, 30 };
IList<int> indexable = numbers as IList<int>;
if (indexable != null)
{
    Console.WriteLine(indexable[0] + indexable[indexable.Count - 1]);  // output: 40
}

注意

上の例のように、変換が成功したかどうかを確認するには、as 式の結果を null と比較する必要があります。As the preceding example shows, you need to compare the result of the as expression with null to check if the conversion is successful. C# 7.0 以降では、変換が成功するかどうかのテストと、成功する場合の新しい変数への結果の代入の両方を、is 演算子を使って行うことができます。Beginning with C# 7.0, you can use the is operator both to test if the conversion succeeds and, if it succeeds, assign its result to a new variable.

キャスト演算子 ()Cast operator ()

(T)E という形式のキャスト式では、式 E の結果が、型 T に明示的に変換されます。A cast expression of the form (T)E performs an explicit conversion of the result of expression E to type T. E から型 T への明示的な変換が存在しない場合は、コンパイル時エラーが発生します。If no explicit conversion exists from the type of E to type T, a compile-time error occurs. 実行時に、明示的な変換が成功せず、キャスト式で例外がスローされる可能性があります。At run time, an explicit conversion might not succeed and a cast expression might throw an exception.

次の例では、数値と参照の明示的な変換を示します。The following example demonstrates explicit numeric and reference conversions:

double x = 1234.7;
int a = (int)x;
Console.WriteLine(a);   // output: 1234

IEnumerable<int> numbers = new int[] { 10, 20, 30 };
IList<int> list = (IList<int>)numbers;
Console.WriteLine(list.Count);  // output: 3
Console.WriteLine(list[1]);  // output: 20

サポートされる明示的な変換については、C# 言語仕様の「Explicit conversions (明示的な変換)」セクションをご覧ください。For information about supported explicit conversions, see the Explicit conversions section of the C# language specification. カスタムの明示的または暗黙的な型変換を定義する方法については、「User-defined conversion operators」(ユーザー定義の変換演算子) を参照してください。For information about how to define a custom explicit or implicit type conversion, see User-defined conversion operators.

() の他の使用方法Other usages of ()

かっこは、メソッドまたはデリゲートを呼び出すときにも使います。You also use parentheses to call a method or invoke a delegate.

他には、式に含まれる演算を評価する順序を調整する場合にもかっこを使います。Other use of parentheses is to adjust the order in which to evaluate operations in an expression. 詳細については、C# 演算子に関するページを参照してください。For more information, see C# operators.

typeof 演算子typeof operator

typeof 演算子では、型の System.Type インスタンスが取得されます。The typeof operator obtains the System.Type instance for a type. typeof 演算子への引数では、次の例で示すように、型または型パラメーターの名前を指定する必要があります。The argument to the typeof operator must be the name of a type or a type parameter, as the following example shows:

void PrintType<T>() => Console.WriteLine(typeof(T));

Console.WriteLine(typeof(List<string>));
PrintType<int>();
PrintType<System.Int32>();
PrintType<Dictionary<int, char>>();
// Output:
// System.Collections.Generic.List`1[System.String]
// System.Int32
// System.Int32
// System.Collections.Generic.Dictionary`2[System.Int32,System.Char]

バインドされていないジェネリック型で typeof 演算子を使うこともできます。You also can use the typeof operator with unbound generic types. バインドされていないジェネリック型の名前には、適切な数のコンマが含まれる必要があります。これは、型パラメーターの数より 1 だけ少ない数です。The name of an unbound generic type must contain the appropriate number of commas, which is one less than the number of type parameters. 次の例では、バインドされていないジェネリック型での typeof 演算子の使用方法を示します。The following example shows the usage of the typeof operator with an unbound generic type:

Console.WriteLine(typeof(Dictionary<,>));
// Output:
// System.Collections.Generic.Dictionary`2[TKey,TValue]

式を typeof 演算子の引数にすることはできません。An expression cannot be an argument of the typeof operator. 式の結果のランタイム型に対する System.Type インスタンスを取得するには、Object.GetType メソッドを使います。To get the System.Type instance for the runtime type of an expression result, use the Object.GetType method.

typeof 演算子での型テストType testing with the typeof operator

typeof 演算子を使って、式の結果のランタイム型が指定された型と完全に一致するかどうかを調べます。Use the typeof operator to check if the runtime type of the expression result exactly matches a given type. 次の例では、typeof 演算子と is 演算子で実行される型チェックの違いを示します。The following example demonstrates the difference between type checking performed with the typeof operator and the is operator:

public class Animal { }

public class Giraffe : Animal { }

public static class TypeOfExample
{
    public static void Main()
    {
        object b = new Giraffe();
        Console.WriteLine(b is Animal);  // output: True
        Console.WriteLine(b.GetType() == typeof(Animal));  // output: False

        Console.WriteLine(b is Giraffe);  // output: True
        Console.WriteLine(b.GetType() == typeof(Giraffe));  // output: True
    }
}

演算子のオーバーロード可/不可Operator overloadability

isas、および typeof の各演算子はオーバーロードできません。The is, as, and typeof operators cannot be overloaded.

ユーザー定義型で () 演算子をオーバーロードすることはできませんが、キャスト式で実行できるカスタム型変換を定義することはできます。A user-defined type cannot overload the () operator, but can define custom type conversions that can be performed by a cast expression. 詳細については、ユーザー定義の変換演算子 に関するページを参照してください。For more information, see User-defined conversion operators.

C# 言語仕様C# language specification

詳細については、「C# 言語仕様」の次のセクションを参照してください。For more information, see the following sections of the C# language specification:

参照See also