型チェック：typeof、GetType、またはis？

多くの人が次のコードを使用するのを見てきました。

Type t = typeof(obj1);
if (t == typeof(int))
    // Some code here

しかし、私もあなたがこれを行うことができることを知っています：

if (obj1.GetType() == typeof(int))
    // Some code here

またはこれ：

if (obj1 is int)
    // Some code here

個人的には最後が一番綺麗だと思いますが、足りないものはありますか？どちらが最適ですか、それとも個人的な好みですか？

すべてが異なります。

• typeof タイプ名（コンパイル時に指定する）を取ります。
• GetType インスタンスのランタイムタイプを取得します。
• is インスタンスが継承ツリーにある場合はtrueを返します。

例

class Animal { } 
class Dog : Animal { }

void PrintTypes(Animal a) { 
    Console.WriteLine(a.GetType() == typeof(Animal)); // false 
    Console.WriteLine(a is Animal);                   // true 
    Console.WriteLine(a.GetType() == typeof(Dog));    // true
    Console.WriteLine(a is Dog);                      // true 
}

Dog spot = new Dog(); 
PrintTypes(spot);

どうtypeof(T)ですか？コンパイル時にも解決されますか？

はい。Tは常に式のタイプです。ジェネリックメソッドは、基本的には適切なタイプのメソッドの集まり全体です。例：

string Foo<T>(T parameter) { return typeof(T).Name; }

Animal probably_a_dog = new Dog();
Dog    definitely_a_dog = new Dog();

Foo(probably_a_dog); // this calls Foo<Animal> and returns "Animal"
Foo<Animal>(probably_a_dog); // this is exactly the same as above
Foo<Dog>(probably_a_dog); // !!! This will not compile. The parameter expects a Dog, you cannot pass in an Animal.

Foo(definitely_a_dog); // this calls Foo<Dog> and returns "Dog"
Foo<Dog>(definitely_a_dog); // this is exactly the same as above.
Foo<Animal>(definitely_a_dog); // this calls Foo<Animal> and returns "Animal". 
Foo((Animal)definitely_a_dog); // this does the same as above, returns "Animal"

コンパイル時にtypeof型を取得したい場合に使用します。実行時に型を取得したい場合に使用します。キャストのように使用するケースはほとんどなく、ほとんどの場合、とにかく変数をキャストすることになります。GetTypeis

考慮していない4番目のオプションがあります（特に、オブジェクトを見つけたタイプにキャストする場合）。それが使用することasです。

Foo foo = obj as Foo;

if (foo != null)
    // your code here

これは1つのキャストのみを使用しますが、このアプローチでは：

if (obj is Foo)
    Foo foo = (Foo)obj;

2が必要です。

アップデート（2020年1月）：

• C＃7+以降、インラインでキャストできるようになったため、「is」アプローチを1つのキャストでも実行できるようになりました。

例：

if(obj is Foo newLocalFoo)
{
    // For example, you can now reference 'newLocalFoo' in this local scope
    Console.WriteLine(newLocalFoo);
}

1。

Type t = typeof(obj1);
if (t == typeof(int))

typeof変数ではなく型でのみ機能するため、これは違法です。obj1は変数であると想定しています。したがって、この方法typeofは静的であり、実行時ではなくコンパイル時に機能します。

2。

if (obj1.GetType() == typeof(int))

これは、あるtrue場合にはobj1、正確にタイプのですint。場合はobj1派生からint、もし条件になりますfalse。

3。

if (obj1 is int)

これはtrue、obj1である場合int、またはと呼ばれるクラスから派生するint場合、またはと呼ばれるインターフェイスを実装する場合intです。

Type t = typeof(obj1);
if (t == typeof(int))
    // Some code here

これはエラーです。C＃のtypeof演算子は、オブジェクトではなく型名のみを使用できます。

if (obj1.GetType() == typeof(int))
    // Some code here

これは機能しますが、おそらく期待どおりではありません。ここで示したように、値の型の場合は許容されますが、参照型の場合は、型が完全に同じ型であり、継承階層の他のものではない場合にのみtrueを返します。例えば：

class Animal{}
class Dog : Animal{}

static void Foo(){
    object o = new Dog();

    if(o.GetType() == typeof(Animal))
        Console.WriteLine("o is an animal");
    Console.WriteLine("o is something else");
}

これは、印刷し"o is something else"の種類があるため、oあるDog、ありませんAnimal。ただし、クラスのIsAssignableFromメソッドを使用すれば、これを機能させることができますType。

if(typeof(Animal).IsAssignableFrom(o.GetType())) // note use of tested type
    Console.WriteLine("o is an animal");

ただし、この手法には依然として大きな問題があります。変数がnullの場合、への呼び出しGetType()はNullReferenceExceptionをスローします。したがって、正しく機能させるには、次のようにします。

