# Enum.Equals(Object) Método

## Definição

Retorna um valor que indica se essa instância é igual a um objeto especificado.Returns a value indicating whether this instance is equal to a specified object.

``````public:
override bool Equals(System::Object ^ obj);``````
``public override bool Equals (object obj);``
``override this.Equals : obj -> bool``
``Public Overrides Function Equals (obj As Object) As Boolean``

#### Parâmetros

obj
Object

Um objeto a ser comparado com essa instância ou `null`.An object to compare with this instance, or `null`.

#### Retornos

`true` se `obj` for um valor de enumeração do mesmo tipo e com o mesmo valor subjacente que essa instância; caso contrário, `false`.`true` if `obj` is an enumeration value of the same type and with the same underlying value as this instance; otherwise, `false`.

## Exemplos

O exemplo a seguir ilustra o uso do método Equals.The following example illustrates the use of the Equals method.

``````using namespace System;
public enum class Colors
{
Red, Green, Blue, Yellow
};

public enum class Mammals
{
Cat, Dog, Horse, Dolphin
};

int main()
{
Mammals myPet = Mammals::Cat;
Colors myColor = Colors::Red;
Mammals yourPet = Mammals::Dog;
Colors yourColor = Colors::Red;
Console::WriteLine(  "My favorite animal is a {0}", myPet );
Console::WriteLine(  "Your favorite animal is a {0}", yourPet );
Console::WriteLine(  "Do we like the same animal? {0}", myPet.Equals( yourPet ) ? (String^)"Yes" : "No" );
Console::WriteLine();
Console::WriteLine(  "My favorite color is {0}", myColor );
Console::WriteLine(  "Your favorite color is {0}", yourColor );
Console::WriteLine(  "Do we like the same color? {0}", myColor.Equals( yourColor ) ? (String^)"Yes" : "No" );
Console::WriteLine();
Console::WriteLine(  "The value of my color ({0}) is {1}", myColor, Enum::Format( Colors::typeid, myColor,  "d" ) );
Console::WriteLine(  "The value of my pet (a {0}) is {1}", myPet, Enum::Format( Mammals::typeid, myPet,  "d" ) );
Console::WriteLine(  "Even though they have the same value, are they equal? {0}", myColor.Equals( myPet ) ? (String^)"Yes" : "No" );
}
// The example displays the following output:
//    My favorite animal is a Cat
//    Your favorite animal is a Dog
//    Do we like the same animal? No
//
//    My favorite color is Red
//    Your favorite color is Red
//    Do we like the same color? Yes
//
//    The value of my color (Red) is 0
//    The value of my pet (a Cat) is 0
//    Even though they have the same value, are they equal? No
``````
``````using System;

public class EqualsTest {
enum Colors { Red, Green, Blue, Yellow };
enum Mammals { Cat, Dog, Horse, Dolphin };

public static void Main() {
Mammals myPet = Mammals.Cat;
Colors myColor = Colors.Red;
Mammals yourPet = Mammals.Dog;
Colors yourColor = Colors.Red;

Console.WriteLine("My favorite animal is a {0}", myPet);
Console.WriteLine("Your favorite animal is a {0}", yourPet);
Console.WriteLine("Do we like the same animal? {0}", myPet.Equals(yourPet) ? "Yes" : "No");

Console.WriteLine();
Console.WriteLine("My favorite color is {0}", myColor);
Console.WriteLine("Your favorite color is {0}", yourColor);
Console.WriteLine("Do we like the same color? {0}", myColor.Equals(yourColor) ? "Yes" : "No");

Console.WriteLine();
Console.WriteLine("The value of my color ({0}) is {1}", myColor, Enum.Format(typeof(Colors), myColor, "d"));
Console.WriteLine("The value of my pet (a {0}) is {1}", myPet, Enum.Format(typeof(Mammals), myPet, "d"));
Console.WriteLine("Even though they have the same value, are they equal? {0}",
myColor.Equals(myPet) ? "Yes" : "No");
}
}
// The example displays the following output:
//    My favorite animal is a Cat
//    Your favorite animal is a Dog
//    Do we like the same animal? No
//
//    My favorite color is Red
//    Your favorite color is Red
//    Do we like the same color? Yes
//
//    The value of my color (Red) is 0
//    The value of my pet (a Cat) is 0
//    Even though they have the same value, are they equal? No
``````
``````Public Class EqualsTest
Enum Colors
Red
Green
Blue
Yellow
End Enum

Enum Mammals
Cat
Dog
Horse
Dolphin
End Enum

