c# - when - Reemplazando el método Equals en Structs

structures in c#

Question

He buscado directrices generales para las estructuras, pero todo lo que puedo encontrar es para las clases.

Al principio pensé que no tendría que verificar si el objeto pasado era nulo, ya que las estructuras son tipos de valores y no pueden ser nulas. Pero ahora que lo pienso, igual que la firma es

public bool Equals(object obj)

parece que no hay nada que impida que el usuario de mi estructura intente compararlo con un tipo de referencia arbitrario.

Mi segundo punto se refiere al casting que (creo que) debo hacer antes de comparar mis campos privados en mi estructura. ¿Cómo se supone que voy a lanzar el objeto al tipo de mi estructura? C # as palabra clave parece ser solo adecuado para los tipos de referencia.

Answer 1

Agregando a las respuestas existentes.

Aún puede tener valores que aceptan valores de null si agrega un? después del nombre de la estructura (esto funciona para cada objeto de valor)

int?

La (MyStructName)variableName también se realiza llamando a (MyStructName)variableName

Answer 2

En caso de que alguien se pregunte sobre el rendimiento alcanzado al encajonar la estructura en un objeto Nullable (para evitar la verificación del tipo doble de is y the cast), hay una sobrecarga no despreciable.

tl; dr : El uso is & cast en este escenario.

struct Foo : IEquatable<Foo>
{
public int a, b;
public Foo(int a, int b)
{
this.a = a;
this.b = b;
}
public override bool Equals(object obj)
{
#if BOXING
var obj_ = obj as Foo?;
return obj_ != null && Equals(obj_.Value);
#elif DOUBLECHECK
return obj is Foo && Equals((Foo)obj);
#elif MAGIC
?
#endif
}
public bool Equals(Foo other)
{
return a == other.a && b == other.b;
}
}
class Program
{
static void Main(string[] args)
{
RunBenchmark(new Foo(42, 43), new Foo(42, 43));
RunBenchmark(new Foo(42, 43), new Foo(43, 44));
}
static void RunBenchmark(object x, object y)
{
var sw = Stopwatch.StartNew();
for (var i = 0; i < 100000000; i++) x.Equals(y);
sw.Stop();
Console.WriteLine(sw.ElapsedMilliseconds);
}
}

Resultados:

BOXING
EQ 8012 7973 7981 8000
NEQ 7929 7715 7906 7888
DOUBLECHECK
EQ 3654 3650 3638 3605
NEQ 3310 3301 3319 3297

Advertencia: esta prueba puede tener fallas de muchas maneras, aunque sí verifiqué que el código de referencia en sí mismo no estaba optimizado de manera extraña.

Mirando el IL, el método de doble verificación compila un poco más limpio.

Boxeo IL:

.method public hidebysig virtual
instance bool Equals (
object obj
) cil managed
{
// Method begins at RVA 0x2060
// Code size 37 (0x25)
.maxstack 2
.locals init (
[0] valuetype [mscorlib]System.Nullable`1<valuetype StructIEqualsImpl.Foo> obj_
)
IL_0000: ldarg.1
IL_0001: isinst valuetype [mscorlib]System.Nullable`1<valuetype StructIEqualsImpl.Foo>
IL_0006: unbox.any valuetype [mscorlib]System.Nullable`1<valuetype StructIEqualsImpl.Foo>
IL_000b: stloc.0
IL_000c: ldloca.s obj_
IL_000e: call instance bool valuetype [mscorlib]System.Nullable`1<valuetype StructIEqualsImpl.Foo>::get_HasValue()
IL_0013: brfalse.s IL_0023
IL_0015: ldarg.0
IL_0016: ldloca.s obj_
IL_0018: call instance !0 valuetype [mscorlib]System.Nullable`1<valuetype StructIEqualsImpl.Foo>::get_Value()
IL_001d: call instance bool StructIEqualsImpl.Foo::Equals(valuetype StructIEqualsImpl.Foo)
IL_0022: ret
IL_0023: ldc.i4.0
IL_0024: ret
} // end of method Foo::Equals

Verificación doble IL:

.method public hidebysig virtual
instance bool Equals (
object obj
) cil managed
{
// Method begins at RVA 0x2060
// Code size 23 (0x17)
.maxstack 8
IL_0000: ldarg.1
IL_0001: isinst StructIEqualsImpl.Foo
IL_0006: brfalse.s IL_0015
IL_0008: ldarg.0
IL_0009: ldarg.1
IL_000a: unbox.any StructIEqualsImpl.Foo
IL_000f: call instance bool StructIEqualsImpl.Foo::Equals(valuetype StructIEqualsImpl.Foo)
IL_0014: ret
IL_0015: ldc.i4.0
IL_0016: ret
} // end of method Foo::Equals

Apoyos a Roman Reiner por detectar un error que realmente no me hacía quedar bien.

Answer 3

Gracias a algunas noticias en C # 7.0 hay una manera más fácil de lograr lo mismo que una respuesta aceptada:

struct MyStruct
{
public override bool Equals(object obj)
{
if (!(obj is MyStruct mys)) // type pattern here
return false;
return this.field1 == mys.field1 && this.field2 == mys.field2 // mys is already known here without explicit casting
}
}

O mi favorito - lo mismo que la función cuerpo de expresión:

struct MyStruct
{
public override bool Equals(object obj) =>
obj is MyStruct mys
? true // the initial "true" doesn''t affect the overall boolean operation yet allows nice line aligning below
&& this.field1 == mys.field1
&& this.field2 == mys.field2
: false; // obj is not MyStruct
}

Answer 4

Supongo que si uno usa .NET 4.5 , uno puede usar la implementación predeterminada como se indica en la documentation :

Cuando define su propio tipo, ese tipo hereda la funcionalidad definida por el método Equals de su tipo base.

ValueType.Equals : Value equality; ya sea una comparación directa byte por byte o una comparación campo por campo usando la reflexión.

Answer 5

Use el operador is :

public bool Equals(object obj)
{
if (obj is MyStruct)
{
var o = (MyStruct)obj;
...
}
}

Answer 6

struct MyStruct
{
public override bool Equals(object obj)
{
if (!(obj is MyStruct))
return false;
MyStruct mys = (MyStruct) obj;
// compare elements here
}
}