IEquatable<T>.Equals(T) Metodo

Definizione

Spazio dei nomi:

System

Assembly:

System.Runtime.dll

Assembly:

mscorlib.dll

Assembly:

netstandard.dll

Indica se l'oggetto corrente è uguale a un altro oggetto dello stesso tipo.

C#

public bool Equals (T other);

C#

public bool Equals (T? other);

Parametri

other

T

Oggetto da confrontare con l'oggetto corrente.

Restituisce

Boolean

true se l'oggetto corrente è uguale al parametro other; in caso contrario, false.

Esempio

Nell'esempio seguente viene illustrata l'implementazione parziale di una Person classe che implementa IEquatable<T> e ha due proprietà e LastName SSN. Il Equals metodo restituisce True se la SSN proprietà di due Person oggetti è identica; in caso contrario, restituisce False.

C#

using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;

public class Person : IEquatable<Person>
{
   private string uniqueSsn;
   private string lName;

   public Person(string lastName, string ssn)
   {
      if (Regex.IsMatch(ssn, @"\d{9}"))
        uniqueSsn = $"{ssn.Substring(0, 3)}-{ssn.Substring(3, 2)}-{ssn.Substring(5, 4)}";
      else if (Regex.IsMatch(ssn, @"\d{3}-\d{2}-\d{4}"))
         uniqueSsn = ssn;
      else
         throw new FormatException("The social security number has an invalid format.");

      this.LastName = lastName;
   }

   public string SSN
   {
      get { return this.uniqueSsn; }
   }

   public string LastName
   {
      get { return this.lName; }
      set {
         if (String.IsNullOrEmpty(value))
            throw new ArgumentException("The last name cannot be null or empty.");
         else
            this.lName = value;
      }
   }

   public bool Equals(Person other)
   {
      if (other == null)
         return false;

      if (this.uniqueSsn == other.uniqueSsn)
         return true;
      else
         return false;
   }

   public override bool Equals(Object obj)
   {
      if (obj == null)
         return false;

      Person personObj = obj as Person;
      if (personObj == null)
         return false;
      else
         return Equals(personObj);
   }

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

   public static bool operator == (Person person1, Person person2)
   {
      if (((object)person1) == null || ((object)person2) == null)
         return Object.Equals(person1, person2);

      return person1.Equals(person2);
   }

   public static bool operator != (Person person1, Person person2)
   {
      if (((object)person1) == null || ((object)person2) == null)
         return ! Object.Equals(person1, person2);

      return ! (person1.Equals(person2));
   }
}

Person Gli oggetti possono quindi essere archiviati in un List<T> oggetto e possono essere identificati dal Contains metodo , come illustrato nell'esempio seguente.

C#

public class TestIEquatable
{
   public static void Main()
   {
      // Create a Person object for each job applicant.
      Person applicant1 = new Person("Jones", "099-29-4999");
      Person applicant2 = new Person("Jones", "199-29-3999");
      Person applicant3 = new Person("Jones", "299-49-6999");

      // Add applicants to a List object.
      List<Person> applicants = new List<Person>();
      applicants.Add(applicant1);
      applicants.Add(applicant2);
      applicants.Add(applicant3);

       // Create a Person object for the final candidate.
       Person candidate = new Person("Jones", "199-29-3999");
       if (applicants.Contains(candidate))
          Console.WriteLine("Found {0} (SSN {1}).",
                             candidate.LastName, candidate.SSN);
      else
         Console.WriteLine("Applicant {0} not found.", candidate.SSN);

      // Call the shared inherited Equals(Object, Object) method.
      // It will in turn call the IEquatable(Of T).Equals implementation.
      Console.WriteLine("{0}({1}) already on file: {2}.",
                        applicant2.LastName,
                        applicant2.SSN,
                        Person.Equals(applicant2, candidate));
   }
}
// The example displays the following output:
//       Found Jones (SSN 199-29-3999).
//       Jones(199-29-3999) already on file: True.

Commenti

L'implementazione del Equals metodo è progettata per eseguire un test per verificarne l'uguaglianza con un altro oggetto di tipo T, lo stesso tipo dell'oggetto corrente. Il Equals(T) metodo viene chiamato nelle circostanze seguenti:

• Quando il Equals metodo viene chiamato e l'argomento other è un oggetto fortemente tipizzato di tipo T. Se other non è di tipo T, viene chiamato il metodo di base Object.Equals(Object) . Dei due metodi, IEquatable<T>.Equals offre prestazioni leggermente migliori.

• Quando vengono chiamati i metodi di ricerca di un numero di oggetti di raccolta generici. Alcuni di questi tipi e i relativi metodi includono:

  • Alcuni degli overload generici del BinarySearch metodo .

  • Metodi di ricerca della List<T> classe , inclusi List<T>.Contains(T), List<T>.IndexOf, List<T>.LastIndexOfe List<T>.Remove.

  • Metodi di ricerca della Dictionary<TKey,TValue> classe , inclusi ContainsKey e Remove.

  • Metodi di ricerca della classe generica LinkedList<T> , inclusi LinkedList<T>.Contains e Remove.

In altre parole, per gestire la possibilità che gli oggetti di una classe vengano archiviati in una matrice o in un oggetto raccolta generico, è consigliabile implementare IEquatable<T> in modo che l'oggetto possa essere facilmente identificato e manipolato.

Quando si implementa il metodo, definire l'uguaglianza Equals in modo appropriato per il tipo specificato dall'argomento di tipo generico. Ad esempio, se l'argomento di tipo è Int32, definire l'uguaglianza in modo appropriato per il confronto di due interi con segno a 32 bit.

Note per gli implementatori

Se si implementa Equals(T), è anche necessario eseguire l'override delle implementazioni della classe di base di Equals(Object) e GetHashCode() in modo che il relativo comportamento sia coerente con quello del Equals(T) metodo . Se si esegue l'override di , l'implementazione sottoposta a override Equals(Object)viene chiamata anche nelle chiamate al metodo statico Equals(System.Object, System.Object) nella classe . Inoltre, è necessario eseguire l'overload degli op_Equality operatori e op_Inequality . In questo modo tutti i test di uguaglianza restituiscono risultati coerenti, come illustrato nell'esempio.

Si applica a