Este artigo foi traduzido por máquina. Para visualizar o arquivo em inglês, marque a caixa de seleção Inglês. Você também pode exibir o texto Em inglês em uma janela pop-up, movendo o ponteiro do mouse sobre o texto.
Tradução
Inglês

Método Object.Equals (Object)

 

Verifica se o objeto especificado é igual ao objeto atual.

Namespace:   System
Assembly:  mscorlib (em mscorlib.dll)

public virtual bool Equals(
	object obj
)

Parâmetros

obj
Type: System.Object

O objeto a ser comparado com o objeto atual.

Valor Retornado

Type: System.Boolean

true se o objeto especificado for igual ao objeto atual; caso contrário, false.

O tipo de comparação entre a instância atual e o obj parâmetro depende se a instância atual é um tipo de referência ou um tipo de valor.

  • Se a instância atual é um tipo de referência, o Equals(Object) método testes de igualdade de referência e uma chamada para o Equals(Object) método é equivalente a uma chamada para o ReferenceEquals método. Igualdade de referência significa que as variáveis de objeto que são comparadas se referem ao mesmo objeto. O exemplo a seguir ilustra o resultado de uma comparação tal. Define uma Person classe, que é um tipo de referência, e chama o Person construtor da classe para criar uma instância de dois novos Person objetos, person1a e person2, que têm o mesmo valor. Ele também atribui person1a a outra variável de objeto, person1b. Como a saída de exemplo mostra, person1a e person1b são iguais porque eles fazem referência ao mesmo objeto. No entanto, person1a e person2 não forem iguais, embora tenham o mesmo valor.

    using System;
    
    // Define a reference type that does not override Equals.
    public class Person
    {
       private string personName;
    
       public Person(string name)
       {
          this.personName = name;
       }
    
       public override string ToString()
       {
          return this.personName;
       }
    }
    
    public class Example
    {
       public static void Main()
       {
          Person person1a = new Person("John");
          Person person1b = person1a;
          Person person2 = new Person(person1a.ToString());
    
          Console.WriteLine("Calling Equals:"); 
          Console.WriteLine("person1a and person1b: {0}", person1a.Equals(person1b));               
          Console.WriteLine("person1a and person2: {0}", person1a.Equals(person2));  
    
          Console.WriteLine("\nCasting to an Object and calling Equals:");
          Console.WriteLine("person1a and person1b: {0}", ((object) person1a).Equals((object) person1b));
          Console.WriteLine("person1a and person2: {0}", ((object) person1a).Equals((object) person2)); 
       }
    }
    // The example displays the following output:
    //       person1a and person1b: True
    //       person1a and person2: False
    //       
    //       Casting to an Object and calling Equals:
    //       person1a and person1b: True
    //       person1a and person2: False
    
  • Se a instância atual é um tipo de valor, o Equals(Object) método testes para igualdade de valor. Igualdade de valor significa o seguinte:

    • Os dois objetos são do mesmo tipo. Como mostra o exemplo a seguir, uma Byte não é igual ao objeto que tem um valor de 12 um Int32 objeto que tem um valor de 12, porque os dois objetos têm diferentes tipos de tempo de execução.

      using System;
      
      public class Example
      {
         public static void Main()
         {
            byte value1 = 12;
            int value2 = 12;
      
            object object1 = value1;
            object object2 = value2;
      
            Console.WriteLine("{0} ({1}) = {2} ({3}): {4}",
                              object1, object1.GetType().Name,
                              object2, object2.GetType().Name,
                              object1.Equals(object2));
         }
      }
      // The example displays the following output:
      //        12 (Byte) = 12 (Int32): False
      
    • Os valores dos campos públicos e privados de dois objetos são iguais. O exemplo a seguir testa a igualdade de valor. Define uma Person estrutura, que é um tipo de valor, e chama o Person construtor da classe para criar uma instância de dois novos Person objetos, person1 e person2, que têm o mesmo valor. Como mostra a saída do exemplo, embora as variáveis de dois objeto objetos diferentes, consultem person1 e person2 são iguais porque eles têm o mesmo valor privados personName campo.

      using System;
      
      // Define a value type that does not override Equals.
      public struct Person
      {
         private string personName;
      
         public Person(string name)
         {
            this.personName = name;
         }
      
         public override string ToString()
         {
            return this.personName;
         }
      }
      
      public struct Example
      {
         public static void Main()
         {
            Person person1 = new Person("John");
            Person person2 = new Person("John");
      
            Console.WriteLine("Calling Equals:"); 
            Console.WriteLine(person1.Equals(person2)); 
      
            Console.WriteLine("\nCasting to an Object and calling Equals:");
            Console.WriteLine(((object) person1).Equals((object) person2));  
         }
      }
      // The example displays the following output:
      //       Calling Equals:
      //       True
      //       
      //       Casting to an Object and calling Equals:
      //       True
      

