Usar operadores iguales en C#

Question

En una instrucción if ¿Cuándo debería usar =, == operadores? ¿Hay un operador ===? ¿Cuál es la diferencia entre estos operadores?

Answer 1

= es la asignación, como en

var i = 5; 

No utilice este operador en la sentencia if.

== es para la comparación como en

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

no hay === operador en C#

Answer 2

una sola = es para la asignación como:

String myString = "Hi There"; 

Un doble es igual para la comparación

if (5 == 5) 
{ 
    do something 
} 

iguales triples en algunos idiomas significan exactamente iguales.

C# no utiliza ese operador.

Answer 3

Un signo de igualdad sólo se utiliza para asignar una variable de un valor, el La asignación también devolverá el mismo valor para que pueda usarse en una declaración if pero nunca (casi ...) se debe usar en una instrucción if. Los signos dobles iguales se usan para probar si dos valores son iguales y es lo que usa la mayor parte del tiempo. No sé de un operador ===.

/Viktor

Answer 4

En caso de declaración por lo general comprobar la igualdad usando ==, el operador = es el operador assignemt, y por mi conocimiento no hay === en C# que nunca he oído hablar de él, pero existe en otros idiomas, creo que en JavaScript lo hace.

Answer 5

= es un operador asignación mientras
== es un operador comparación

Ejemplo:

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

mientras

int a=2; 
int b=3; 

bool c= a==b // c = false since result of a==b is false 

Answer 6

Además de las otras respuestas, ReferenceEquals(x,y) es probablemente lo más parecido a ===.

Answer 7

Para información adicional, el operador Not Equal es !=.

Más información sobre Operadores # C: http://msdn.microsoft.com/en-us/library/6a71f45d%28v=VS.100%29.aspx

Answer 8

me encontré con === sólo en javascript todavía. Es el operador igual estricto allí. he usado varias veces ya que este if(obj === undefined){ alert("obj has sublimed");}

Answer 9

(Lo que sigue es algo de un "comentario" pero es demasiado largo para estar en un comentario y se perdería con los otros comentarios en este post.)

En C# == (como todos los operadores en C#) no es polimórfico. Es decir, la "versión" de == que se llama siempre se basa en el tipo estático en tiempo de compilación.

Por ejemplo:

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

El Equalsmétodo virtual, por otro lado, se define en object y por tanto es polimórfico en todos los subtipos.

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

La elección de cuál utilizar (o ==Equals) es a veces sutil - pero importante. La mayoría de los tipos de colecciones se utilizan para tareas como EqualsContains, etc (esto es prácticamente necesario para todos los contenedores genéricos ya que no hay T.== de un tipo arbitrario T.)

// compile-time error: Operator '==' cannot be applied to operands of type 'T' and 'T' 
bool equals<T> (T a, T b) { return a == b; } 

// fair-game, because object defines Equals and it's polymorphic to subtypes 
bool equals<T> (T a, T b) { return a.Equals(b); } 

Ver When should I use == and when should I use Equals? y Guidelines for Implementing Equals and the Equality Operator (==), etc. Personalmente , utilizo == sobre Equals para tipos concretos estáticamente-resolubles para el que está bien definido == y yo voluntad no (por contrato o convención) se refieren a un subtipo - ejemplos son string y tipos (la mayoría) de la estructura (por ejemplo, int, Guid).

Happy coding.

Editar: No hay operador C# === (como se ha dicho, ¡duh!). Si hablar de la variante de JavaScript, que sería aproximadamente:

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

(Es igualdad estricta en JavaScript - pero no objeto de identidad).

Si hablar de la identidad del objeto entonces debería ser el mismo que (object)a == (object)b que tiene la misma semántica que object.ReferenceEquals(a,b).

Answer 10

Esto es anhelar un comentario, así que decidí agregar otra publicación.

que establecer variables var a una lista de objetos esto y lleva a cabo una comparación de los dos vars que siempre fallaron lógica de comparación:

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

Gracias a los puestos aquí en este hilo, he cambiado la lógica de la siguiente manera y ahora funciona perfectamente:

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