दिलचस्प पोस्ट
जावास्क्रिप्ट का उपयोग कर ब्राउज़िंग इतिहास कैसे साफ़ करें? एएसपी.नेट में नियंत्रण पाने का बेहतर तरीका ViewModelLocator MVVM लाइट में देखें मॉडेल्स ऐप लॉन्चर आइकन में सूचनाओं की गिनती कैसे प्रदर्शित करें डुप्लिकेट को सूची से कैसे हटाएं? अन्य ऐप्स में सामग्री साझा करने के लिए FileProvider का समर्थन कैसे करें? Node.js + Nginx – अब क्या? VS2012 समाधान को VS2010 में परिवर्तित करना jQuery का चयनकर्ता: आईडी समाप्त होता है? टाइमर टास्क बनाम थ्रेड.sleep बनाम हेन्डलर पोस्ट डिलायटेड – प्रत्येक एन मिलीसेकंड को कॉल करने के लिए सबसे सटीक है? एक आरजीबी मूल्य को देखते हुए, मैं एक टिंट (या छाया) कैसे बनाऊं? अतिरिक्त कॉलम (एस) के साथ कई-से-कई संघ तालिका मैप करना Android KitKat सुरक्षा MediaStore से पढ़ने का प्रयास करते समय अपवाद डबल गुणा में टूट गया है .net? कंसेटेनेटेड कॉमा-सीडेमेटेड डेटा के एक कॉलम को विभाजित करें और कारकों के रूप में आउटपुट को आउट करें

सी = अंतर और बराबर के बीच सी ()

मेरे पास एक सिल्वरलाइट अनुप्रयोग में एक शर्त है जो 2 स्ट्रिंग्स की तुलना करता है, किसी कारण के लिए जब मैं == उपयोग करता हूं, तब वह गलत होता है

