IEquatable<T>.Equals(T) Método

Definição

Namespace:

System

Assembly:

System.Runtime.dll

Assembly:

mscorlib.dll

Assembly:

netstandard.dll

Indica se o objeto atual é igual a outro objeto do mesmo tipo.

C#

public bool Equals (T other);

C#

public bool Equals (T? other);

Parâmetros

other

T

Um objeto para comparação com esse objeto.

Retornos

Boolean

true se o objeto atual for igual ao parâmetro other; caso contrário, false.

Exemplos

O exemplo a seguir mostra a implementação parcial de uma Person classe que implementa IEquatable<T> e tem duas propriedades LastName e SSN. O Equals método retornará True se a SSN propriedade de dois Person objetos for idêntica; caso contrário, retornará 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 os objetos podem ser armazenados em um List<T> objeto e podem ser identificados pelo Contains método, como mostra o exemplo a seguir.

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.

Comentários

A implementação do Equals método destina-se a executar um teste de igualdade com outro objeto de tipo T, o mesmo tipo que o objeto atual. O Equals(T) método é chamado nas seguintes circunstâncias:

• Quando o Equals método é chamado e o other argumento é um objeto fortemente tipado do tipo T. (Se other não for do tipo T, o método base Object.Equals(Object) será chamado. Dos dois métodos, IEquatable<T>.Equals oferece um desempenho ligeiramente melhor.)

• Quando os métodos de pesquisa de vários objetos de coleção genéricos são chamados. Alguns desses tipos e seus métodos incluem o seguinte:

  • Algumas das sobrecargas genéricas do BinarySearch método.

  • Os métodos de pesquisa da List<T> classe, incluindo List<T>.Contains(T), List<T>.IndexOfe List<T>.LastIndexOfList<T>.Remove.

  • Os métodos de pesquisa da Dictionary<TKey,TValue> classe, incluindo ContainsKey e Remove.

  • Os métodos de pesquisa da classe genérica LinkedList<T> , incluindo LinkedList<T>.Contains e Remove.

Em outras palavras, para lidar com a possibilidade de que objetos de uma classe sejam armazenados em uma matriz ou em um objeto de coleção genérico, é uma boa ideia implementar IEquatable<T> para que o objeto possa ser facilmente identificado e manipulado.

Ao implementar o Equals método, defina a igualdade adequadamente para o tipo especificado pelo argumento de tipo genérico. Por exemplo, se o argumento de tipo for Int32, defina a igualdade adequadamente para a comparação de dois inteiros com sinal de 32 bits.

Notas aos Implementadores

Se você implementar Equals(T), você também deverá substituir as implementações de Equals(Object) classe base e GetHashCode() , portanto, seu comportamento é consistente com o Equals(T) do método. Se você substituir Equals(Object), sua implementação substituída também será chamada em chamadas para o método estático Equals(System.Object, System.Object) em sua classe. Além disso, você deve sobrecarregar os operadores e op_Inequality os op_Equality operadores. Isso garante que todos os testes de igualdade retornem resultados consistentes, o que o exemplo ilustra.

Aplica-se a