¿Cómo anular correctamente la igualdad?

Question

Todavía soy nuevo en los operadores de sobrecarga. Pensé que estaba haciendo un gran trabajo hasta que llegue a este problema. NullReferenceException se lanza en el operador! =. Supongo que está usándolo en el método CompareTo, pero no estoy del todo seguro. Si alguien puede señalarme en la dirección correcta, estaría muy agradecido.

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

Cuando comento los operadores de binaory, el programa funciona según lo previsto. Mi pregunta es ¿cómo puedo proteger mis operadores binarios de las referencias nulas para poder guardarlas para las comparaciones manuales? Gracias por su tiempo.

Answer 1

Ambas respuestas dadas hasta ahora son incorrectas. La respuesta aceptada es incorrecta porque recursivamente accidentalmente. La otra respuesta es incorrecta porque dice que null no es igual a nulo.

Sus implementaciones de los operadores son todas incorrectas; se requieren para manejar correctamente las entradas nulas.

Su implementación de GetHashCode está muy dañada; intentas poner un número de catorce dígitos en un formato que puede aceptar nueve dígitos. Simplemente llame a GetHashCode en la fecha; ¡No hay necesidad de pasar por este rigamarole de convertirlo en una cuerda y luego convertirlo en un número!

La forma correcta de escribir el código es usar object.ReferenceEquals para hacer comparaciones de referencia en lugar de usar los operadores == y !=; es demasiado fácil hacer una recursión accidental.

El patrón típico dice así:

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

Los otros operadores de comparación se dejan como ejercicio.

Answer 2

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

     } 

Answer 3

Parece que uno de los Task objetos que se están comparando con != se establece en null. El operador integrado != compara las referencias y no se rompe, pero su operador intenta desreferenciar la tarea y se rompe.

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

Esta implementación devuelve false cuando ambas tareas son null. Debe implementar una comprobación nula simétrica en el operador ==.