Pemeriksaan Ketik: typeof, GetType, atau?

Semuanya berbeda.

• typeof mengambil nama tipe (yang Anda tentukan pada waktu kompilasi).
• GetType mendapatkan tipe runtime dari sebuah instance.
• is mengembalikan nilai true jika sebuah instance ada di pohon warisan.

Contoh

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);

Bagaimana dengan typeof(T)? Apakah ini juga teratasi pada waktu kompilasi?

Ya. T selalu sesuai dengan jenis ekspresinya. Ingat, metode generik pada dasarnya adalah sekumpulan metode dengan tipe yang sesuai. Contoh:

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"

Gunakan typeof bila Anda ingin mendapatkan tipenya pada waktu kompilasi. Gunakan GetType bila Anda ingin mendapatkan tipe pada waktu eksekusi. Jarang ada kasus untuk menggunakan is seperti halnya cast dan, dalam banyak kasus, Anda tetap melakukan casting variabel.

Ada opsi keempat yang belum Anda pertimbangkan (terutama jika Anda juga akan melemparkan objek ke tipe yang Anda temukan); yaitu menggunakan as.

Foo foo = obj as Foo;

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

Ini hanya menggunakan satu pemeran sedangkan pendekatan ini:

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

membutuhkan dua.

Pembaruan (Jan 2020):

• Mulai C# 7+, Anda kini dapat melakukan cast inline, sehingga pendekatan 'is' kini dapat dilakukan dalam satu cast juga.

Contoh:

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))

Ini ilegal, karena typeof hanya bekerja pada tipe, bukan pada variabel. Saya berasumsi obj1 adalah variabel. Jadi, dengan cara ini typeof bersifat statis, dan melakukan tugasnya pada waktu kompilasi, bukan pada waktu proses.

2.

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

Ini adalah true jika obj1 persis bertipe int. Jika obj1 berasal dari int, kondisi ifnya adalah false.

3.

if (obj1 is int)

Ini adalah true jika obj1 adalah int, atau jika ia berasal dari kelas bernama int, atau jika ia mengimplementasikan antarmuka bernama int.

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

Ini adalah sebuah kesalahan. Operator typeof di C# hanya dapat mengambil nama tipe, bukan objek.

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

Ini akan berhasil, tapi mungkin tidak seperti yang Anda harapkan. Untuk tipe nilai, seperti yang Anda tunjukkan di sini, nilai tersebut dapat diterima, namun untuk tipe referensi, nilai tersebut hanya akan menghasilkan nilai true jika tipe tersebut adalah tipe yang sama persis, bukan tipe lain dalam hierarki pewarisan. Contohnya:

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");
}

Ini akan mencetak "o is something else", karena tipe o adalah Dog, bukan Animal. Namun Anda dapat membuat ini berfungsi jika Anda menggunakan metode IsAssignableFrom dari kelas Type.

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

Namun teknik ini masih menyisakan masalah besar. Jika variabel Anda null, panggilan ke GetType() akan memunculkan NullReferenceException. Jadi untuk membuatnya berfungsi dengan benar, Anda harus melakukan:

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

Dengan ini, Anda memiliki perilaku yang setara dengan kata kunci is. Oleh karena itu, jika ini adalah perilaku yang Anda inginkan, Anda harus menggunakan kata kunci is, yang lebih mudah dibaca dan efisien.

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

Namun dalam kebanyakan kasus, kata kunci is masih belum sesuai dengan keinginan Anda, karena biasanya tidak cukup hanya dengan mengetahui bahwa suatu objek bertipe tertentu. Biasanya, Anda ingin menggunakan objek tersebut sebagai turunan dari tipe tersebut, sehingga memerlukan casting juga. Jadi Anda mungkin mendapati diri Anda menulis kode seperti ini:

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

Namun hal itu membuat CLR memeriksa tipe objek hingga dua kali. Ia akan memeriksanya sekali untuk memenuhi operator is, dan jika o memang Animal, kami memeriksanya lagi untuk memvalidasi pemerannya.

Lebih efisien melakukan ini:

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

Operator as adalah pemeran yang tidak akan mengeluarkan pengecualian jika gagal, melainkan mengembalikan null. Dengan cara ini, CLR memeriksa tipe objek sekali saja, dan setelah itu, kita hanya perlu melakukan pemeriksaan null, yang mana lebih efisien.

Namun hati-hati: banyak orang terjebak dengan as. Karena tidak memberikan pengecualian, beberapa orang menganggapnya sebagai gips yang "aman", dan mereka menggunakannya secara eksklusif, menghindari gips biasa. Hal ini menyebabkan kesalahan seperti ini:

(o as Animal).Speak();