Public Shared Sub Main()
Dim myPet As Mammals = Mammals.Cat
Dim myColor As Colors = Colors.Red
Dim yourPet As Mammals = Mammals.Dog
Dim yourColor As Colors = Colors.Red
Dim output as string

Console.WriteLine("My favorite animal is a {0}", myPet)
Console.WriteLine("Your favorite animal is a {0}", yourPet)
If myPet.Equals(yourPet) Then output = "Yes" Else output = "No"
Console.WriteLine("Do we like the same animal? {0}", output)

Console.WriteLine()
Console.WriteLine("My favorite color is {0}", myColor)
Console.WriteLine("Your favorite color is {0}", yourColor)
If myColor.Equals(yourColor) Then output = "Yes" Else output = "No"
Console.WriteLine("Do we like the same color? {0}", output)

Console.WriteLine()
Console.WriteLine("The value of my color ({0}) is {1}", myColor, [Enum].Format(GetType(Colors), myColor, "d"))
Console.WriteLine("The value of my pet (a {0}) is {1}", myPet, [Enum].Format(GetType(Mammals), myPet, "d"))
Console.WriteLine("Even though they have the same value, are they equal? {0}",
If(myColor.Equals(myPet), "Yes", "No"))
End Sub
End Class
' The example displays the following output:
'    My favorite animal is a Cat
'    Your favorite animal is a Dog
'    Do we like the same animal? No
'
'    My favorite color is Red
'    Your favorite color is Red
'    Do we like the same color? Yes
'
'    The value of my color (Red) is 0
'    The value of my pet (a Cat) is 0
'    Even though they have the same value, are they equal? No
``````

O exemplo a seguir define dois tipos de enumeração, `SledDog` e `WorkDog`.The following example defines two enumeration types, `SledDog` and `WorkDog`. A enumeração `SledDog` tem dois membros, `SledDog.AlaskanMalamute` e `SledDog.Malamute`, que têm o mesmo valor subjacente.The `SledDog` enumeration has two members, `SledDog.AlaskanMalamute` and `SledDog.Malamute`, that have the same underlying value. A chamada para o método Equals indica que esses valores são iguais porque seus valores subjacentes são os mesmos.The call to the Equals method indicates that these values are equal because their underlying values are the same. Os membros `SledDog.Malamute` e `WorkDog.Newfoundland` têm o mesmo valor subjacente, embora eles representem tipos diferentes de enumeração.The `SledDog.Malamute` and `WorkDog.Newfoundland` members have the same underlying value, although they represent different enumeration types. Uma chamada para o método Equals indica que esses valores não são iguais.A call to the Equals method indicates that these values are not equal.

``````using System;

public enum SledDog { Unknown=0, AlaskanMalamute=1, Malamute=1,
Husky=2, SiberianHusky=2 };

public enum WorkDog { Unknown=0, Newfoundland=1, GreatPyrennes=2 };

public class Example
{
public static void Main()
{
SledDog dog1 = SledDog.Malamute;
WorkDog dog3 = WorkDog.Newfoundland;

Console.WriteLine("{0:F} ({0:D}) = {1:F} ({1:D}): {2}",
dog1, dog2, dog1.Equals(dog2));
Console.WriteLine("{0:F} ({0:D}) = {1:F} ({1:D}): {2}",
dog1, dog3, dog1.Equals(dog3));
}
}
// The example displays the following output:
//       Malamute (1) = Malamute (1): True
//       Malamute (1) = Newfoundland (1): False
``````
``````Public Enum SledDog As Integer
Unknown=0
Malamute=1
Husky=2
SiberianHusky=2
End Enum

Public Enum WorkDog As Integer
Unknown=0
Newfoundland=1
GreatPyrennes=2
End Enum

Module Example
Public Sub Main()
Dim dog1 As SledDog = SledDog.Malamute
Dim dog2 As SledDog = SledDog.AlaskanMalamute
Dim dog3 As WorkDog = WorkDog.Newfoundland

Console.WriteLine("{0:F} ({0:D}) = {1:F} ({1:D}): {2}",
dog1, dog2, dog1.Equals(dog2))
Console.WriteLine("{0:F} ({0:D}) = {1:F} ({1:D}): {2}",
dog1, dog3, dog1.Equals(dog3))
End Sub
End Module
' The example displays the following output:
'       Malamute (1) = Malamute (1): True
'       Malamute (1) = Newfoundland (1): False
``````

## Comentários

O método Enum.Equals(Object) substitui ValueType.Equals(Object) para definir como os membros de enumeração são avaliados quanto à igualdade.The Enum.Equals(Object) method overrides ValueType.Equals(Object) to define how enumeration members are evaluated for equality.