Usando operatori uguali in C #

In una dichiarazione If quando dovrei usare =, == operatori. Esiste un operatore ===? Qual è la differenza tra questi operatori?

= è l’assegnazione, come in

var i = 5; 

Non utilizzare questo operatore nell’istruzione if.

== è per il confronto come in

 if(i == 6){...} 

non c’è operatore === in C #

(Quanto segue è in qualche modo un “commento” ma è troppo lungo per essere inserito in un commento e andrebbe perso con gli altri commenti in questo post.)

In C # == (come tutti gli operatori in C #) non è polimorfico. Cioè, la “versione” di == che viene chiamata è sempre basata sul tipo statico in fase di compilazione.

Per esempio:

 object a = Guid.NewGuid(); object b = new Guid(""+a); a == b // false -- uses object.== -- an *identity* compare 

Il metodo virtuale Equals , d’altra parte, è definito object ed è quindi polimorfico in tutti i sottotipi.

 object a = Guid.NewGuid(); object b = new Guid(""+a); a.Equals(b) // true -- uses Guid.Equals 

La scelta di quale usare ( == o Equals ) è a volte sottile – ma importante. La maggior parte dei tipi di raccolta utilizzerà Equals per attività come Contains , ecc. (Questo è praticamente richiesto per tutti i contenitori generici in quanto non esiste T.== per un tipo arbitrario T )

 // compile-time error: Operator '==' cannot be applied to operands of type 'T' and 'T' bool equals (T a, T b) { return a == b; } // fair-game, because object defines Equals and it's polymorphic to subtypes bool equals (T a, T b) { return a.Equals(b); } 

Vedere Quando dovrei usare == e quando dovrei usare Equals? e linee guida per l’implementazione di Equals e l’operatore di uguaglianza (==) , ecc. Personalmente, utilizzo == su Equals per tipi di calcestruzzo risolvibili staticamente per i quali == è ben definito e non lo farò (per contratto o convenzione) con un sottotipo: gli esempi sono string e (la maggior parte) tipi di struttura (es. int , Guid ).

Buona programmazione.

Modifica: non esiste un operatore C # === (come hanno detto le persone, duh!). Se si parla della variante JavaScript, sarebbe approssimativamente:

 bool trippleEquals (object a, object b) { return a.GetType() == b.GetType() && a.Equals(b); } 

un’eguaglianza rigorosa in JavaScript, ma non l’identity framework dell’object ).

Se si parla dell’id quadro dell’object allora dovrebbe essere uguale a (object)a == (object)b che ha la stessa semantica object.ReferenceEquals(a,b) .

una singola = è per un incarico come:

 String myString = "Hi There"; 

Una doppia parità è per il confronto

 if (5 == 5) { do something } 

il triplo equivale in alcune lingue significa esattamente uguale.

C # non utilizza quell’operatore.

Oltre alle altre risposte, ReferenceEquals(x,y) è probabilmente la cosa più vicina a === .

Nell’istruzione if di solito controlli l’uguaglianza usando ==, l’operatore = è l’operatore assignemt, e per mia conoscenza non c’è === in c # non ne ho mai sentito parlare ma esiste in altre lingue credo in javascript lo fa.

Un segno di uguale viene utilizzato solo per assegnare una variabile a un valore, l’assegnazione restituirà anche lo stesso valore in modo da poter essere utilizzata in un’istruzione if, ma non dovrebbe mai (quasi …) essere utilizzata in un’istruzione if. Doppi segni di uguale vengono utilizzati per verificare se due valori sono uguali ed è ciò che si usa la maggior parte del tempo. Non conosco un operatore ===.

/ Viktor

= è un operatore di assegnazione mentre
== è un operatore di comparazione

Esempio:

 int a=2; int b=3; int c=a=b; // a, b, c is equal to 3 as b=3 

mentre

 int a=2; int b=3; bool c= a==b // c = false since result of a==b is false 

Per informazioni extra, l’operatore Non uguale è != .

Maggiori informazioni sugli operatori C #: http://msdn.microsoft.com/en-us/library/6a71f45d%28v=VS.100%29.aspx

Mi sono imbattuto in === solo in javascript ancora. È il rigoroso operatore di parità in là. L’ho usato più volte in questo if(obj === undefined){ alert("obj has sublimed");}

Questo è troppo lungo per un commento, quindi ho deciso di aggiungere un altro post.

Ho impostato var variabili su un elenco di oggetti e ho eseguito un confronto sulle due vars che hanno sempre fallito la logica di confronto:

  object Object1; object Object2; var v1 = Object1; var v2 = Object2; if (v1 != v2) { // Do something } 

Grazie ai post qui in questo thread, ho modificato la logica come segue e ora funziona perfettamente:

  object Object1; object Object2; var v1 = Object1; var v2 = Object2; if (!v1.Equals(v2)) { // Do something }