((System.Object) р == NULL)

Question

Почему это:

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

Вместо этого:

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

Я не понимаю, почему вы когда-нибудь написать ((System .Object) р)?

С уважением,

Dan

Answer 1

Вы бросили в object, когда вы не знаете или не можете быть уверены, был ли исходный класс переопределяется 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"); 
     } 
    } 
} 

Этот кодовые выходы только"ae is null", что явно не так. Отливка до object позволяет избежать класса operator == и, следовательно, является настоящей контрольной проверкой на null.

Answer 2

Попросту говоря, это бессмысленно. Нуль всегда можно назначить (за исключением ненулевых значений, таких как ints и structs) независимо от типа, поэтому его всегда можно проверить. Литой не требуется

Если TwoDPoint является непустым типом, таким как структура, то на самом деле он может иметь точку. Кэш (System.Object) эффективно блокирует структуру в объект с нулевым значением. Но если это так, то obj as TwoDPoint будет недействительным. Вам понадобится obj as TwoDPoint?, чтобы сделать его нулевым. (не может использоваться как с не-nullables)

Answer 3

Каждый объект в .NET является производным от System.Object, поэтому нет необходимости в явном приведении.

Answer 4

И еще более кратким будет:

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

Answer 5

Это имеет смысл, если этот код внутри Object.Equals переопределить, и вы не хотите ссылаться на оператор равенства (который, например, может ошибочно вызвать Equals). Выделение объекта позволяет вызывать стандартный оператор равенства, который сравнивает ссылки.

Как правило, вы должны использовать Object.ReferenceEquals, чтобы сравнить экземпляр объекта с null внутри Equals переопределить.

Например, это может вызвать переполнение стека:

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; 
    } 
} 

В приведенном выше примере оператор равенства вызывает Equals и потому otherPoint переменная типа Point, он будет ссылаться оператор равенства, что приводит к бесконечной рекурсии.

Обычно, когда вы переопределяете Equals и определяете оператор равенства, вы должны поставить логику сравнения в оператор и вызвать из переопределения Equals. Имейте в виду, что рекомендуется, чтобы класс был неизменным, если оба они переопределены.

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); 
    } 
}