बनाम टाइप

Question

कोड के इनमें से कौन सा टुकड़ा तेज़ है?

if (obj is ClassA) {} 

if (obj.GetType() == typeof(ClassA)) {} 

संपादित करें: मुझे पता है कि वे एक ही बात नहीं करते है।

Answer 1

This should answer that question, and then some.

दूसरी पंक्ति, if (obj.GetType() == typeof(ClassA)) {}, तेज, उन है कि लेख पढ़ने के लिए नहीं करना चाहते हैं के लिए है।

Answer 2

वे एक ही बात नहीं करते हैं। पहला काम करता है अगर ओबीजे क्लासए या क्लासए के कुछ उप-वर्ग के प्रकार का है। दूसरा वाला क्लास ए के प्रकार से मेल खाता है। दूसरा एक तेज़ होगा क्योंकि इसे कक्षा पदानुक्रम की जांच करने की आवश्यकता नहीं है।

उन लोगों के लिए जो कारण जानना चाहते हैं, लेकिन is vs typeof में संदर्भित आलेख को पढ़ना नहीं चाहते हैं।

Answer 3

यह ऐसा मामला है जिस, तेजी से होता है अगर वे एक ही बात नहीं करते है? विभिन्न अर्थों के साथ बयानों के प्रदर्शन की तुलना करना एक बुरा विचार लगता है।

is आपको बताता है कि क्या वस्तु ClassA को अपने प्रकार के उत्तराधिकारी में कहीं भी लागू करती है। GetType() आपको सबसे ज्यादा व्युत्पन्न प्रकार के बारे में बताता है।

वही बात नहीं है। सील प्रकार -

Answer 4

मैं कुछ बेंच मार्किंग, जहां वे भी ऐसा ही किया था।

var c1 = ""; 
var c2 = typeof(string); 
object oc1 = c1; 
object oc2 = c2; 

var s1 = 0; 
var s2 = '.'; 
object os1 = s1; 
object os2 = s2; 

bool b = false; 

Stopwatch sw = Stopwatch.StartNew(); 
for (int i = 0; i < 10000000; i++) 
{ 
    b = c1.GetType() == typeof(string); // ~60ms 
    b = c1 is string; // ~60ms 

    b = c2.GetType() == typeof(string); // ~60ms 
    b = c2 is string; // ~50ms 

    b = oc1.GetType() == typeof(string); // ~60ms 
    b = oc1 is string; // ~68ms 

    b = oc2.GetType() == typeof(string); // ~60ms 
    b = oc2 is string; // ~64ms 


    b = s1.GetType() == typeof(int); // ~130ms 
    b = s1 is int; // ~50ms 

    b = s2.GetType() == typeof(int); // ~140ms 
    b = s2 is int; // ~50ms 

    b = os1.GetType() == typeof(int); // ~60ms 
    b = os1 is int; // ~74ms 

    b = os2.GetType() == typeof(int); // ~60ms 
    b = os2 is int; // ~68ms 


    b = GetType1<string, string>(c1); // ~178ms 
    b = GetType2<string, string>(c1); // ~94ms 
    b = Is<string, string>(c1); // ~70ms 

    b = GetType1<string, Type>(c2); // ~178ms 
    b = GetType2<string, Type>(c2); // ~96ms 
    b = Is<string, Type>(c2); // ~65ms 

    b = GetType1<string, object>(oc1); // ~190ms 
    b = Is<string, object>(oc1); // ~69ms 

    b = GetType1<string, object>(oc2); // ~180ms 
    b = Is<string, object>(oc2); // ~64ms 


    b = GetType1<int, int>(s1); // ~230ms 
    b = GetType2<int, int>(s1); // ~75ms 
    b = Is<int, int>(s1); // ~136ms 

    b = GetType1<int, char>(s2); // ~238ms 
    b = GetType2<int, char>(s2); // ~69ms 
    b = Is<int, char>(s2); // ~142ms 

    b = GetType1<int, object>(os1); // ~178ms 
    b = Is<int, object>(os1); // ~69ms 

    b = GetType1<int, object>(os2); // ~178ms 
    b = Is<int, object>(os2); // ~69ms 
} 

sw.Stop(); 
MessageBox.Show(sw.Elapsed.TotalMilliseconds.ToString()); 

सामान्य कार्यों सामान्य प्रकार के लिए परीक्षण करने के लिए:

static bool GetType1<S, T>(T t) 
{ 
    return t.GetType() == typeof(S); 
} 
static bool GetType2<S, T>(T t) 
{ 
    return typeof(T) == typeof(S); 
} 
static bool Is<S, T>(T t) 
{ 
    return t is S; 
} 