Porque o Object classe é a classe base para todos os tipos do .NET Framework, o Object.Equals(Object) método fornece a comparação de igualdade padrão para todos os outros tipos. No entanto, muitas vezes substituem tipos de Equals método para implementar a igualdade de valor. Para obter mais informações, consulte as notas de chamadores e observações para seções herdeiros.

Quando você chama o Equals(Object) sobrecarga de método em uma classe de Tempo de Execução do Windows, ele fornece o comportamento padrão para as classes que não substituem Equals(Object). Ele faz parte do suporte que o .NET Framework dá para o Tempo de Execução do Windows (consulte Suporte do .NET Framework para aplicativos da Windows Store e Windows Runtime ). Classes de Tempo de Execução do Windows não herdam Objecte atualmente não implementam um Equals(Object)método. No entanto, eles parecerão ter ToString, Equals(Object), e GetHashCode métodos quando usá-los em seu código c# ou Visual Basic e o .NET Framework fornece o comportamento padrão para esses métodos.

System_CAPS_noteObservação

Tempo de Execução do Windowsas classes que são escritas em c# ou Visual Basic podem substituir o Equals(Object) sobrecarga do método.

Classes derivadas frequentemente substituem o Object.Equals(Object) método para implementar a igualdade de valor. Além disso, os tipos de frequentemente fornecem uma sobrecarga adicional com rigidez de tipos para o Equals método normalmente Implementando o IEquatable<T> interface. Quando você chama o Equals método de teste de igualdade, você deve saber se a instância atual substitui Object.Equals e entender como uma chamada específica para um Equals método seja resolvido. Caso contrário, você pode executar um teste de igualdade que é diferente do que você pretendeu, e o método pode retornar um valor inesperado.

O exemplo a seguir fornece uma ilustração. Ele cria três StringBuilder objetos com cadeias de caracteres idênticas e, em seguida, faz quatro chamadas para Equals métodos. O primeiro método chamada retorna truee o retorno de três restantes false.

using System;
using System.Text;

public class Example
{
   public static void Main()
   {
      StringBuilder sb1 = new StringBuilder("building a string...");
      StringBuilder sb2 = new StringBuilder("building a string...");

      Console.WriteLine("sb1.Equals(sb2): {0}", sb1.Equals(sb2));
      Console.WriteLine("((Object) sb1).Equals(sb2): {0}", 
                        ((Object) sb1).Equals(sb2));
      Console.WriteLine("Object.Equals(sb1, sb2): {0}",
                        Object.Equals(sb1, sb2));      

      Object sb3 = new StringBuilder("building a string...");
      Console.WriteLine("\nsb3.Equals(sb2): {0}", sb3.Equals(sb2));                              
   }
}
// The example displays the following output:
//       sb1.Equals(sb2): True
//       ((Object) sb1).Equals(sb2): False
//       Object.Equals(sb1, sb2): False
//
//       sb3.Equals(sb2): False

