सी # प्रकार तुलना: Type.Equals बनाम ऑपरेटर ==

Question

Resharper पता चलता है कि निम्नलिखित से बदला जा:

Type foo = typeof(Foo); 
Type bar = typeof(Bar); 

if(foo.Equals(bar)) { ... } 

करने के लिए:

if(foo == bar) { ... } 

ऑपरेटर ==

// Summary: 
//  Indicates whether two System.Type objects are equal. 
// 
// Parameters: 
// left: 
//  The first object to compare. 
// 
// right: 
//  The second object to compare. 
// 
// Returns: 
//  true if left is equal to right; otherwise, false. 
public static bool operator ==(Type left, Type right); 

बराबर (टाइप ओ)

// Summary: 
//  Determines if the underlying system type of the current System.Type is the 
//  same as the underlying system type of the specified System.Type. 
// 
// Parameters: 
// o: 
//  The System.Type whose underlying system type is to be compared with the underlying 
//  system type of the current System.Type. 
// 
// Returns: 
//  true if the underlying system type of o is the same as the underlying system 
//  type of the current System.Type; otherwise, false. 
public virtual bool Equals(Type o); 

प्रश्न
क्यों operator == जब प्रकार की तुलना Equals(Type o) से अधिक की सिफारिश की जाएगी?

Answer 1

मेरा सुझाव है कि आप ब्रैड विल्सन द्वारा उत्कृष्ट when is a type not a type? ब्लॉग पोस्ट पढ़ें। सारांशित करने के लिए: सीएलआर द्वारा प्रबंधित रनटाइम प्रकार (आंतरिक प्रकार रनटाइम टाइप द्वारा दर्शाया गया) हमेशा Type जैसा नहीं होता है, जिसे बढ़ाया जा सकता है। Equalsunderlying system type की जांच करेगा, जबकि == इस प्रकार की जांच करेगा।

एक साधारण उदाहरण:

Type type = new TypeDelegator(typeof(int)); 
Console.WriteLine(type.Equals(typeof(int))); // Prints True 
Console.WriteLine(type == typeof(int));  // Prints False 

Answer 2

कारण सरल है: दोनों इस मामले में कार्यात्मक रूप से समकक्ष हैं और बाद वाला अधिक पठनीय है।

Answer 3

http://blogs.msdn.com/b/csharpfaq/archive/2004/03/29/when-should-i-use-and-when-should-i-use-equals.aspx

से बराबर विधि सिर्फ System.Object में परिभाषित एक आभासी एक है, और जो भी कक्षाएं ऐसा करने के लिए चुनें द्वारा ओवरराइड है। == ऑपरेटर एक ऑपरेटर है जिसे कक्षाओं द्वारा ओवरलोड किया जा सकता है, लेकिन आमतौर पर पहचान व्यवहार होता है।

संदर्भ प्रकार जहां == अतिभारित नहीं किया गया है के लिए, यह तुलना है कि क्या दो संदर्भ एक ही वस्तु को देखें - जो वास्तव में है क्या बराबर के कार्यान्वयन System.Object में करता है।

वैल्यू प्रकार डिफ़ॉल्ट रूप से == के लिए ओवरलोड प्रदान नहीं करते हैं। हालांकि, ढांचे द्वारा प्रदान किए गए अधिकांश मूल्य प्रकार अपने स्वयं के अधिभार प्रदान करते हैं। वैल्यू टाइप द्वारा प्रदान किए गए मान प्रकार के लिए बराबर का डिफ़ॉल्ट कार्यान्वयन है, और तुलना करने के लिए प्रतिबिंब का उपयोग करता है, जो इसे सामान्य रूप से एक प्रकार-विशिष्ट कार्यान्वयन से काफी धीमा कर देता है। इस कार्यान्वयन में भी दो मानों की तुलना में संदर्भों के जोड़े पर बराबर है।

हालांकि, सामान्य उपयोग में दो प्रकार की तुलना के बीच मुख्य अंतर (जहां आप अक्सर अपने मूल्य प्रकार को परिभाषित करने की संभावना नहीं रखते हैं) बहुरूपता है। ऑपरेटरों को ओवरलोड किया गया है, जिसका अर्थ है कि जब तक कि संकलक अधिक विशिष्ट संस्करण को कॉल नहीं करता है, तो यह केवल पहचान संस्करण को कॉल करेगा।