((System.Object)p == null)

Question

Warum dies tun:

    // If parameter cannot be cast to Point return false.
    TwoDPoint p = obj as TwoDPoint;
    if ((System.Object)p == null)
    {
        return false;
    }

Stattdessen:

    // If parameter cannot be cast to Point return false.
    TwoDPoint p = obj as TwoDPoint;
    if (p == null)
    {
        return false;
    }

Ich verstehe nicht, warum Sie jemals ((System.Object)p) schreiben würden?

Herzliche Grüße,

Dan

Answer 1

Sie werfen nach object wenn Sie nicht wissen oder nicht sicher sein können, ob die ursprüngliche Klasse die operator == :

using System;
class AlwaysEqual
{
    public static bool operator ==(AlwaysEqual a, AlwaysEqual b)
    {
        return true;
    }

    public static bool operator !=(AlwaysEqual a, AlwaysEqual b)
    {
        return true;
    }
}

class Program
{
    static void Main()
    {
        object o = new AlwaysEqual();
        AlwaysEqual ae = o as AlwaysEqual;

        if (ae == null)
        {
            Console.WriteLine("ae is null");
        }

        if ((object)ae == null)
        {
            Console.WriteLine("(object)ae is null");
        }
    }
}

Dieser Code gibt aus nur "ae is null" was natürlich nicht der Fall ist. Die Besetzung der object vermeidet die AlwaysEqual Die Klasse operator == und ist daher eine echte Referenzprüfung gegen null .

Answer 2

Im Klartext: Es ist sinnlos. Null kann immer zugewiesen werden (mit Ausnahme von Non-Nullables wie Ints und Structs) unabhängig vom Typ, so dass es immer überprüft werden kann. Die Besetzung ist nicht notwendig

Si TwoDPoint ein nicht-nullbarer Typ wie z. B. eine Struktur ist, dann kann er tatsächlich einen Punkt haben. Die (System.Object) Cache würde die Struktur effektiv in ein löschbares Objekt umwandeln. Aber wenn das der Fall wäre, dann obj as TwoDPoint wäre nicht gültig. Sie bräuchten obj as TwoDPoint? um es löschbar zu machen. (kann nicht wie bei Nicht-Nullables verwendet werden)

Answer 3

Jedes Objekt in .NET ist von System.Object abgeleitet, so dass ein expliziter Cast nicht erforderlich ist.

Answer 4

Und noch prägnanter wäre es:

if (!(obj is TwoDPoint)) {
  return false;
}

Answer 5

Es macht absolut Sinn, wenn dieser Code in Object.Equals überschreiben und Sie wollen den Gleichheitsoperator nicht aufrufen (was zum Beispiel fälschlicherweise den Equals ). Das Casting in ein Objekt ermöglicht den Aufruf des Standard-Gleichheitsoperators, der Referenzen vergleicht.

Normalerweise würden Sie Folgendes verwenden Object.ReferenceEquals um eine Instanz eines Objekts zu vergleichen mit null innerhalb Equals überschreiben.

Dies würde zum Beispiel einen Stapelüberlauf verursachen:

public class Point {
  public override bool Equals (object other) {
    var otherPoint = other as Point;

    if (other == null)
      return false;

    //...
  }

  public static bool operator == (Point l, Point r) {
    //...
    //null checks
    if (!l.Equals(r))
      return false;
  }
}

In dem obigen Beispiel ruft der Gleichheitsoperator Equals und weil otherPoint Variable ist vom Typ Point würde der Gleichheitsoperator aufgerufen, was zu einer unendlichen Rekursion führen würde.

Normalerweise wird beim Überschreiben von Equals und den Gleichheitsoperator definieren, würden Sie die Vergleichslogik in den Operator packen und diesen von der Equals überschreiben. Beachten Sie, dass die Klasse unveränderlich sein sollte, wenn beide überschrieben werden.

public class Point {
  public override bool Equals (object other) {
    var otherPoint = other as Point;
    return this == otherPoint;
  }

  //must override GetHashCode() as well

  public static bool operator == (Point l, Point r) {
    if (Object.ReferenceEquals(l, null) && Object.ReferenceEquals(r, null))
      return true;
    if (Object.ReferenceEquals(l, null) || Object.ReferenceEquals(r, null))
      return false;
    //actual equality checks
  }
  public static bool operator != (Point l, Point r) {
    return !(l==r);
  }
}