Dalam hal ini, pengembang dengan jelas berasumsi bahwa o akan selalu menjadi Animal, dan selama asumsi mereka benar, semuanya berfungsi dengan baik. Namun jika mereka salah, maka yang mereka dapatkan di sini adalah NullReferenceException. Dengan pemeran reguler, mereka akan mendapatkan InvalidCastException, yang akan mengidentifikasi masalahnya dengan lebih tepat.

Terkadang, bug ini sulit ditemukan:

class Foo{
    readonly Animal animal;

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

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

Ini adalah kasus lain di mana pengembang dengan jelas mengharapkan o menjadi Animal setiap saat, namun hal ini tidak terlihat jelas di konstruktor, tempat pemeran as digunakan. Ini tidak jelas sampai Anda mendapatkan metode Interact, di mana bidang animal diharapkan ditetapkan secara positif. Dalam kasus ini, Anda tidak hanya akan mendapatkan pengecualian yang menyesatkan, namun pengecualian tersebut juga tidak akan muncul hingga kemungkinan terjadi lebih lama dibandingkan saat kesalahan sebenarnya terjadi.

Kesimpulan:

• Jika Anda hanya perlu mengetahui apakah suatu objek bertipe tertentu atau tidak, gunakan is.

• Jika Anda perlu memperlakukan suatu objek sebagai turunan dari tipe tertentu, tetapi Anda tidak tahu pasti apakah objek tersebut akan bertipe tersebut, gunakan as dan periksa null.

• Jika Anda perlu memperlakukan suatu objek sebagai turunan dari tipe tertentu, dan objek tersebut seharusnya bertipe tersebut, gunakan cast biasa.

Jika Anda menggunakan C# 7, maka inilah saatnya memperbarui jawaban hebat Andrew Hare. Pencocokan pola telah memperkenalkan pintasan bagus yang memberi kita variabel yang diketik dalam konteks pernyataan if, tanpa memerlukan deklarasi/pemeran terpisah dan periksa:

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

Ini terlihat sangat mengecewakan untuk pemeran tunggal seperti ini, tetapi benar-benar bersinar ketika Anda memiliki banyak kemungkinan tipe yang masuk ke dalam rutinitas Anda. Di bawah ini adalah cara lama untuk menghindari casting dua kali:

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

Mengatasi penyusutan kode ini sebanyak mungkin, serta menghindari duplikat objek yang sama selalu mengganggu saya. Di atas dikompresi dengan baik dengan pencocokan pola sebagai berikut:

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

EDIT: Memperbarui metode baru yang lebih panjang untuk menggunakan saklar sesuai komentar Palec.

Saya memiliki properti Type untuk dibandingkan dan tidak dapat menggunakan is (seperti my_type is _BaseTypetoLookFor), tetapi saya dapat menggunakan ini:

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

Perhatikan bahwa IsInstanceOfType dan IsAssignableFrom mengembalikan true ketika membandingkan tipe yang sama, dengan IsSubClassOf akan mengembalikan false. Dan IsSubclassOf tidak berfungsi pada antarmuka, seperti dua antarmuka lainnya. (Lihat juga pertanyaan dan jawaban ini.)

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

Saya lebih suka adalah

Oleh karena itu, jika Anda menggunakan is, kemungkinan besar Anda tidak menggunakan warisan dengan benar.

Asumsikan Orang : Entitas, dan Hewan : Entitas. Umpan adalah metode virtual di Entitas (untuk membuat Neil senang)

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
    }
  }
}

Lebih tepatnya

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

Saya percaya yang terakhir juga melihat warisan (misalnya Anjing adalah Hewan == benar), yang lebih baik dalam banyak kasus.

Itu tergantung pada apa yang saya lakukan. Jika saya memerlukan nilai bool (misalnya, untuk menentukan apakah saya akan menggunakan int), saya akan menggunakan is. Jika saya benar-benar membutuhkan tipe tersebut karena alasan tertentu (misalnya, untuk meneruskan ke metode lain), saya akan menggunakan GetType().

Yang terakhir lebih bersih, lebih jelas, dan juga memeriksa subtipe. Yang lain tidak memeriksa polimorfisme.

Digunakan untuk mendapatkan objek System.Type untuk suatu tipe. Ekspresi typeof mengambil bentuk berikut:

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
    */

Sampel ini menggunakan metode GetType untuk menentukan tipe yang digunakan untuk memuat hasil perhitungan numerik. Hal ini tergantung pada kebutuhan penyimpanan nomor yang dihasilkan.

    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
    */

Anda dapat menggunakan operator "typeof()" di C# tetapi Anda perlu memanggil namespace menggunakan System.IO; Anda harus menggunakan kata kunci "is" jika Anda ingin memeriksa jenisnya.

Uji kinerja typeof() vs 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();
    }
}

Hasil dalam mode debug:

00:00:08.4096636
00:00:10.8570657

Hasil dalam mode rilis:

00:00:02.3799048
00:00:07.1797128