यहां कोड है:

 if (((ListBoxItem)lstBaseMenu.SelectedItem).Content.Equals("Energy Attack")) { // Execute code } if (((ListBoxItem)lstBaseMenu.SelectedItem).Content == "Energy Attack") { // Execute code } 

ऐसा क्यों हो रहा है यह किसी भी कारण से है?

वेब के समाधान से एकत्रित समाधान "सी = अंतर और बराबर के बीच सी ()"

जब प्रकार == का प्रयोग object प्रकार की अभिव्यक्ति पर किया जाता है, तो यह System.Object.ReferenceEqualsobject लिए हल करेगा।

Equals केवल एक virtual पद्धति है और इस तरह व्यवहार करता है, इसलिए ओवरराइड संस्करण का उपयोग किया जाएगा (जो, string प्रकार के लिए सामग्री की तुलना करता है)।

किसी स्ट्रिंग के ऑब्जेक्ट संदर्भ की तुलना करते समय (ऑब्जेक्ट रेफरेंस स्ट्रिंग को संदर्भित करता है तो भी), स्ट्रिंग क्लास के लिए विशिष्ट == ऑपरेटर के विशेष व्यवहार को नजरअंदाज किया जाता है।

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

 string s1 = "test"; string s2 = "test"; string s3 = "test1".Substring(0, 4); object s4 = s3; Console.WriteLine("{0} {1} {2}", object.ReferenceEquals(s1, s2), s1 == s2, s1.Equals(s2)); Console.WriteLine("{0} {1} {2}", object.ReferenceEquals(s1, s3), s1 == s3, s1.Equals(s3)); Console.WriteLine("{0} {1} {2}", object.ReferenceEquals(s1, s4), s1 == s4, s1.Equals(s4)); 

आउटपुट है:

 True True True False True True False False True 

== और .Equals दोनों वास्तविक प्रकार में परिभाषित व्यवहार और कॉल साइट पर वास्तविक प्रकार पर निर्भर हैं। दोनों ही विधियों / ऑपरेटरों हैं, जिन्हें किसी भी प्रकार से ओवरराइड किया जा सकता है और किसी भी तरह के व्यवहार लेखक को ऐसा इच्छा हो सकती है। मेरे अनुभव में, मुझे लगता है कि लोगों को लागू करने के लिए यह सामान्य है। एक ऑब्जेक्ट पर .Equals लेकिन ऑपरेटर को लागू करने की उपेक्षा == इसका अर्थ है कि। .Equals वास्तव में मूल्यों की समानता को मापते हैं, जबकि == यह मापता है कि वे एक ही संदर्भ हैं या नहीं।

जब मैं एक नई प्रकार के साथ काम कर रहा हूं जिसका परिभाषा प्रवाह में है या जेनेरिक एल्गोरिदम लिख रहा है, तो मुझे सबसे अच्छा अभ्यास निम्न है

  • यदि मैं सी # में संदर्भों की तुलना करना चाहता हूं, तो मैं Object.ReferenceEquals उपयोग करता हूं। Object.ReferenceEquals सीधे (जेनेरिक केस में आवश्यक नहीं)
  • अगर मैं मूल्यों की तुलना करना चाहता हूं तो मैं EqualityComparer<T>.Default उपयोग करता हूं। EqualityComparer<T>.Default

कुछ मामलों में जब मुझे लगता है कि == का उपयोग अस्पष्ट है, तो मैं स्पष्ट रूप से Object.Reference उपयोग करूँगा। अस्पष्टता को हटाने के लिए संदर्भ में बराबर Object.Reference

एरिक लिपर ने हाल ही में एक ब्लॉग पोस्ट किया है, इस विषय पर कि सीएलआर में समानता के 2 तरीके क्यों हैं यह पढ़ने के लायक है

सबसे पहले, एक अंतर है संख्याओं के लिए

 > 2 == 2.0 True > 2.Equals(2.0) False 

और तार के लिए

 > string x = null; > x == null True > x.Equals(null) NullReferenceException 

दोनों ही मामलों में, == अधिक उपयोगी ढंग से व्यवहार करता है

मैं यह जोड़ूंगा कि यदि आप अपना ऑब्जेक्ट स्ट्रिंग में डालें तो यह सही तरीके से काम करेगा। यही कारण है कि कंपाइलर आपको एक चेतावनी देगा, "संभावित अनपेक्षित संदर्भ तुलना; मान की तुलना प्राप्त करने के लिए, 'स्ट्रिंग' टाइप करने के लिए बाएं हाथ की ओर डालें"

== ऑपरेटर 1. यदि ऑपरेंसेस मूल्य प्रकार हैं और उनके मूल्य बराबर हैं, तो वह सही और झूठे रिटर्न देता है। 2. यदि परिपथ स्ट्रिंग के अपवाद के साथ संदर्भ प्रकार हैं और दोनों एक ही ऑब्जेक्ट का संदर्भ देते हैं, तो यह सही और गलत रिटर्न देता है। 3. यदि ऑपरेंड्स स्ट्रिंग प्रकार हैं और उनके मूल्य समान हैं, तो यह सही और गलत रिटर्न देता है।

.Equals 1. यदि ऑपरेंड्स संदर्भ प्रकार हैं, तो यह संदर्भ समानता करता है जो कि यदि दोनों एक ही वस्तु का संदर्भ लेते हैं, तो यह सही और गलत देता है। 2. यदि संचालन मूल्य प्रकार हैं तो == ऑपरेटर के विपरीत यह पहले उनके प्रकार की जाँच करता है और यदि उनके प्रकार समान होते हैं तो यह == ऑपरेटर करता है और यह झूठी रिटर्न देता है।

जहाँ तक मैं समझता हूं कि इसका उत्तर सरल है:

  1. == वस्तु संदर्भों की तुलना
  2. .Equals वस्तु सामग्री की तुलना
  3. स्ट्रिंग डेटाटाइप्स हमेशा सामग्री तुलना की तरह काम करते हैं।

मुझे आशा है कि मैं सही हूँ और यह आपके प्रश्न का उत्तर दिया।

मैं यहाँ थोड़ा भ्रमित हूँ यदि रनटाइम प्रकार की सामग्री प्रकार की स्ट्रिंग होती है, तो दोनों == और बराबर को सही करना चाहिए। हालांकि, चूंकि यह मामला नहीं दिखाई देता है, इसलिए रनटाइम का प्रकार की सामग्री स्ट्रिंग नहीं है और इस पर बराबर कॉल करने से यह एक संदर्भित समानता कर रहा है और यह बताता है कि क्यों बराबर ("ऊर्जा हमला") विफल रहता है। हालांकि, दूसरे मामले में, निर्णय के रूप में अतिभारित == स्थैतिक ऑपरेटर को समय के संकलन पर बनाया जाना चाहिए और यह निर्णय == (स्ट्रिंग, स्ट्रिंग) प्रतीत होता है। यह मुझे सुझाव देती है कि सामग्री स्ट्रिंग के लिए एक अंतर्निहित रूपांतरण प्रदान करती है

@ ब्ल्यू मोनकेएमएन द्वारा पहले उत्तर में एक और आयाम है अतिरिक्त आयाम यह है कि @ Drahcir के शीर्षक प्रश्न का उत्तर, जैसा कि यह भी कहा गया है, यह इस बात पर निर्भर करता है कि हम string मान पर कैसे पहुंचे। उदाहरण देकर स्पष्ट करने के लिए:

 string s1 = "test"; string s2 = "test"; string s3 = "test1".Substring(0, 4); object s4 = s3; string s5 = "te" + "st"; object s6 = s5; Console.WriteLine("{0} {1} {2}", object.ReferenceEquals(s1, s2), s1 == s2, s1.Equals(s2)); Console.WriteLine("\n Case1 - A method changes the value:"); Console.WriteLine("{0} {1} {2}", object.ReferenceEquals(s1, s3), s1 == s3, s1.Equals(s3)); Console.WriteLine("{0} {1} {2}", object.ReferenceEquals(s1, s4), s1 == s4, s1.Equals(s4)); Console.WriteLine("\n Case2 - Having only literals allows to arrive at a literal:"); Console.WriteLine("{0} {1} {2}", object.ReferenceEquals(s1, s5), s1 == s5, s1.Equals(s5)); Console.WriteLine("{0} {1} {2}", object.ReferenceEquals(s1, s6), s1 == s6, s1.Equals(s6)); 

आउटपुट है:

 True True True Case1 - A method changes the value: False True True False False True Case2 - Having only literals allows to arrive at a literal: True True True True True True 

उत्तर के लिए एक और बिंदु जोड़ना

.EqualsTo() विधि आपको संस्कृति और मामले के प्रति संवेदनशील से तुलना करने के लिए प्रावधान देता है।

सी == टोकन == दो भिन्न समानता जांच ऑपरेटर के लिए उपयोग किया जाता है जब कंपाइलर उस टोकन से मुकाबला करता है, तो यह जांच करेगा कि किस तरह की किसी भी प्रकार की तुलना की जा रही है, उसमें समान संयोजन प्रकार (*) की तुलना में या तो उन प्रकार के संयोजन के लिए एक समानता-ऑपरेटर अधिभार लागू किया गया है, जिसमें दोनों प्रकार के रूपांतरित किए जा सकते हैं। यदि कंपाइलर इस तरह के एक अधिभार पाता है तो यह इसका उपयोग करेगा अन्यथा, यदि दो प्रकार के दोनों संदर्भ प्रकार हैं और वे असंबंधित वर्ग नहीं हैं (या तो एक इंटरफ़ेस हो सकता है, या वे संबंधित कक्षाएं हो सकते हैं), कंपाइलर == को संदर्भ-तुलना ऑपरेटर के रूप में देखेंगे। यदि कोई शर्त लागू नहीं होती है, तो संकलन विफल हो जाएगा।

ध्यान दें कि कुछ अन्य भाषाओं दो समानता जांच ऑपरेटर के लिए अलग टोकन का उपयोग करते हैं। उदाहरण के लिए, VB.NET में, = टोकन का प्रयोग केवल अतिभारणीय समानता-जांच ऑपरेटर के लिए अभिव्यक्ति के भीतर किया जाता है, और इसे संदर्भ-परीक्षण या शून्य-परीक्षण ऑपरेटर के रूप में प्रयोग किया जाता है। एक प्रकार का उपयोग = जो कि समानता-जांच ऑपरेटर को ओवरराइड नहीं करता है, असफल हो जायेगा, जैसा कि प्रयोग करने का प्रयास करेगा संदर्भ संदर्भ समानता या शून्यता के अलावा अन्य किसी भी उद्देश्य Is लिए है।

(*) आमतौर पर आमतौर पर स्वयं के साथ तुलना करने के लिए समानता को अधिभारित किया जाता है, लेकिन यह अन्य विशेष प्रकारों के साथ तुलना करने के लिए समानता ऑपरेटर को अतिभारित करने के लिए उपयोगी हो सकता है; उदाहरण के लिए, int float साथ तुलना करने के लिए एक समानता ऑपरेटरों को परिभाषित किया जा सकता है (और आईएमएचओ को होना चाहिए, परंतु उसने नहीं किया है), ताकि 16777217 खुद को 16777216f के बराबर रिपोर्ट न करें। जैसा कि ऐसा कोई ऑपरेटर परिभाषित नहीं किया गया है, C #, int को float बढ़ावा देगा, इसे समानता जांच ऑपरेटर को देखकर 16777216f तक गोल करेगा; वह ऑपरेटर तब दो बराबर फ़्लोटिंग-पॉइंट नंबर देखता है और उनको समान रूप से रिपोर्ट करता है, जो गोलाई के बारे में अनजान था।

बहुत अच्छा जवाब और उदाहरण!

मैं सिर्फ दोनों के बीच मूलभूत अंतर जोड़ना चाहता हूं,

ऑपरेटर जैसे कि == बहुरूपक नहीं हैं, जबकि Equals है

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

चूंकि .Equal पद्धति का स्थिर संस्करण अभी तक उल्लेख नहीं किया गया था, मैं इसे संक्षेप करने और 3 विविधताओं की तुलना करने के लिए यहां जोड़ना चाहता हूं।

 MyString.Equals("Somestring")) //Method 1 MyString == "Somestring" //Method 2 String.Equals("Somestring", MyString); //Method 3 (static String.Equals method) - better 