if(o != null && typeof(Animal).IsAssignableFrom(o.GetType()))
    Console.WriteLine("o is an animal");

これにより、isキーワードと同等の動作になります。したがって、これが目的の動作である場合は、isより読みやすく効率的なキーワードを使用する必要があります。

if(o is Animal)
    Console.WriteLine("o is an animal");

ただし、ほとんどの場合、isキーワードはまだ望んでいるものではありません。通常、オブジェクトが特定のタイプであることを知るだけでは不十分だからです。通常は、実際にそのオブジェクトをその型のインスタンスとして使用する必要があるため、キャストも必要です。そのため、次のようなコードを記述している可能性があります。

if(o is Animal)
    ((Animal)o).Speak();

ただし、これによりCLRはオブジェクトのタイプを最大2回チェックします。is演算子を満足させるために1回チェックし、o実際にである場合はAnimal、キャストを検証するためにもう一度チェックします。

代わりにこれを行う方が効率的です。

Animal a = o as Animal;
if(a != null)
    a.Speak();

asオペレータは、それが代わりに返し、失敗した場合に例外をスローしませんキャストですnull。このように、CLRはオブジェクトの型を1回だけチェックし、その後は、より効率的なnullチェックを実行するだけで済みます。

ただし、注意してください。多くの人がで罠に陥りasます。例外をスローしないため、一部の人々はそれを「安全な」キャストと見なし、通常のキャストを避けて排他的に使用します。これにより、次のようなエラーが発生します。

(o as Animal).Speak();

この場合、開発者はそれoが常にであることを明確に想定してAnimalおり、その想定が正しい限り、すべてが正常に機能します。しかし、それらが間違っている場合、それらがここで終わるのはNullReferenceExceptionです。通常のキャストでは、InvalidCastException代わりに彼らが問題をより正確に特定していたはずです。

時々、このバグを見つけるのは難しいかもしれません：

class Foo{
    readonly Animal animal;

    public Foo(object o){
        animal = o as Animal;
    }

    public void Interact(){
        animal.Speak();
    }
}

これは、開発者が毎回であることoを明らかに期待している別のケースですAnimalが、asキャストが使用されるコンストラクターでは明らかではありません。フィールドに確実に割り当てられることが期待されるInteractメソッドに到達するまで、それは明らかではありませんanimal。この場合、誤解を招く例外が発生するだけでなく、実際のエラーが発生したときよりもかなり遅くなるまで、例外がスローされません。

要約すれば：

• オブジェクトがなんらかのタイプかどうかを知る必要があるだけなら、を使用してくださいis。

• オブジェクトを特定のタイプのインスタンスとして扱う必要があるが、オブジェクトがそのタイプであるかどうかがわからない場合は、を使用asして確認しnullます。

• オブジェクトを特定のタイプのインスタンスとして扱う必要があり、オブジェクトがそのタイプであることが想定されている場合は、通常のキャストを使用します。

C＃7を使用している場合は、Andrew Hareのすばらしい答えを更新するときがきました。パターンマッチングにより、ifステートメントのコンテキスト内で型指定された変数を提供する便利なショートカットが導入されました。個別の宣言/キャストとチェックは必要ありません。

if (obj1 is int integerValue)
{
    integerValue++;
}

これは、このような単一のキャストにとってはかなり圧倒的に見えますが、ルーチンに入る可能性のある多くの型がある場合は本当に素晴らしいです。以下は、2回キャストを回避するための古い方法です。

Button button = obj1 as Button;
if (button != null)
{
    // do stuff...
    return;
}
TextBox text = obj1 as TextBox;
if (text != null)
{
    // do stuff...
    return;
}
Label label = obj1 as Label;
if (label != null)
{
    // do stuff...
    return;
}
// ... and so on

このコードを可能な限り縮小することに取り組み、同じオブジェクトの重複キャストを回避することは常に私を悩ませてきました。上記は、次のパターンマッチングでうまく圧縮されています。

switch (obj1)
{
    case Button button:
        // do stuff...
        break;
    case TextBox text:
        // do stuff...
        break;
    case Label label:
        // do stuff...
        break;
    // and so on...
}

編集：Palecのコメントに従ってスイッチを使用するように、より長い新しい方法を更新しました。

私が持っていたTypeと比較する-propertyをして使用することができませんでしis（のようなmy_type is _BaseTypetoLookFor）が、私はこれらを使用することができます。

base_type.IsInstanceOfType(derived_object);
base_type.IsAssignableFrom(derived_type);
derived_type.IsSubClassOf(base_type);

お知らせIsInstanceOfTypeおよびIsAssignableFrom戻り値trueと同じタイプを比較するとき、IsSubClassOfが返されますfalse。またIsSubclassOf、他の2つが機能するインターフェイスでは機能しません。（この質問と回答もご覧ください。）

public class Animal {}
public interface ITrainable {}
public class Dog : Animal, ITrainable{}

