== vs. Oggetto.Equals(object) in .NET

Così, quando ero una comparativa novizio novizio sto ora, ho usato a pensare che queste due cose sono state zucchero sintattico per l’altro, cioè che utilizza uno sopra l’altro, era semplicemente una preferenza personale. Nel corso del tempo, sono venuto a scoprire che questi due non sono la stessa cosa, anche in una implementazione di default (vedere questo e questo). Per confondere ulteriormente la questione, ognuno dei quali può essere sottoposto a override/sovraccarico separatamente per avere significati completamente diversi.

Questa è una buona cosa, quali sono le differenze, e quando e come e perché si dovrebbe utilizzare uno sopra l’altro?

 

9 Replies
  1. 17

    MSDN è chiaro e solido descrizioni di entrambe le cose.

    oggetto.Metodo Equals

    l’operatore ==

    Che Supportano L’Overload Degli Operatori

    Linee guida per l’Override del metodo Equals() e l’Operatore ==

    Questa è una buona cosa, quali sono le
    le differenze, e quando e perché si
    utilizzare uno sopra l’altro?

    Come può essere “buona” o “cattiva” cosa? Un metodo, un altro operatore. Se il riferimento di uguaglianza non è sufficiente, sovraccarico, altrimenti li lasci così com’è. Per i tipi primitivi lavorano solo dalla scatola.

    • Come qualcuno di entrare in generics le differenze possono essere di grandi dimensioni quando si chiama su qualsiasi tipo di T ciecamente.
    • “alla cieca” non è una buona pratica per nulla. se si conosce la risposta alla tua domanda, perché chiedere?
    • Anche se l’ho fatto conoscere una risposta concreta (che non conosco), forse per la stessa ragione per cui le persone di porre domande e di rispondere a se stessi? Inoltre, come si può fare altro per un tipo generico T? Se voi iniziare a fare le cose come if (typeof(T) == typeof(int)), qual è il punto?
    • Come per la mia indignazione, che ho incontrato per molte situazioni, quando ho a disposizione per tutta risposta, ma la persona che vuole solo mostrare e ripetere la mia risposta con alcune aggiunte minori, così sprecando il mio tempo. Se davvero non si conosce la risposta, mi scuso.
    • “Inoltre, come si può fare altro” mi Dispiace ma io non riesco a capire cosa vuoi dire. Forse si può chiedere di cemento domanda circa i generici?
    • Dato dire List<T>, la Lista non si cura di ciò che tipo T è, non dovrebbe controllare ovunque che tipo di oggetto T è, si deve utilizzare solo Oggetto, metodi e risultati attesi (escluso quando ci sono restrizioni su ciò che T è). O sono io che sbaglio qui?
    • Elenco<Apple> e Elenco<Orange> sono due cose completamente diverse classi. Ogni tipo può comportarsi in modo diverso. In ogni caso, si dovrebbe leggere la descrizione della Parità e == metodi per capire come funziona. Se non ci sono avvisi, si consideri che il solo riferimento uguaglianza è utilizzato.
    • Se si vuole discutere l’attuazione dell’uguaglianza di insiemi generici, crea una nuova domanda. Commenti non è un posto per le nuove domande.
    • questa risposta sarebbe più maneggevole se riassunti la differenza essenziale tra i due operatori. Non è fino a quando la terzo link (linee guida per l’override) che microsoft inizia a discutere le due uguaglianze allo stesso tempo – che è necessario, per rispondere alla domanda. (E io quasi non si è preoccupato cliccando sul 4 ° link, in quanto il titolo non mi tranquillizzava, e il 3 ° link sembravano del tutto irrilevanti).
    • In realtà, che il 4 ° link non essere di aiuto a tutti più di tanto. Contrasta ReferenceEquals con Uguale, ma non danno le linee guida per situazioni in cui è Uguale e “==” deve dare una risposta diversa. Per quanto posso dire, qualcuno la progettazione di una classe dovrebbe sempre fare di loro si comportano allo stesso modo. Quando non sarebbe questo il caso? Finora, ritengo che la tua risposta per rispondere alla domanda posta. Tutto quello che hai fatto è collegato con i documenti di microsoft, che NON parlare di ciò che è diverso tra i due. non rispondere a domande essenziali: Quando sono queste diverse? Quando preferire l’uno?
    • Cordiali saluti, anni dopo, Microsoft ha finalmente giusto, e dice: “Fate in modo che Oggetto.Uguale e gli operatori di uguaglianza hanno esattamente la stessa semantica”. msdn.microsoft.com/en-us/library/vstudio/… Che è, che deve si comportano allo stesso modo. La differenza dovrebbe essere tra Object.ReferenceEquals e Object.Equals; == deve essere solo ” zucchero sintattico per Object.Equals. Che non è, probabilmente, è ora considerato come uno dei loro errori…
    • Perché è questo il accettato di rispondere? Si tratta di un terribile risposta.
    • Bisogno di descrivere ciascun tipo singolarmente, non basta dare il link.
    • Dovrebbe essere notato che se x è null (Nothing in vb.net), quindi x.Equals() genererà un’eccezione.

  2. 34
    string x = "hello";
    string y = String.Copy(x);
    string z = "hello";

    Per verificare se x punti per lo stesso oggetto y:

    (object)x == (object)y  //false
    x.ReferenceEquals(y)    //false
    x.ReferenceEquals(z)    //true (because x and z are both constants they
                            //      will point to the same location in memory)

    Per verificare se x ha lo stesso valore di stringa y:

    x == y        //true
    x == z        //true
    x.Equals(y)   //true
    y == "hello"  //true

    Si noti che questo è diverso da Java.
    In Java il == operatore non è in overload così un errore comune in Java è:

    y == "hello"  //false (y is not the same object as "hello")

    Per il confronto di stringhe in Java è necessario utilizzare sempre .equals()

    y.equals("hello")  //true
    • Per la stringa di operatore == confronta sia la stringa in base al contenuto .Ma non è questo il caso per altri tipi di riferimento
    • Voglio sottolineare quello che Vaysage appena detto: l’Utilizzo di “stringa”, come ad esempio: fuorviante (o almeno incompleta). Essa mostra come le stringhe di lavoro. Ma la stringa è un caso speciale. Per questa risposta, per essere completa, di contrasto string con: (a) di un singolo carattere, (b) un array di caratteri, (c) un struct contenenti numerosi campi di carattere, (d) un class contenenti numerosi campi di tipo carattere. Forse sarebbe anche bisogno di mostrare (e) un class contenente un struct campo o contenente una character array campo. Poi fare le varie assegnazioni, vedi quando il risultato è ancora true.
  3. 9

    Microsoft dice che classe gli esecutori devono fare == si comportano in modo più simile possibile a Equals:

    FATE in modo che Oggetto.Uguale e gli operatori di uguaglianza hanno esattamente la stessa semantica

    da http://msdn.microsoft.com/en-us/library/vstudio/7h9bszxx(v=vs. 110).aspx


    Se si vuole essere certi che si stanno ottenendo IDENTITÀ confronto (quando si confrontano i riferimenti), quindi utilizzare ReferenceEquals invece.

    Se una classe implementatore non ignorare ==, quindi metodo statico è cercato, in fase di compilazione, in classi di base. Se questa ricerca arriva Object, quindi Object.== è utilizzato. Per le classi, questo è come ReferenceEquals.

    Se la documentazione è incerto se una determinata classe (da un produttore diverso da Microsoft presumibilmente) implementa == come Equals o ReferenceEquals (o potrebbe, in teoria, essere diverso, sia di quelli),
    Io a volte evitare di ==. Invece, io uso il meno leggibile Equals(a, b) o ReferenceEquals(a, b), a seconda del significato che voglio.

    OTOH, ps2goat rende un buon punto che l’utilizzo di == evita eccezione se il primo operando è nullo (perché == è statico operatore). Questo è un argomento a favore dell’uso di ==.


    Rimosso controverso commento in merito ==


    AGGIORNAMENTO UN recente doc di Microsoft preventivo, da .Net 4.7.2 recuperati Feb. 2019, mostra che ancora intendono i due si comportano in modo simile:

    Oggetto.Metodo Equals

    Alcuni linguaggi come C# e Visual Basic supportare l’overload dell’operatore. Quando un tipo di overload dell’operatore di uguaglianza, deve anche fare l’override del metodo Equals(Object) per fornire la stessa funzionalità. Questo avviene, generalmente, scrivendo il metodo Equals(Object) in termini di sovraccarico operatore di uguaglianza, come nell’esempio seguente.


    NOTA: Vedere le altre risposte per le conseguenze di == essere un metodo statico vs Equals essere un metodo di istanza. Io non sto sostenendo comportamento è identico; sto osservando che Microsoft consiglia di fare due più simile possibile.

    • Ho aggiunto un’altra risposta, che potrebbe cambiare la vostra mente un po ‘ (non che il tuo ragionamento). Chiamata .Equals() su un oggetto null (eccezione) vs statico operatore che non richiedono operando per creare un’istanza (nessuna eccezione, funziona come previsto).
    • Risposta eccellente. Grazie. Per quanto riguarda il tuo commento altrove su questa pagina tratta di essere “perplesso perché molte di queste risposte link a quell’articolo” – è StackOverflow: non si tratta di lettura di domanda e risposta, è su quanto velocemente si può trovare qualcosa per cercare il pelo nell’uovo nella domanda stessa. Quindi, perché la persona criticando la domanda è in cima alla pagina e la tua risposta che finalmente chiarisce questo pasticcio .NET sta lottando per ottenere voti. 🙂
    • Uguale semantica uguaglianza; due oggetti possono essere uguali, ma sono molto sottili differenze. == significa che gli oggetti sono completamente intercambiabili. La differenza è molto importante quando si tratta di oggetti mutabili, perché si può cambiare uno stato dell’oggetto, e quindi il risultato è Uguale, in qualsiasi momento, ma non è possibile modificare il risultato dell’ ==. Con gli oggetti immutabili, il significato è diverso, perché è Uguale a e == non cambiare mai. Che è il motivo per cui l’override == è consigliato solo per gli oggetti immutabili. Questa differenza è fondamentale, perché quando si tratta di un oggetto mutabile, un altro thread o metodo può cambiare.
    • Microsoft documentato intento è quello di == operatore si comporta come Equals; di qui la citazione nella mia risposta. OTOH, Microsoft non impone questo. Se si, come una classe di designer sceglie di fare la distinzione è stato, nulla si ferma. Puoi descrivere un specifiche situazione in cui hai trovato questo per essere desiderabile? Inoltre, re “non è possibile modificare il risultato di ==“. Sì, è possibile; definire un overload dell’operatore == per la tua classe. Spesso si attua == come Equals; infatti, il doc di Microsoft I di riferimento consiglia di farlo.
    • Ho aggiornato la mia risposta con una quotazione che mostra Microsoft intende == e Equals per lo stesso comportamento. (Nei limiti del possibile, dato che uno è un metodo di istanza, l’altro è un metodo statico.) Avete qualche alternativa citazione che dice il contrario? Non necessariamente da Microsoft, ma da qualsiasi fonte autorevole re di buona pratica di programmazione in C#? [Come si può vedere dalla mia risposta, credo che Microsoft design non è buona, quindi sarei interessato a un’alternativa raccomandazione sostenuta da dettagli.]
    • Ho aggiunto “Se la classe implementatore non ignorare == paragrafo per coprire il caso che tu descrivi. Ma è da notare che, mentre questo è il default comportamento, è la classe implementatore. [E io la interpreto Microsoft quotazioni al di sopra, come non consigliare questo.] Re “oggetti mutabili”, se una classe implementa Equals, mi consiglia di non fare affidamento su == quando si desidera ReferenceEquals. Così facendo potrebbe essere frainteso da futuri manutentori del software. Se si esegue il test di identità uguaglianza, poi dire così esplicitamente. (FWIW, in java quello che hai detto sarebbe sempre vero.)
    • L’esatto esempio da seguire è la stringa. È possibile utilizzare == perché due stringhe identiche sono completamente intercambiabili, anche se essi non si riferiscono allo stesso oggetto. Questo perché la stringa non è modificabile classe. In contrasto, StringBuilder non override == perché è possibile modificare il contenuto di uno StringBuilder. Questo perché StringBuilder è mutevole.
    • Onestamente, sto cercando di trovare la spec che ho letto circa 10 anni fa sul vecchio MSDN. Era piuttosto chiaro che == stato per le situazioni in cui gli oggetti sono completamente intercambiabili. (Immutables, o situazioni in cui un modello di gestione degli eventi propaga le modifiche tra gli oggetti.) Non trovo che la Microsoft più recente documentazione. La regola generale di pollice, però, è che si deve solo sovraccarico == se l’utente di un oggetto di interscambio due oggetti where == è vero. Tale regola non si applica Equals(), però.
    • La mia risposta a stackoverflow.com/a/54892972/1711103 ha esempi completi di utilizzo == versus è Uguale.
    • eccellente spiegazione. Chiarisce, inoltre, per me che quando si commenta su quello “==” dovrebbe significa, diceva che da un punto di vista la matematica, (non necessariamente da Microsoft misto-messaggi su questo argomento)! Sono totalmente d’accordo con la tua analisi – ho sempre considerato questo punto un significativo errore di Microsoft. [Ho seguito OO lingue più a lungo rispetto alla maggior parte delle persone sono state vivo – presto dovrei essere in grado di andare in pensione e contribuire a strumenti che aiutano a migliorare la programmazione OO tecniche.]

  4. 5

    Stavo per postare questo come commento all’accettato di rispondere, ma credo che questo merita di essere considerato quando si determina quale strada prendere.

    dotnetfiddle: https://dotnetfiddle.net/gESLzO

    Violino codice:

        Object a = null;
        Object b = new Object();
    
        //Ex 1
        Console.WriteLine(a == b);
        //Ex 2
        Console.WriteLine(b == a);
    
        //Ex 3     
        Console.WriteLine(b.Equals(a));
        //Ex 4
        Console.WriteLine(a.Equals(b));

    I primi 3 WriteLine esempi di lavoro, ma la quarta genera un’eccezione. 1 e 2 utilizzare ==, che è un metodo statico che non richiedono l’oggetto istanziato.

    Esempio 3 funziona perché b viene creata un’istanza.

    Esempio 4 non riesce perché a è null, e quindi un metodo non può essere invocato su un oggetto null.

    Perché cerco di codice come pigramente possibile, io uso ==, soprattutto quando si lavora con gli scenari in cui uno dei due oggetti (o entrambi) può essere null. Se non, mi piacerebbe fare un controllo null, prima, prima di essere in grado di chiamare .Equals().

    • Si noti che questo si verifica ancora con le stringhe, come bene. E, naturalmente, l’operatore potrebbe essere sostituito, ma l’essenza di questa risposta è che gli operatori sono statici e non richiedono non-null istanze per uno dei due operandi.
  5. 1

    La mia comprensione di usi e di entrambi era questo: uso == concettuale di uguaglianza (nel contesto di questi due argomenti significano la stessa cosa?), e .Uguale per la concreta parità (sono questi i due argomenti in realtà l’esatto stesso oggetto?).

    Edit: Kevin Sheffield articolo linkato fa un lavoro migliore di spiegare il valore di vs riferimento uguaglianza…

    • D’accordo, ma che non suoni come una buona regola del pollice.
    • Non corretto. ReferenceEquals è il identity test .Net. Se Equals sempre fatto un test di identità, quindi non ci sarebbe nessun punto di avere entrambi…
    • È l’opposto. == per la concreta parità e pari concettuale uguaglianza.
  6. 1

    Per rispondere a questo, dobbiamo descrivere i quattro tipi di oggetto di equivalenza:

    1. Di riferimento Uguaglianza, oggetto.ReferenceEquals(a, b): Le due variabili punto lo stesso oggetto in RAM. (Se questa fosse la C, entrambe le variabili hanno lo stesso esatto puntatore.)

    2. Intercambiabilità, a == b: Le due variabili si riferiscono a oggetti che sono completamente intercambiabili. Così, quando a == b, Func(a,b) e Func(b,a) fare la stessa cosa.

    3. Semantica di Uguaglianza, di oggetto.È uguale a(a, b): In questo esatto momento, i due oggetti che significano la stessa cosa.

    4. Entità uguaglianza.Id == b.Id: I due oggetti che si riferiscono alla stessa entità, come una riga del database, ma non hanno lo stesso contenuto.

    Come programmatore, quando si lavora con un oggetto di un tipo noto, è necessario capire il tipo di equivalenza che è appropriato per il vostro business logic in questo specifico momento di codice che sei.

    L’esempio più semplice di questo è la stringa contro StringBuilder tipi. Stringa sostituisce ==, StringBuilder non:

    var aaa1 = "aaa";
    var aaa2 = $"{'a'}{'a'}{'a'}";
    var bbb = "bbb";
    
    //False because aaa1 and aaa2 are completely different objects with different locations in RAM
    Console.WriteLine($"Object.ReferenceEquals(aaa1, aaa2): {Object.ReferenceEquals(aaa1, aaa2)}");
    
    //True because aaa1 and aaa2 are completely interchangable
    Console.WriteLine($"aaa1 == aaa2: {aaa1 == aaa2}");             //True
    Console.WriteLine($"aaa1.Equals(aaa2): {aaa1.Equals(aaa2)}");   //True
    Console.WriteLine($"aaa1 == bbb: {aaa1 == bbb}");               //False
    Console.WriteLine($"aaa1.Equals(bbb): {aaa1.Equals(bbb)}");     //False
    
    //Won't compile
    //This is why string can override ==, you can not modify a string object once it is allocated
    //aaa1[0] = 'd';
    
    //aaaUpdated and aaa1 point to the same exact object in RAM
    var aaaUpdated = aaa1;
    Console.WriteLine($"Object.ReferenceEquals(aaa1, aaaUpdated): {Object.ReferenceEquals(aaa1, aaaUpdated)}"); //True
    
    //aaaUpdated is a new string, aaa1 is unmodified
    aaaUpdated += 'c';
    Console.WriteLine($"Object.ReferenceEquals(aaa1, aaaUpdated): {Object.ReferenceEquals(aaa1, aaaUpdated)}"); //False
    
    var aaaBuilder1 = new StringBuilder("aaa");
    var aaaBuilder2 = new StringBuilder("aaa");
    
    //False, because both string builders are different objects
    Console.WriteLine($"Object.ReferenceEquals(aaaBuider1, aaaBuider2): {Object.ReferenceEquals(aaa1, aaa2)}");
    
    //Even though both string builders have the same contents, they are not interchangable
    //Thus, == is false
    Console.WriteLine($"aaaBuider1 == aaaBuilder2: {aaaBuilder1 == aaaBuilder2}");
    
    //But, because they both have "aaa" at this exact moment in time, Equals returns true
    Console.WriteLine($"aaaBuider1.Equals(aaaBuilder2): {aaaBuilder1.Equals(aaaBuilder2)}");
    
    //Modifying the contents of the string builders changes the strings, and thus
    //Equals returns false
    aaaBuilder1.Append('e');
    aaaBuilder2.Append('f');
    Console.WriteLine($"aaaBuider1.Equals(aaaBuilder2): {aaaBuilder1.Equals(aaaBuilder2)}");

    Per entrare in ulteriori dettagli, siamo in grado di lavorare a ritroso, a partire con l’entità dell’uguaglianza. Nel caso di entità di uguaglianza, di proprietà dell’ente, possono cambiare nel tempo, ma l’entità della chiave primaria non cambia mai. Questo può essere dimostrato con pseudocodice:

    //Hold the current user object in a variable
    var originalUser = database.GetUser(123);
    
    //Update the user’s name
    database.UpdateUserName(123, user.Name + "son");
    
    var updatedUser = database.GetUser(123);
    
    Console.WriteLine(originalUser.Id == updatedUser.Id); //True, both objects refer to the same entity
    Console.WriteLine(Object.Equals(originalUser, updatedUser); //False, the name property is different

    Movimento semantiche in parità, l’esempio cambia leggermente:

    var originalUser = new User() { Name = "George" };
    var updatedUser = new User() { Name = "George" };
    
    Console.WriteLine(Object.Equals(originalUser, updatedUser); //True, the objects have the same contents
    Console.WriteLine(originalUser == updatedUser); //User doesn’t define ==, False
    
    updatedUser.Name = "Paul";
    
    Console.WriteLine(Object.Equals(originalUser, updatedUser); //False, the name property is different

    Che cosa circa l’intercambiabilità? (override ==) Che è più complicato. Costruiamo su l’esempio di cui sopra un po’:

    var originalUser = new User() { Name = "George" };
    var updatedUser = new User() { Name = "George" };
    Console.WriteLine(Object.Equals(originalUser, updatedUser); //True, the objects have the same contents
    
    //Does this change updatedUser? We don’t know
    DoSomethingWith(updatedUser);
    
    //Are the following equivalent?
    //SomeMethod(originalUser, updatedUser);
    //SomeMethod(updatedUser, originalUser);

    Nell’esempio di cui sopra, DoSomethingWithUser(updatedUser) potrebbe cambiare updatedUser. Così possiamo più garantire che il originalUser e updatedUser oggetti sono “Uguali”. Questo è il motivo per cui l’Utente non override ==.

    Un buon esempio per quando override == è con oggetti immutabili. Un immutabile oggetto è un oggetto che è pubblicamente visibile stato (proprietà) non cambiano mai. L’intero stato visibile deve essere impostato nel costruttore dell’oggetto. (Così, tutte le proprietà sono di sola lettura.)

    var originalImmutableUser = new ImmutableUser(name: "George");
    var secondImmutableUser = new ImmutableUser(name: "George");
    
    Console.WriteLine(Object.Equals(originalImmutableUser, secondImmutableUser); //True, the objects have the same contents
    Console.WriteLine(originalImmutableUser == secondImmutableUser); //ImmutableUser defines ==, True
    
    //Won’t compile because ImmutableUser has no setters
    secondImmutableUser.Name = "Paul";
    
    //But this does compile
    var updatedImmutableUser = secondImmutableUser.SetName("Paul"); //Returns a copy of secondImmutableUser with Name changed to Paul.
    
    Console.WriteLine(object.ReferenceEquals(updatedImmutableUser, secondImmutableUser)); //False, because updatedImmutableUser is a different object in a different location in RAM
    
    //These two calls are equivalent because the internal state of an ImmutableUser can never change
    DoSomethingWith(originalImmutableUser, secondImmutableUser);
    DoSomethingWith(secondImmutableUser, originalImmutableUser);

    Si dovrebbe ignorare == con un oggetto mutabile? (Che è, un oggetto che è stato interno può cambiare?) Probabilmente non. Si avrebbe bisogno di costruire un quadro piuttosto complesso sistema di eventi per mantenere l’intercambiabilità.

    In generale, io lavoro con un sacco di codice che utilizza oggetti immutabili, così ho override == perché è più leggibile di oggetto.È uguale. Quando lavoro con oggetti mutabili, io non override == e si basano su un oggetto.È uguale. Il suo compito del programmatore per sapere se gli oggetti a cui si sta lavorando sono modificabili o non, perché sapere se qualcosa è stato possibile cambiare deve influenzare il modo in cui si progetta il tuo codice.

    L’implementazione di default == oggetto.ReferenceEquals perché, con oggetti mutabili, l’intercambiabilità è garantita solo quando il punto di variabili stesso esatto dell’oggetto in RAM. Anche se gli oggetti hanno lo stesso contenuto in un dato punto nel tempo, (Uguale restituisce true) non vi è alcuna garanzia che gli oggetti continuano ad essere uguali; quindi gli oggetti non sono intercambiabili. Così, quando si lavora con un oggetto mutabile che non override ==, l’implementazione di default == opere, perché se a == b, sono lo stesso oggetto, e SomeFunc(a, b) e SomeFunc(b, a) sono esattamente le stesse.

    Inoltre, se in una classe non definire l’equivalenza (Per esempio, pensare a una connessione di database e aprire il file handle, ect,) quindi l’implementazione di default == e è Uguale a cadere di nuovo a riferimento l’uguaglianza, perché due variabili di tipo di connessione al database, aprire il file di gestire, ect, sono solo uguali anche se sono l’esatto esempio di connessione con il database, aprire il file di gestire, ect. Entità uguaglianza potrebbe avere un senso nella logica di business che ha bisogno di sapere che due diverse connessioni di database, fare riferimento alla stessa base di dati, o che due diversi handle di file fanno riferimento allo stesso file su disco.

    Ora, per il mio soapbox momento. A mio parere, C# gestisce questo argomento in modo confuso. == dovrebbe essere per semantico uguaglianza, anziché il metodo Equals. Ci dovrebbe essere un operatore differente, come ===, per l’intercambiabilità, e, potenzialmente, un altro operatore ====, per referenziale uguaglianza. In questo modo, qualcuno che è un novizio, e /o la scrittura di CRUD applicazioni, ha solo bisogno di capire ==, e non il più ricco di dettagli di intercambiabilità e referenziale uguaglianza.

  7. 0

    È possibile che si desidera utilizzare .Equivale a qualcuno potrebbe venire insieme in un secondo momento e sovraccarico per la classe.

    • Ma non sarebbe una buona cosa?
    • Sì, penso che intendevo dire il contrario.
  8. -1

    Due dei più usati tipi, String e Int32, implementare sia l’operatore==() e Equals() come valore di uguaglianza (invece di uguaglianza di riferimento). Penso che si può considerare queste due definizione di esempi, quindi la mia conclusione è che entrambi sono identici significati. Se Microsoft stati altrimenti, penso che siano intenzionalmente a causa di confusione.

    • All’interno di .net, i tipi di ignorare l’uguaglianza/disuguaglianza operatori di fare in modo di imporre l’uguaglianza di valori, ma C# aggiunge il proprio sovraccarico di uguaglianza/disuguaglianza agli operatori di verificare il riferimento uguaglianza di oggetti che non presentano un valore-test di uguaglianza. Personalmente, non mi piace, ad un linguaggio di design (vb.net utilizza gli operatori Is e IsNot di riferimento della prova di uguaglianza; quando è applicato a tipi di Framework, = e <> avrà valore di prova uguaglianza se si compilare. Non c’è niente per evitare qualsiasi tipo di sovraccaricare gli operatori a significare qualcosa di completamente diverso, comunque.
  9. -1

    Operatore == e Equals() entrambi sono uguali, mentre ci stiamo confrontando invece i valori di riferimento. L’uscita di entrambi sono uguali vedi sotto esempio.

    Esempio

        static void Main()
        {
            string x = " hello";
            string y = " hello";
            string z = string.Copy(x);
            if (x == y)
            {
                Console.WriteLine("== Operator");
            }
            if(x.Equals(y))
            {
                Console.WriteLine("Equals() Function Call");
            }
            if (x == z)
            {
                Console.WriteLine("== Operator while coping a string to another.");
            }
            if (x.Equals(y))
            {
                Console.WriteLine("Equals() Function Call while coping a string to another.");
            }
        }

    Di uscita:

      == Operator
      Equals() Function Call
      == Operator while coping a string to another.
      Equals() Function Call while coping a string to another.

Lascia un commento