Equals Método (Object)
Recolher sumário
Expandir sumário
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

O objeto a ser comparado com o objeto atual.

Valor de retorno

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 testa a 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 referir ao mesmo objeto.O exemplo a seguir ilustra o resultado da comparação.Ele define um Person classe, que é um tipo de referência, e chama o Person construtor da classe para instanciar 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 do exemplo mostra, person1a e person1b são iguais porque eles fazem referência ao mesmo objeto.No entanto, person1a e person2 não são 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 testa a igualdade de valor.Igualdade de valor significa o seguinte:

    • Os dois objetos são do mesmo tipo.Como mostra o exemplo a seguir, um Byte não é igual a objeto que tem um valor de 12 uma 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.Ele define um Person estrutura, que é um tipo de valor, e chama o Person construtor da classe para instanciar 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 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 no .NET Framework, o Object.Equals(Object) método fornece a comparação de igualdade padrão para todos os outros tipos.No entanto, os tipos geralmente substituir o 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 a Tempo de Execução do Windows, ele fornece o comportamento padrão para classes 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 Tempo de Execução do Windows).Classes de Tempo de Execução do Windows não herdam Object, e atualmente não implementar um Equals(Object) método.No entanto, eles parecem 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 Windows as classes que são escritas em c# ou Visual Basic podem substituir o Equals(Object) sobrecarga do método.

Classes derivadas substituem frequentemente o Object.Equals(Object) método para implementar a igualdade de valor.Além disso, os tipos freqüentemente 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 para testar a 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 é diferente do que você pretendia, 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 faz com quatro chamadas a Equals métodos.A primeiro chamada do método retorna true, e 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.Porque as cadeias de caracteres atribuída a dois StringBuilder objetos forem iguais, o método retorna true.No entanto, StringBuilder não substitui Object.Equals(Object).Por isso, quando o StringBuilder objeto é convertido em um Object, quando um StringBuilder instância é atribuída a uma variável do tipo Object, e quando o Object.Equals(Object, Object) método será 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, elas 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 ...).

Ao definir seu próprio tipo, esse tipo herda a funcionalidade definida pelo Equals método de seu tipo base.A tabela a seguir relaciona a implementação padrão do Equals método para as principais categorias de tipos do .NET Framework.

Categoria de tipo

Igualdade definido pelo

Comments

Classe derivada diretamente de Object

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 por um campo comparação usando a reflexão.

Enumeração

Enum.Equals

Os 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 invocação idênticos.

Interface

Object.Equals(Object)

Igualdade de referência.

Um tipo de valor, você sempre deve substituir Equals, porque o testa a igualdade que dependem de reflexão oferece 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 de igualdade de valor.Esse tipo de implementação de Equals retornar true se os dois objetos têm o mesmo valor, mesmo se eles não são a mesma instância.O implementador do tipo decide o que constitui o valor de um objeto, mas é normalmente alguns ou todos os dados armazenados em variáveis de instância do objeto.Por exemplo, o valor de um String objeto baseia-se nos caracteres da cadeia de caracteres; o String.Equals(Object) substituições de métodos de Object.Equals(Object) método retorne true para qualquer duas instâncias que contêm os mesmos caracteres na mesma ordem em seqüência.

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 seriam 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 anular 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 representam as referências de objeto que não são nulo.

  • x.Equals(x) Retorna true, exceto nos 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.

  • Chamadas sucessivas à x.Equals(y) retornam o mesmo valor desde que 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 for 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 de substituição Equals(Object) também deve substituir GetHashCode; caso contrário, tabelas de hash talvez não funcionem corretamente.

  • Você deve considerar implementar o IEquatable<T> interface para oferecer suporte a fortemente tipados testa a igualdade.O IEquatable<T>.Equals implementação deve retornar resultados consistentes com Equals.

  • Se sua linguagem de programação oferece suporte à 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 deverá sobrecarregar o operador de igualdade, mesmo que 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 substituindo 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 causar o objeto sejam 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 usa a reflexão para realizar uma comparação por um campo de tipos de valor cujos campos incluem tipos de referência.

  • Se você substituir Equals e linguagem de desenvolvimento oferece suporte à sobrecarga de operador, você deverá sobrecarregar o operador de igualdade.

  • Você deve implementar o IEquatable<T> interface.Chamar fortemente tipada IEquatable<T>.Equals método evita a conversão boxing o 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 é 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 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 Object.Equals(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 Equals.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 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 oferecem suporte a sobrecarga de operador.Quando um tipo sobrecarrega o operador de igualdade, ele deve também substituir o Equals(Object) método para fornecer a mesma funcionalidade.Isso normalmente é feito escrevendo o 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 Equals(Object) method need not call 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.

Universal Windows Platform
Disponível desde 4.5
.NET Framework
Disponível desde 1.1
Portable Class Library
Com suporte em: portable .NET platforms
Silverlight
Disponível desde 2.0
Windows Phone Silverlight
Disponível desde 7.0
Windows Phone
Disponível desde 8.1
Retornar ao topo
Mostrar:
© 2016 Microsoft