Jak poprawnie zastąpić równość?

Question

Nadal nie mam do czynienia z przeciążaniem operatorów. Myślałem, że wykonuję świetną robotę, dopóki nie dotknęłam tego problemu. Wyjątek NullReferenceException jest zgłaszany dla operatora! =. Zakładam, że używa go w metodzie CompareTo, ale nie jestem całkowicie pewien. Jeśli ktokolwiek może wskazać mi właściwy kierunek, byłbym bardzo wdzięczny.

using System; 
using System.Collections.Generic; 
using System.ComponentModel; 
using System.Data; 
using System.Drawing; 
using System.Linq; 
using System.Text; 
using System.Windows.Forms; 

namespace WindowsFormsApplication2 
{ 
    public partial class Form1 : Form 
    { 
     public Form1() 
     { 
      InitializeComponent(); 
      List<Task> tasks = new List<Task>(); 
      tasks.Add(new Task("first", DateTime.Now.AddHours(2))); 
      tasks.Add(new Task("second", DateTime.Now.AddHours(4))); 
      tasks.TrimExcess(); 
      tasks.Sort(); 
     } 
    } 
    public class Task : IComparable 
    { 
     public Task() 
     { 
     } 
     public Task(string nameIn, DateTime dueIn) 
     { 
      nameOfTask = nameIn; 
      dateDue = dueIn; 
     } 
     DateTime dateDue; 
     string nameOfTask; 

     public static bool operator <(Task t1, Task t2) 
     { 
      return (t1.dateDue < t2.dateDue); 
     } 
     public static bool operator >(Task t1, Task t2) 
     { 
      return (t1.dateDue > t2.dateDue); 
     } 
     public static bool operator ==(Task t1, Task t2) 
     { 
      return (t1.dateDue == t2.dateDue); 
     } 
     public static bool operator !=(Task t1, Task t2) 
     { 
       return (t1.dateDue != t2.dateDue); 

     } 
     public override int GetHashCode() 
     { 
      return Int32.Parse(this.dateDue.ToString("yyyymmddhhmmss")); 
     } 
     public override bool Equals(System.Object obj) 
     { 
      if (obj == null) return false;  

      Task t = obj as Task; 
      if ((System.Object)t == null) return false; 
      return (this.dateDue == t.dateDue); 
     } 
     int IComparable.CompareTo(object obj) 
     { 
      if (obj == null) return 1; 

      Task t = obj as Task; 
      if (t != null) 
      { 
       return this.dateDue.CompareTo(t.dateDue); 
      } 
      else 
       throw new ArgumentException("Object is not a Task"); 
     } 
    } 
} 

Kiedy komentuję operatorów binaory program działa zgodnie z przeznaczeniem. Moje pytanie brzmi: jak mogę chronić moje operatory binarne przed zerowymi referencjami, więc mogę zachować je dla ręcznych porównań? Dziękuję za poświęcony czas.

Answer 1

Obie udzielone do tej pory odpowiedzi są błędne. Przyjęta odpowiedź jest błędna, ponieważ przypadkowo się powtórzy. Inna odpowiedź jest błędna, ponieważ mówi, że wartość null nie jest równa zeru.

Twoje wdrożenia operatorów są błędne; są one wymagane, aby poprawnie obsługiwać wejścia zerowe.

Twoja implementacja GetHashCode jest głęboko zepsuta; próbujesz umieścić czternastocyfrową liczbę w formacie, który może przyjąć dziewięć cyfr. Po prostu wywołaj GetHashCode na datę; nie ma potrzeby, aby przejść przez ten rigamarole zamieniając go w ciąg, a następnie zmieniając go w liczbę!

Właściwym sposobem napisania kodu jest użycie object.ReferenceEquals do porównywania odniesień zamiast korzystania z operatorów == i !=; jest zbyt łatwo zrobić przypadkową rekursję.

Typowy wzór wygląda tak:

public static bool operator ==(Task t1, Task t2)   
{ 
    if (object.ReferenceEquals(t1, t2)) return true; 
    // All right. We know that they are (1) not the same object, and 
    // (2) not both null. Maybe one of them is null. 
    if (object.ReferenceEquals(t1, null)) return false; 
    if (object.ReferenceEquals(t2, null)) return false; 
    // They are not the same object and both are not null. 
    return t1.dateDue == t2.dateDue; 
} 

public static bool operator !=(Task t1, Task t2)   
{ 
    // Simply call the == operator and invert it. 
    return !(t1 == t2); 
} 

public override bool Equals(object t) 
{ 
    return (t as Task) == this; 
} 

public override int GetHashCode() 
{ 
    return this.dateDue.GetHashCode(); 
} 

Pozostałe operatory porównania są pozostawione jako ćwiczenie.

Answer 2

public static bool operator !=(Task t1, Task t2) 
     { 
       if (null == t1 || null == t2) { return false;} 
       return (t1.dateDue != t2.dateDue); 

     } 

Answer 3

Wygląda jak jeden z Task obiektów, które są w porównaniu z != jest ustawiony na null. Wbudowany operator != porównuje odniesienia i nie pęka, ale twój operator próbuje dereferencji zadania i zrywa.

public static bool operator !=(Task t1, Task t2) { 
    if (ReferenceEquals(t1, null)) { 
     return !ReferenceEquals(t2, null); // return true only if t2 is *not* null 
    } 
    if (ReferenceEquals(t2, null)) { 
     return true; // we know that t1 is not null 
    } 
    return (t1.dateDue != t2.dateDue); 
} 

Ta implementacja zwraca false gdy oba zadania są null. Powinieneś zaimplementować symetryczne sprawdzanie wartości pustych w operatorze ==.