जहां MyString एक ऐसा चर है जो कोड में कहीं और से आता है।

पृष्ठभूमि जानकारी और गर्मियों के लिए:

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

सी # में विधि 1 या विधि 2 का उपयोग करके तार की तुलना करने के लिए कोई व्यावहारिक अंतर नहीं है, जब तक दोनों प्रकार की स्ट्रिंग के होते हैं। हालांकि, यदि कोई रिक्त है, तो एक अन्य प्रकार का है (एक पूर्णांक की तरह), या कोई एक ऑब्जेक्ट का प्रतिनिधित्व करता है जिसमें एक अलग संदर्भ होता है, तो, प्रारंभिक प्रश्न बताता है, आप अनुभव कर सकते हैं कि समानता के लिए सामग्री की तुलना क्या नहीं लौट सकती है तुम आशा करते हो।

सुझाए गए समाधान:

क्योंकि == का उपयोग करने के लिए बिल्कुल समान नहीं है। चीजों की तुलना करते समय, आप स्थिर .Equals विधि का उपयोग कर सकते हैं। इस तरह, यदि दोनों पक्ष समान प्रकार नहीं हैं तो आप अभी भी सामग्री की तुलना करेंगे और यदि कोई अशक्त है, तो आप अपवाद से बचेंगे।

  bool true = String.Equals("Somestring", MyString); 