No primeiro caso, fortemente tipado StringBuilder.Equals(StringBuilder) sobrecarga de método, que testa a igualdade de valor, é chamada. Como as cadeias de caracteres atribuída a dois StringBuilder objetos forem iguais, o método retornará true. No entanto, StringBuilder não substitui Object.Equals(Object). Por isso, quando o StringBuilder objeto é convertido para um Object, quando um StringBuilder instância é atribuída a uma variável do tipo Objecte quando o Object.Equals(Object, Object) método é passado duas StringBuilder objetos, o padrão Object.Equals(Object) método é chamado. Porque StringBuilder é um tipo de referência, isso equivale a passar os dois StringBuilder objetos para o ReferenceEquals método. Embora todas as três StringBuilder objetos contêm cadeias de caracteres idênticas, eles se referem a três objetos distintos. Como resultado, esses três método chama retorno false.

Você pode comparar o objeto atual com outro objeto igualdade de referência ao chamar o ReferenceEquals método. No Visual Basic, você também pode usar o is palavra-chave (por exemplo, If Me Is otherObject Then ...).

Quando você define seu próprio tipo, esse tipo herda a funcionalidade definida pelo Equals método de seu tipo base. A tabela a seguir lista a implementação padrão da Equals método para as principais categorias de tipos do .NET Framework.

Categoria do tipo

Igualdade definida pelo

Comments

Classe derivada diretamenteObject

Object.Equals(Object)

Igualdade de referência; equivalente a chamar Object.ReferenceEquals.

Estrutura

ValueType.Equals

Igualdade de valor; comparação byte por byte direta ou usando a reflexão de comparação de campo por campo.

Enumeração

Enum.Equals

Valores devem ter o mesmo tipo de enumeração e o mesmo valor subjacente.

delegate

MulticastDelegate.Equals

Delegados devem ter o mesmo tipo com listas de chamada idêntica.

Interface

Object.Equals(Object)

Igualdade de referência.

Para um tipo de valor, você sempre deve substituir Equals, como testes de igualdade que dependem de reflexão oferecem um desempenho ruim. Você também pode substituir a implementação padrão de Equals para tipos de referência para testar a igualdade de valor em vez de igualdade de referência e definir o significado preciso da igualdade de valor. Tais implementações de Equals retornar true se os dois objetos têm o mesmo valor, mesmo se eles não são a mesma instância. Implementador do tipo decide o que constitui o valor de um objeto, mas é geralmente alguns ou todos os dados armazenados nas variáveis de instância do objeto. Por exemplo, o valor de um String objeto baseia-se os caracteres da cadeia de caracteres; o String.Equals(Object) substituições de método de Object.Equals(Object) método para retornar true para qualquer dois string instâncias que contêm os mesmos caracteres na mesma ordem.

O exemplo a seguir mostra como substituir o Object.Equals(Object) método para testar a igualdade de valor. Ela substitui o Equals método para o Person classe. Se Person aceita sua implementação de classe base de igualdade, dois Person objetos seria iguais somente se eles referenciados um único objeto. No entanto, nesse caso, duas Person objetos são iguais se eles tiverem o mesmo valor para o Person.Id propriedade.

public class Person
{
   private string idNumber;
   private string personName;

   public Person(string name, string id)
   {
      this.personName = name;
      this.idNumber = id;
   }

   public override bool Equals(Object obj)
   {
      Person personObj = obj as Person; 
      if (personObj == null)
         return false;
      else
         return idNumber.Equals(personObj.idNumber);
   }

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

public class Example
{
   public static void Main()
   {
      Person p1 = new Person("John", "63412895");
      Person p2 = new Person("Jack", "63412895");
      Console.WriteLine(p1.Equals(p2));
      Console.WriteLine(Object.Equals(p1, p2));
   }
}
// The example displays the following output:
//       True
//       True

Além de substituição Equals, você pode implementar o IEquatable<T> interface para fornecer um teste com rigidez de tipos para igualdade.

As instruções a seguir devem ser verdadeiras para todas as implementações do Equals(Object) método. Na lista, x, y, e z representar referências de objeto que não são nulo.

  • x.Equals(x)Retorna true, exceto em casos que envolvem tipos de ponto flutuante. Consulte ISO/IEC/IEEE 60559:2011, tecnologia da informação – microprocessador sistemas – aritmética de ponto flutuante.

