การตรวจสอบประเภท: typeof, GetType หรือเป็น?

ทั้งหมดมีความแตกต่างกัน

• typeof ใช้ชื่อประเภท (ซึ่งคุณระบุ ณ เวลาคอมไพล์)
• GetType รับประเภทรันไทม์ของอินสแตนซ์
• is คืนค่าเป็นจริงหากอินสแตนซ์อยู่ในแผนผังการสืบทอด

ตัวอย่าง

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 เมื่อคุณต้องการรับประเภท ณ เวลารวบรวม ใช้ GetType เมื่อคุณต้องการรับประเภทที่ เวลาดำเนินการ ไม่ค่อยมีกรณีใดที่จะใช้ is เนื่องจากเป็นการร่าย และในกรณีส่วนใหญ่ คุณก็ต้องร่ายตัวแปรอยู่ดี

มีตัวเลือกที่สี่ที่คุณยังไม่ได้พิจารณา (โดยเฉพาะถ้าคุณจะโยนวัตถุให้เป็นประเภทที่คุณพบเช่นกัน); นั่นคือการใช้ as

Foo foo = obj as Foo;

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

สิ่งนี้ใช้เพียง หนึ่ง คาสต์ โดยที่วิธีนี้:

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

ต้องการ สอง.

อัปเดต (มกราคม 2020):

• ตั้งแต่ C# 7+ ตอนนี้คุณสามารถส่งแบบอินไลน์ได้แล้ว ดังนั้นวิธีการ 'เป็น' ก็สามารถทำได้ในการส่งครั้งเดียวเช่นกัน

ตัวอย่าง:

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 เงื่อนไข if จะเป็น false

3.

if (obj1 is int)

นี่คือ true หาก obj1 เป็น int หรือหากมาจากคลาสที่เรียกว่า int หรือหากใช้อินเทอร์เฟซที่เรียกว่า int

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

นี่เป็นข้อผิดพลาด ตัวดำเนินการ typeof ใน C# สามารถรับได้เฉพาะชื่อประเภทเท่านั้น ไม่สามารถรับวัตถุได้

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

สิ่งนี้จะได้ผล แต่อาจไม่เป็นไปตามที่คุณคาดหวัง สำหรับประเภทค่า ตามที่คุณแสดงไว้ที่นี่ ก็ยอมรับได้ แต่สำหรับประเภทการอ้างอิง จะส่งคืนค่าเป็นจริงก็ต่อเมื่อประเภทนั้นเป็นประเภท เหมือนกันทุกประการ ไม่ใช่อย่างอื่นในลำดับชั้นการสืบทอด ตัวอย่างเช่น:

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

เทคนิคนี้ยังคงทิ้งปัญหาสำคัญไว้ หากตัวแปรของคุณเป็นโมฆะ การเรียก 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 ตรวจสอบประเภทของวัตถุมากถึงสองครั้ง มันจะตรวจสอบหนึ่งครั้งเพื่อให้เป็นไปตามตัวดำเนินการ is และหาก o เป็น Animal จริงๆ เราจะทำการตรวจสอบอีกครั้งเพื่อตรวจสอบความถูกต้องของการส่ง

การทำเช่นนี้มีประสิทธิภาพมากกว่าแทน:

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

ตัวดำเนินการ as เป็นตัวส่งที่จะไม่ทำให้เกิดข้อยกเว้นหากล้มเหลว แต่จะส่งคืน null แทน ด้วยวิธีนี้ CLR จะตรวจสอบประเภทของออบเจ็กต์เพียงครั้งเดียว และหลังจากนั้น เราก็ต้องทำการตรวจสอบแบบ 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++;
}

มันดูไม่น่าดูเลยสำหรับนักแสดงเดี่ยวแบบนี้ แต่จะโดดเด่นจริงๆ เมื่อคุณมีนักแสดงประเภทต่างๆ ที่เป็นไปได้เข้ามาในชีวิตประจำวันของคุณ ด้านล่างนี้เป็นวิธีเก่าในการหลีกเลี่ยงการส่งซ้ำสองครั้ง:

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 ที่จะเปรียบเทียบและไม่สามารถใช้ 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

ฉันชอบ คือ

ที่กล่าวว่า หากคุณใช้ is คุณมีแนวโน้มที่จะ ไม่ ใช้การสืบทอดอย่างถูกต้อง

สมมติว่าบุคคลนั้น: เอนทิตี และสัตว์นั้น: เอนทิตี Feed เป็นวิธีการเสมือนใน Entity (เพื่อทำให้ Neil มีความสุข)

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

ฉันเชื่อว่าอันสุดท้ายยังดูที่มรดกด้วย (เช่น Dog is Animal == true) ซึ่งดีกว่าในกรณีส่วนใหญ่

มันขึ้นอยู่กับสิ่งที่ฉันทำ หากฉันต้องการค่าบูล (เช่น เพื่อพิจารณาว่าฉันจะแปลงเป็น 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
    */

คุณสามารถใช้ตัวดำเนินการ "typeof()" ใน C# ได้ แต่คุณต้องเรียกเนมสเปซโดยใช้ System.IO คุณต้องใช้คีย์เวิร์ด "is" หากคุณต้องการตรวจสอบประเภท

ประเภทการทดสอบประสิทธิภาพ () กับ 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