यह थोड़ा और लिखना है, लेकिन मेरी राय में, उपयोग करने के लिए सुरक्षित है

यहां कुछ जानकारी माइक्रोसॉफ्ट से कॉपी की गई है:

 public static bool Equals (string a, string b); 

पैरामीटर

a स्ट्रिंग

तुलना करने के लिए पहली स्ट्रिंग, या null

b स्ट्रिंग

तुलना करने के लिए दूसरी स्ट्रिंग, या null

Boolean लौटाता है

true अगर a का मान b के मान के समान है; अन्यथा, false । अगर दोनों a और b null , तो विधि रिटर्न true

जब हम कोई ऑब्जेक्ट बनाते हैं, तो ऑब्जेक्ट के दो हिस्से होते हैं सामग्री एक और दूसरी है उस कंटेंट के संदर्भ। == सामग्री और संदर्भ दोनों की तुलना करता है; equals() केवल सामग्री की तुलना करता है

http://www.codeproject.com/Articles/584128/What-is-the-difference-between-equalsequals-and-Eq

बराबर और == के बीच का एकमात्र अंतर ऑब्जेक्ट प्रकार की तुलना पर है अन्य मामलों में, जैसे संदर्भ प्रकार और मूल्य प्रकार, वे लगभग समान हैं (या तो दोनों बिट-वार समानता हैं या दोनों संदर्भ समानता हैं)।

वस्तु: बराबर: बिट-वार समानता ==: संदर्भ समानता

स्ट्रिंग: (बराबर और == स्ट्रिंग के लिए समान होते हैं, लेकिन यदि स्ट्रिंग में से एक ऑब्जेक्ट में बदल जाता है, तो तुलना का परिणाम अलग होगा) बराबर: बिट-वार समता ==: बिट-वार समानता

अधिक स्पष्टीकरण के लिए यहां देखें

==

== ऑपरेटर का उपयोग किसी भी प्रकार के दो चर की तुलना करने के लिए किया जा सकता है, और यह बिट्स की तुलना करता है

 int a = 3; byte b = 3; if (a == b) { // true } 

नोट: इंट के बाईं ओर अधिक शून्य हैं लेकिन हमें इसके बारे में परवाह नहीं है।

इंट ए (00000011) == बाइट बी (00000011)

याद रखें == ऑपरेटर चर में केवल बिट के पैटर्न की परवाह करता है

== यदि दो संदर्भ (प्राथमिकताएं) ढेर पर समान ऑब्जेक्ट को संदर्भित करता है तो उपयोग करें।

नियम समान होते हैं, चर एक संदर्भ या आदिम है।

 Foo a = new Foo(); Foo b = new Foo(); Foo c = a; if (a == b) { // false } if (a == c) { // true } if (b == c) { // false } 

ए == सी सच है एक == ख गलत है

बिट पैटर्न ए और सी के समान हैं, इसलिए वे == का उपयोग करते हुए बराबर हैं।

बराबरी का():

यह देखने के लिए बराबर () विधि का उपयोग करें कि क्या दो भिन्न ऑब्जेक्ट समान हैं

दो भिन्न स्ट्रिंग ऑब्जेक्ट्स जैसे कि दोनों "जेन" में वर्णों का प्रतिनिधित्व करते हैं