मैं भी कस्टम प्रकार के लिए करने की कोशिश की और परिणाम निरंतर चल रहे थे:

var c1 = new Class1(); 
var c2 = new Class2(); 
object oc1 = c1; 
object oc2 = c2; 

var s1 = new Struct1(); 
var s2 = new Struct2(); 
object os1 = s1; 
object os2 = s2; 

bool b = false; 

Stopwatch sw = Stopwatch.StartNew(); 
for (int i = 0; i < 10000000; i++) 
{ 
    b = c1.GetType() == typeof(Class1); // ~60ms 
    b = c1 is Class1; // ~60ms 

    b = c2.GetType() == typeof(Class1); // ~60ms 
    b = c2 is Class1; // ~55ms 

    b = oc1.GetType() == typeof(Class1); // ~60ms 
    b = oc1 is Class1; // ~68ms 

    b = oc2.GetType() == typeof(Class1); // ~60ms 
    b = oc2 is Class1; // ~68ms 


    b = s1.GetType() == typeof(Struct1); // ~150ms 
    b = s1 is Struct1; // ~50ms 

    b = s2.GetType() == typeof(Struct1); // ~150ms 
    b = s2 is Struct1; // ~50ms 

    b = os1.GetType() == typeof(Struct1); // ~60ms 
    b = os1 is Struct1; // ~64ms 

    b = os2.GetType() == typeof(Struct1); // ~60ms 
    b = os2 is Struct1; // ~64ms 


    b = GetType1<Class1, Class1>(c1); // ~178ms 
    b = GetType2<Class1, Class1>(c1); // ~98ms 
    b = Is<Class1, Class1>(c1); // ~78ms 

    b = GetType1<Class1, Class2>(c2); // ~178ms 
    b = GetType2<Class1, Class2>(c2); // ~96ms 
    b = Is<Class1, Class2>(c2); // ~69ms 

    b = GetType1<Class1, object>(oc1); // ~178ms 
    b = Is<Class1, object>(oc1); // ~69ms 

    b = GetType1<Class1, object>(oc2); // ~178ms 
    b = Is<Class1, object>(oc2); // ~69ms 


    b = GetType1<Struct1, Struct1>(s1); // ~272ms 
    b = GetType2<Struct1, Struct1>(s1); // ~140ms 
    b = Is<Struct1, Struct1>(s1); // ~163ms 

    b = GetType1<Struct1, Struct2>(s2); // ~272ms 
    b = GetType2<Struct1, Struct2>(s2); // ~140ms 
    b = Is<Struct1, Struct2>(s2); // ~163ms 

    b = GetType1<Struct1, object>(os1); // ~178ms 
    b = Is<Struct1, object>(os1); // ~64ms 

    b = GetType1<Struct1, object>(os2); // ~178ms 
    b = Is<Struct1, object>(os2); // ~64ms 
} 

sw.Stop(); 
MessageBox.Show(sw.Elapsed.TotalMilliseconds.ToString()); 

और प्रकार:

sealed class Class1 { } 
sealed class Class2 { } 
struct Struct1 { } 
struct Struct2 { } 

अनुमान:

1. कॉलिंग रों GetTypestruct पर धीमी है।GetTypeobject वर्ग जो उप प्रकार में ओवरराइड नहीं किया जा सकता है और इस तरह struct रों GetType के नाम से जाना बॉक्सिंग करने की आवश्यकता पर परिभाषित किया गया है।

2. किसी ऑब्जेक्ट उदाहरण पर, GetType तेज है, लेकिन बहुत ही मामूली है।

3. सामान्य प्रकार, यदि Tclass है, तो is तेज हो गया है। यदि Tstruct है, तो isGetType की तुलना में बहुत तेजी से होता है, लेकिन typeof(T) दोनों की तुलना में बहुत तेजी से होता है।T जा रहा है class के मामलों में, typeof(T) वास्तविक अंतर्निहित प्रकार t.GetType से अपनी अलग के बाद से विश्वसनीय नहीं है।

संक्षेप में, यदि आप एक object उदाहरण है, GetType का उपयोग करें। यदि आपके पास सामान्य class प्रकार है, तो is का उपयोग करें। यदि आपके पास सामान्य struct प्रकार है, तो typeof(T) का उपयोग करें। यदि आप अनिश्चित हैं कि सामान्य प्रकार संदर्भ प्रकार या मान प्रकार है, तो is का उपयोग करें। यदि आप हमेशा एक शैली (सीलबंद प्रकारों के लिए) के साथ संगत होना चाहते हैं, तो is का उपयोग करें ..