  • x.Equals(y)Retorna o mesmo valor como y.Equals(x).

  • x.Equals(y)Retorna true se x e y são NaN.

  • Se (x.Equals(y) && y.Equals(z)) retorna true, em seguida, x.Equals(z) retorna true.

  • As chamadas sucessivas para x.Equals(y) retornam o mesmo valor enquanto os objetos referenciados por x e y não são modificados.

  • x.Equals(null) retorna false.

Implementações de Equals não deve lançar exceções; eles sempre devem retornar um valor. Por exemplo, se obj é null, o Equals método deve retornar false em vez de gerar um ArgumentNullException.

Siga estas diretrizes ao substituir Equals(Object):

  • Tipos que implementam IComparable deve substituir Equals(Object).

  • Tipos que substituição Equals(Object) também deverá substituir GetHashCode; caso contrário, tabelas de hash podem não funcionar corretamente.

  • Você pode implementar o IEquatable<T> interface para oferecer suporte a fortemente tipado testes de igualdade. O IEquatable<T>.Equals implementação deve retornar resultados consistentes com Equals.

  • Se a linguagem de programação dá suporte a sobrecarga de operador e sobrecarregar o operador de igualdade para um determinado tipo, você também deve substituir o Equals(Object) método para retornar o mesmo resultado que o operador de igualdade. Isso ajuda a garantir que código de biblioteca de classe que usa Equals (como ArrayList e Hashtable) se comporta de maneira consistente com a maneira como o operador de igualdade é usado pelo código do aplicativo.

As diretrizes a seguir se aplicam a substituição Equals(Object) para um tipo de referência:

  • Considere substituir Equals se a semântica do tipo é baseada no fato de que o tipo representa algum valor (es).

  • A maioria dos tipos de referência não devem sobrecarregar o operador de igualdade, mesmo se elas substituem Equals. No entanto, se você estiver implementando um tipo de referência que deve ter a semântica de valor, como um tipo de número complexo, você deve substituir o operador de igualdade.

  • Você não deve substituir Equals em um tipo de referência mutável. Isso ocorre porque a substituição Equals requer que você também substituir o GetHashCode método, conforme discutido na seção anterior. Isso significa que o código hash de uma instância de um tipo de referência mutável pode alterar durante seu ciclo de vida, o que pode fazer com que o objeto a ser perdidas em uma tabela de hash.

As diretrizes a seguir se aplicam a substituição Equals(Object) para um tipo de valor:

  • Se você estiver definindo um tipo de valor que inclui um ou mais campos cujos valores são tipos de referência, você deve substituir Equals(Object). O Equals(Object) a implementação ValueType executa uma comparação byte por byte para tipos de valor cujos campos são todos os tipos de valor, mas ele usa reflexão para realizar uma comparação de campo por campo de tipos de valor cujos campos incluem tipos de referência.

  • Se você substituir Equals e seu idioma de desenvolvimento oferece suporte a sobrecarga de operador, você deve sobrecarregar o operador de igualdade.

  • Você deve implementar o IEquatable<T> interface. Chamando fortemente tipada IEquatable<T>.Equals método evita conversão boxing de obj argumento.

A exemplo a seguir mostra um Point classe que substitui o Equals método para fornecer a igualdade de valor e um Point3D que é derivada da classe Point. Porque Point substitui Object.Equals(Object) para testar a igualdade de valor, o Object.Equals(Object) método não for chamado. No entanto, Point3D.Equals chamadas Point.Equals porque Point implementa Object.Equals(Object) de forma que fornece a igualdade de valor.

using System;

class Point
{
   protected int x, y;

   public Point() : this(0, 0) 
   { }

   public Point(int x, int y) 
   {
      this.x = x;
      this.y = y;
   }

   public override bool Equals(Object obj) 
   {
      //Check for null and compare run-time types.
      if ((obj == null) || ! this.GetType().Equals(obj.GetType())) {
         return false;
      }
      else { 
         Point p = (Point) obj; 
         return (x == p.x) && (y == p.y);
      }   
   }

