generate - params comments c#

¿Qué significa esta sobrecarga?

Question

¿Puede alguien explicarme qué significa esta sobrecarga?

public static bool operator ==(Shop lhs, Shop rhs)
{
    if (Object.ReferenceEquals(lhs, null))
    {
        if (Object.ReferenceEquals(rhs, null))
        {
            return true;
        }
        return false;
    }

    return lhs.Equals(rhs);
}

Nunca he visto Object.ReferenceEquals en sobrecarga

Answer 1

Es muy fácil. "NULL" en realidad es un objeto que reside en la memoria y tiene una referencia y se puede configurar para cualquier objeto que sea una subclase de la clase "Objeto" de Base.

Por lo tanto, el código anterior comprueba primero que ambos objetos "Comprar" son igualmente nulos al comparar su valor de referencia con la referencia a objetos "nulos", si ambos son iguales a nulos, son iguales y devuelven True.

Si solo el primer objeto es nulo y el segundo no, devuelve falso.

Y finalmente, si el primer objeto Shop no es nulo, el código supone que el segundo no es nulo y compara su instancia con el objeto Shop para verificar que sean iguales.

Y la razón principal por la que no usamos esta forma de comparar objetos nulos es porque se produce un error de tiempo de ejecución si se compara un objeto nulo o no instanciado, por lo que debemos anular el operador predeterminado "==" de esta manera.

Answer 2

Es una operator overload (de ==, no la sobrecarga del método de ReferenceEquals ) para verificar si dos instancias del tipo Shop son de igual referencia (es decir, si se refieren a la misma dirección de memoria ).

bool result = shop1 == shop2; //shop1 and shop2 are of type Shop 

Al declarar el operador == , también se le pedirá que sobrecargue su operador coincidente (o contador) != :

public static bool operator ==(Shop lhs, Shop rhs) {
    if (Object.ReferenceEquals(lhs, null)) { //Check if the left-hand-side Shop is null
        if (Object.ReferenceEquals(rhs, null)) {
            return true; //both are null, equal reference
        }
        return false; //lhs is null, but rhs is not (not equal reference)
    }
    return lhs.Equals(rhs); //lhs is not null, thus can call .Equals, check if it is Equals to rhs
}

public static bool operator !=(Shop lhs, Shop rhs) { //the opposite operator
    if (Object.ReferenceEquals(lhs, null)) {
        if (Object.ReferenceEquals(rhs, null)) {
            return false;
        }
        return true;
    }
    return !lhs.Equals(rhs);
}

También vale la pena tener en cuenta que se Object.ReferenceEquals(lhs, null) lugar de lhs == null ya que el segundo provocará que se llame a otra sobrecarga == hasta la recursión infinita que causa la Exception .

Se usan así:

Shop shop1 = new Shop();
Shop shop2 = new Shop();
bool result = shop1 == shop2; //this will return false, since lhs and rhs referring to two different memory address
shop2 = shop1;
result = shop1 == shop2; //this will return true, referring to the same memory location
shop1 = null;
shop2 = null;
result = shop1 == shop2; //this will return true, both are null

Entendiendo esto, incluso podrías crear algo como esto:

public struct MyCrazyInt{ //this will reverse the result of + and -
    private int Value { get; set; }
    public MyCrazyInt(int value) :this() {
        Value = value;
    }

    public bool Equals(MyCrazyInt otherCrazy) {
        return this.Value != otherCrazy.Value; //reverse this result
    }

    public static MyCrazyInt operator +(MyCrazyInt lhs, MyCrazyInt rhs) {
        int lhsVal = lhs.Value;
        int rhsVal = rhs.Value;
        return new MyCrazyInt(lhsVal - rhsVal); //note that direct lhs-rhs will cause 
    }

    public static MyCrazyInt operator -(MyCrazyInt lhs, MyCrazyInt rhs) {
        int lhsVal = lhs.Value;
        int rhsVal = rhs.Value;
        return new MyCrazyInt(lhsVal + rhsVal); //note that direct lhs+rhs will cause 
    }

    public override string ToString() {
        return Value.ToString();
    }
}

Y luego úsalo así

MyCrazyInt crazyInt1 = new MyCrazyInt(5);
MyCrazyInt crazyInt2 = new MyCrazyInt(3);
MyCrazyInt crazyInt3 = crazyInt1 - crazyInt2; //this will return 8
crazyInt3 = crazyInt1 + crazyInt2; //this will return 2

Answer 3

Esta sobrecarga fue pensada para comparar dos instancias de la Shop . Utiliza Object.ReferenceEquals para determinar si una de las instancias es null .
No puede usar lhs == null o rhs == null , porque esto invocaría nuevamente al operator == y crearía una recursión infinita que llevaría a una Exception .

Si ambas instancias son null , devuelve verdadero (ya que son iguales).
Si solo una instancia es null , devuelve falso (ya que no son iguales).
Si ambas instancias no son null , devuelve el resultado de la implementación de Equals de Shop .