Animal dog = new Dog();

typeof(Animal).IsInstanceOfType(dog);     // true
typeof(Dog).IsInstanceOfType(dog);        // true
typeof(ITrainable).IsInstanceOfType(dog); // true

typeof(Animal).IsAssignableFrom(dog.GetType());      // true
typeof(Dog).IsAssignableFrom(dog.GetType());         // true
typeof(ITrainable).IsAssignableFrom(dog.GetType()); // true

dog.GetType().IsSubclassOf(typeof(Animal));            // true
dog.GetType().IsSubclassOf(typeof(Dog));               // false
dog.GetType().IsSubclassOf(typeof(ITrainable)); // false

私が好むのは

つまり、を使用している場合は、継承を適切に使用していない可能性があります。

その人：エンティティ、その動物：エンティティを想定します。フィードはエンティティの仮想メソッドです（ニールを幸せにするため）

class Person
{
  // A Person should be able to Feed
  // another Entity, but they way he feeds
  // each is different
  public override void Feed( Entity e )
  {
    if( e is Person )
    {
      // feed me
    }
    else if( e is Animal )
    {
      // ruff
    }
  }
}

むしろ

class Person
{
  public override void Feed( Person p )
  {
    // feed the person
  }
  public override void Feed( Animal a )
  {
    // feed the animal
  }
}

最後の1つは継承も検討していると思います（たとえば、Dog is Animal == true）。これはほとんどの場合に優れています。

それは私が何をしているかに依存します。bool値が必要な場合（たとえば、intにキャストするかどうかを決定する場合）は、を使用しますis。何らかの理由で（たとえば、他のメソッドに渡すために）実際に型が必要な場合は、を使用しますGetType()。

最後のものはより明確で、より明白で、サブタイプもチェックします。他の人はポリモーフィズムをチェックしません。

型のSystem.Typeオブジェクトを取得するために使用されます。typeof式は次の形式を取ります。

System.Type type = typeof(int);

Example:

    public class ExampleClass
    {
       public int sampleMember;
       public void SampleMethod() {}

       static void Main()
       {
          Type t = typeof(ExampleClass);
          // Alternatively, you could use
          // ExampleClass obj = new ExampleClass();
          // Type t = obj.GetType();

          Console.WriteLine("Methods:");
          System.Reflection.MethodInfo[] methodInfo = t.GetMethods();

          foreach (System.Reflection.MethodInfo mInfo in methodInfo)
             Console.WriteLine(mInfo.ToString());

          Console.WriteLine("Members:");
          System.Reflection.MemberInfo[] memberInfo = t.GetMembers();

          foreach (System.Reflection.MemberInfo mInfo in memberInfo)
             Console.WriteLine(mInfo.ToString());
       }
    }
    /*
     Output:
        Methods:
        Void SampleMethod()
        System.String ToString()
        Boolean Equals(System.Object)
        Int32 GetHashCode()
        System.Type GetType()
        Members:
        Void SampleMethod()
        System.String ToString()
        Boolean Equals(System.Object)
        Int32 GetHashCode()
        System.Type GetType()
        Void .ctor()
        Int32 sampleMember
    */

このサンプルでは、​​GetTypeメソッドを使用して、数値計算の結果を格納するために使用される型を決定します。これは、結果の数値のストレージ要件によって異なります。

    class GetTypeTest
    {
        static void Main()
        {
            int radius = 3;
            Console.WriteLine("Area = {0}", radius * radius * Math.PI);
            Console.WriteLine("The type is {0}",
                              (radius * radius * Math.PI).GetType()
            );
        }
    }
    /*
    Output:
    Area = 28.2743338823081
    The type is System.Double
    */

if (c is UserControl) c.Enabled = enable;

C＃では "typeof（）"演算子を使用できますが、System.IOを使用して名前空間を呼び出す必要があります。タイプを確認する場合は、「is」キーワードを使用する必要があります。

パフォーマンステストのtypeof（）とGetType（）：

using System;
namespace ConsoleApplication1
    {
    class Program
    {
        enum TestEnum { E1, E2, E3 }
        static void Main(string[] args)
        {
            {
                var start = DateTime.UtcNow;
                for (var i = 0; i < 1000000000; i++)
                    Test1(TestEnum.E2);
                Console.WriteLine(DateTime.UtcNow - start);
            }
            {
                var start = DateTime.UtcNow;
                for (var i = 0; i < 1000000000; i++)
                    Test2(TestEnum.E2);
                Console.WriteLine(DateTime.UtcNow - start);
            }
            Console.ReadLine();
        }
        static Type Test1<T>(T value) => typeof(T);
        static Type Test2(object value) => value.GetType();
    }
}

デバッグモードの結果：

00:00:08.4096636
00:00:10.8570657

リリースモードでの結果：

00:00:02.3799048
00:00:07.1797128