   public override int GetHashCode() 
   {
      return (x << 2) ^ y;
   }

    public override string ToString()
    {
        return String.Format("Point({0}, {1})", x, y);
    }
}

sealed class Point3D: Point 
{
   int z;

   public Point3D(int x, int y, int z) : base(x, y) 
   {
      this.z = z; 
   }

   public override bool Equals(Object obj) 
   {
      Point3D pt3 = obj as Point3D;
      if (pt3 == null)
         return false;
      else
         return base.Equals((Point)obj) && z == pt3.z;
   }

   public override int GetHashCode() 
   {
      return (base.GetHashCode() << 2) ^ z;
   }

   public override String ToString() 
   {
        return String.Format("Point({0}, {1}, {2})", x, y, z);
    }
}

class Example 
{
  public static void Main() 
  {
     Point point2D = new Point(5, 5);
     Point3D point3Da = new Point3D(5, 5, 2);
     Point3D point3Db = new Point3D(5, 5, 2);
     Point3D point3Dc = new Point3D(5, 5, -1);

     Console.WriteLine("{0} = {1}: {2}", 
                       point2D, point3Da, point2D.Equals(point3Da));
     Console.WriteLine("{0} = {1}: {2}", 
                       point2D, point3Db, point2D.Equals(point3Db));        
     Console.WriteLine("{0} = {1}: {2}", 
                       point3Da, point3Db, point3Da.Equals(point3Db));
     Console.WriteLine("{0} = {1}: {2}", 
                       point3Da, point3Dc, point3Da.Equals(point3Dc));
  } 
}
// The example displays the following output:
//       Point(5, 5) = Point(5, 5, 2): False
//       Point(5, 5) = Point(5, 5, 2): False
//       Point(5, 5, 2) = Point(5, 5, 2): True
//       Point(5, 5, 2) = Point(5, 5, -1): False

The Point.Equals method checks to make sure that the obj argument is not null and that it references an instance of the same type as this object. If either check fails, the method returns false.

The Point.Equals method calls the M:System.Object.GetType method to determine whether the run-time types of the two objects are identical. If the method used a check of the form obj is Point in C# or TryCast(obj, Point) in Visual Basic, the check would return true in cases where obj is an instance of a derived class of Point, even though obj and the current instance are not of the same run-time type. Having verified that both objects are of the same type, the method casts obj to type Point and returns the result of comparing the instance fields of the two objects.

In Point3D.Equals, the inherited Point.Equals method, which overrides M:System.Object.Equals(System.Object), is invoked before anything else is done. Because Point3D is a sealed class (NotInheritable in Visual Basic), a check in the form obj is Point in C# or TryCast(obj, Point) in Visual Basic is adequate to ensure that obj is a Point3D object. If it is a Point3D object, it is cast to a Point object and passed to the base class implementation of M:System.Object.Equals(System.Object). Only when the inherited Point.Equals method returns true does the method compare the z instance fields introduced in the derived class.

O exemplo a seguir define uma Rectangle classe que implementa internamente um retângulo como dois Point objetos. O Rectangle classe também substituições Object.Equals(Object) para fornecer para igualdade de valor.

using System;

class Rectangle 
{
   private Point a, b;

   public Rectangle(int upLeftX, int upLeftY, int downRightX, int downRightY) {
      this.a = new Point(upLeftX, upLeftY);
      this.b = new Point(downRightX, downRightY);
   }

   public override bool Equals(Object obj) {
      // Perform an equality check on two rectangles (Point object pairs).
      if (obj == null || GetType() != obj.GetType()) 
          return false;
      Rectangle r = (Rectangle)obj;
      return a.Equals(r.a) && b.Equals(r.b);
   }

   public override int GetHashCode() {
      return Tuple.Create(a, b).GetHashCode();
   }

