ejemplos - int equals c#
== o.Equals() (12)
== es generalmente la "identidad" igual a significado "objeto a es de hecho el mismo objeto exacto en la memoria que el objeto b".
equals () significa que los objetos son lógicamente iguales (por ejemplo, desde un punto de vista comercial). Entonces, si está comparando instancias de una clase definida por el usuario, generalmente necesitará usar y definir equals () si desea que cosas como una Hashtable funcionen correctamente.
Si tuviera la clase de Persona proverbial con las propiedades "Nombre" y "Dirección" y quisiera utilizar esta Persona como clave en una Hashtable que contenga más información sobre ellas, deberá implementar equals () (y hash) para que pueda podría crear una instancia de una Persona y usarla como clave en la Hashtable para obtener la información.
Usando == solo, su nueva instancia no sería la misma.
¿Por qué usar uno sobre el otro?
== es la prueba de identidad. Volverá a ser verdadero si los dos objetos que se están probando son de hecho el mismo objeto. Equals() realiza una prueba de igualdad y devolverá true si los dos objetos se consideran iguales.
Las pruebas de identidad son más rápidas, por lo que puede usarlas cuando no haya necesidad de pruebas de igualdad más costosas. Por ejemplo, comparando contra null o la cadena vacía.
Es posible sobrecargar cualquiera de estos para proporcionar un comportamiento diferente, como pruebas de identidad para Equals() , pero por el bien de cualquiera que lea su código, no lo haga.
A continuación: Algunos tipos como String o DateTime proporcionan sobrecargas para el operador == que le da semántica de igualdad. Entonces, el comportamiento exacto dependerá de los tipos de objetos que comparas.
Ver también:
@John Millikin:
Señalado a continuación: algunos tipos de valores como DateTime proporcionan sobrecargas para el operador == que le dan semántica de igualdad. Entonces, el comportamiento exacto dependerá de los tipos de objetos que esté comparando.
Elaborar:
DateTime se implementa como una estructura. Todas las estructuras son hijos de System.ValueType.
Dado que los hijos de System.ValueType viven en la pila, no hay un puntero de referencia para el montón, y por lo tanto no hay forma de hacer una verificación de referencia, debe comparar objetos por valor solamente.
System.ValueType anula .Equals () y == para usar una comprobación de igualdad basada en la reflexión, utiliza la reflexión para comparar el valor de cada campo.
Como la reflexión es algo lenta, si implementa su propia estructura, es importante sobrescribir .Equals () y agregar su propio código de comprobación de valores, ya que será mucho más rápido. No solo llame a base.Equals ();
De acuerdo con MSDN :
En C #, hay dos tipos diferentes de igualdad: igualdad de referencia (también conocida como identidad) e igualdad de valor. La igualdad de valores es el significado generalmente entendido de la igualdad: significa que dos objetos contienen los mismos valores. Por ejemplo, dos enteros con el valor de 2 tienen valor de igualdad. La igualdad de referencia significa que no hay dos objetos para comparar. En cambio, hay dos referencias a objetos y ambas se refieren al mismo objeto.
...
Por defecto, el operador == prueba la igualdad de referencia al determinar si dos referencias indican el mismo objeto.
El ejemplo es porque la clase DateTime implementa la interfaz IEquatable, que implementa un "método específico de tipo para determinar la igualdad de instancias". de acuerdo con MSDN .
En la mayoría de los casos, son iguales, por lo que debe usar == para mayor claridad. De acuerdo con las pautas de diseño de Microsoft Framework:
" ASEGÚRESE de que Object.Equals y los operadores de igualdad tengan exactamente la misma semántica y características de rendimiento similares". docs.microsoft.com/en-us/dotnet/standard/design-guidelines/…
Pero a veces, alguien anulará Object.Equals sin proporcionar operadores de igualdad. En ese caso, debe usar Igual para probar la igualdad de valores, y Object.ReferenceEquals para probar la igualdad de referencia.
He visto Object.ReferenceEquals () usado en casos donde uno quiere saber si dos referencias se refieren al mismo objeto
Otra cosa a tener en cuenta: el operador == puede no ser invocable o puede tener un significado diferente si accede al objeto desde otro idioma. Por lo general, es mejor tener una alternativa que pueda llamarse por su nombre.
Si desmontas (por dotPeek por ejemplo) de Object, entonces
public virtual bool Equals(Object obj)
descrito como:
// Returns a boolean indicating if the passed in object obj is
// Equal to this. Equality is defined as object equality for reference
// types and bitwise equality for value types using a loader trick to
// replace Equals with EqualsValue for value types).
//
Entonces, depende del tipo. Por ejemplo:
Object o1 = "vvv";
Object o2 = "vvv";
bool b = o1.Equals(o2);
o1 = 555;
o2 = 555;
b = o1.Equals(o2);
o1 = new List<int> { 1, 2, 3 };
o2 = new List<int> { 1, 2, 3 };
b = o1.Equals(o2);
La primera vez b es verdadera (igual realizada en los tipos de valores), la segunda vez b es verdadera (igual en los tipos de valores), la tercera vez b es falsa (igual en los tipos de referencia).
Tanto Equals como == pueden estar sobrecargados, por lo que los resultados exactos de llamar a uno u otro variarán. Tenga en cuenta que == se determina en tiempo de compilación, por lo que aunque la implementación real podría cambiar, lo que == se usa se fija en tiempo de compilación, a diferencia de Equals que podría usar una implementación diferente basada en el tipo de tiempo de ejecución del lado izquierdo.
Por ejemplo, string realiza una prueba de igualdad para == .
También tenga en cuenta que la semántica de ambos puede ser complex .
La mejor práctica es implementar la igualdad como este ejemplo. Tenga en cuenta que puede simplificar o excluir todo esto dependiendo de cómo planea usar su clase, y esa struct ya ha struct la mayor parte de esto.
class ClassName
{
public bool Equals(ClassName other)
{
if (other == null)
{
return false;
}
else
{
//Do your equality test here.
}
}
public override bool Equals(object obj)
{
ClassName other = obj as null; //Null and non-ClassName objects will both become null
if (obj == null)
{
return false;
}
else
{
return Equals(other);
}
}
public bool operator ==(ClassName left, ClassName right)
{
if (left == null)
{
return right == null;
}
else
{
return left.Equals(right);
}
}
public bool operator !=(ClassName left, ClassName right)
{
if (left == null)
{
return right != null;
}
else
{
return !left.Equals(right);
}
}
public override int GetHashCode()
{
//Return something useful here, typically all members shifted or XORed together works
}
}
Todos los demás prácticamente tienen cobertura, pero tengo un consejo más. De vez en cuando, obtendrá a alguien que jura sobre su vida (y la de sus seres queridos) que .Equals es más eficiente / mejor / mejor práctica o alguna otra línea dogmática. No puedo hablar de eficiencia (bueno, está bien, en ciertas circunstancias sí puedo), pero puedo hablar sobre un gran problema que surgirá: .Equals requiere que .Equals un objeto. (Suena estúpido, pero arroja a la gente).
No puedes hacer lo siguiente:
StringBuilder sb = null;
if (sb.Equals(null))
{
// whatever
}
Me parece obvio, y tal vez la mayoría de la gente, que obtendrá una NullReferenceException . Sin embargo, los defensores de .Equals olvidan de ese pequeño factoid. Algunos incluso son "arrojados" (lo siento, no pudieron resistir) cuando ven que los NullRefs comienzan a aparecer.
(Y años antes de la publicación de DailyWTF , realmente DailyWTF con alguien que ordenó que todos los controles de igualdad fueran .Equals lugar de == . Incluso demostrando que su imprecisión no ayudaba. Nos aseguramos de romper todas sus otras reglas para que ninguna referencia devuelta por un método ni propiedad alguna vez fue nula, y funcionó al final).
use equal si desea expresar el contenido de los objetos comparados debe ser igual. use == para valores primitivos o si desea verificar que los objetos que se comparan sean uno y el mismo objeto. Para objetos == verifica si el puntero de dirección de los objetos es el mismo.