    public override String ToString() 
    {
       return String.Format("Rectangle({0}, {1}, {2}, {3})",
                            a.x, a.y, b.x, b.y); 
    }
}

class Point 
{
  internal int x;
  internal int y;

  public Point(int X, int Y) {
     this.x = X;
     this.y = Y;
  }

  public override bool Equals (Object obj) {
     // Performs an equality check on two points (integer pairs).
     if (obj == null || GetType() != obj.GetType()) return false;
     Point p = (Point)obj;
     return (x == p.x) && (y == p.y);
  }

  public override int GetHashCode() {
     return Tuple.Create(x, y).GetHashCode();
  }
}

class Example 
{
   public static void Main() 
   {
      Rectangle r1 = new Rectangle(0, 0, 100, 200);
      Rectangle r2 = new Rectangle(0, 0, 100, 200);
      Rectangle r3 = new Rectangle(0, 0, 150, 200);

      Console.WriteLine("{0} = {1}: {2}", r1, r2, r1.Equals(r2));
      Console.WriteLine("{0} = {1}: {2}", r1, r3, r1.Equals(r3));
      Console.WriteLine("{0} = {1}: {2}", r2, r3, r2.Equals(r3));
   }
}
// The example displays the following output:
//    Rectangle(0, 0, 100, 200) = Rectangle(0, 0, 100, 200): True
//    Rectangle(0, 0, 100, 200) = Rectangle(0, 0, 150, 200): False
//    Rectangle(0, 0, 100, 200) = Rectangle(0, 0, 150, 200): False

Algumas linguagens como c# e Visual Basic dão suporte a sobrecarga de operador. Quando um tipo sobrecarrega o operador de igualdade, ele também deverá substituir o Equals(Object) método para fornecer a mesma funcionalidade. Normalmente, isso é feito por meio da gravação de Equals(Object) método em termos de operador de igualdade sobrecarregados, como no exemplo a seguir.

using System;

public struct Complex {
   public double re, im;

   public override bool Equals(Object obj) {
      return obj is Complex && this == (Complex)obj;
   }

   public override int GetHashCode() {
      return Tuple.Create(re, im).GetHashCode();
   }

   public static bool operator ==(Complex x, Complex y) {
      return x.re == y.re && x.im == y.im;
   }

   public static bool operator !=(Complex x, Complex y) {
      return !(x == y);
   }

    public override String ToString()
    {
       return String.Format("({0}, {1})", re, im);
    } 
}

class MyClass 
{
  public static void Main() 
  {
    Complex cmplx1, cmplx2;

    cmplx1.re = 4.0;
    cmplx1.im = 1.0;

    cmplx2.re = 2.0;
    cmplx2.im = 1.0;

    Console.WriteLine("{0} <> {1}: {2}", cmplx1, cmplx2, cmplx1 != cmplx2);        
    Console.WriteLine("{0} = {1}: {2}", cmplx1, cmplx2, cmplx1.Equals(cmplx2));        

    cmplx2.re = 4.0;

    Console.WriteLine("{0} = {1}: {2}", cmplx1, cmplx2, cmplx1 == cmplx2);        
    Console.WriteLine("{0} = {1}: {2}", cmplx1, cmplx2, cmplx1.Equals(cmplx2));          
  }
}
// The example displays the following output:
//       (4, 1) <> (2, 1): True
//       (4, 1) = (2, 1): False
//       (4, 1) = (4, 1): True
//       (4, 1) = (4, 1): True

Because Complex is a value type, it cannot be derived from. Therefore, the override to M:System.Object.Equals(System.Object) method need not call M:System.Object.GetType to determine the precise run-time type of each object, but can instead use the is operator in C# or the TypeOf operator in Visual Basic to check the type of the obj parameter.

Plataforma Universal do Windows
Disponível desde 8
.NET Framework
Disponível desde 1.1
Biblioteca de Classes Portátil
Com suporte no: plataformas portáteis do .NET
Silverlight
Disponível desde 2.0
Windows Phone Silverlight
Disponível desde 7.0
Windows Phone
Disponível desde 8.1
Retornar ao início
Mostrar: