# Enum.Equals(Object) Metoda

## Definicja

Zwraca wartość wskazującą, czy to wystąpienie jest równe podanemu obiektowi.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``

#### Parametry

obj
Object

Obiekt, który ma zostać porównany z tym wystąpieniem `null` .An object to compare with this instance, or `null`.

#### Zwraca

Boolean

`true` if `obj` jest wartością wyliczenia tego samego typu i z tą samą wartością bazową co to wystąpienie; w przeciwnym razie `false` .`true` if `obj` is an enumeration value of the same type and with the same underlying value as this instance; otherwise, `false`.

Poniższy przykład ilustruje Equals sposób używania metody.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
``````

W poniższym przykładzie zdefiniowano dwa typy wyliczeniowe `SledDog` i `WorkDog` .The following example defines two enumeration types, `SledDog` and `WorkDog`. `SledDog`Wyliczenie ma dwa elementy członkowskie `SledDog.AlaskanMalamute` i `SledDog.Malamute` , które ma taką samą wartość podstawową.The `SledDog` enumeration has two members, `SledDog.AlaskanMalamute` and `SledDog.Malamute`, that have the same underlying value. Wywołanie Equals metody wskazuje, że te wartości są równe, ponieważ ich wartości bazowe są takie same.The call to the Equals method indicates that these values are equal because their underlying values are the same. `SledDog.Malamute` `WorkDog.Newfoundland` Elementy członkowskie i mają tę samą wartość bazową, chociaż reprezentują różne typy wyliczeniowe.The `SledDog.Malamute` and `WorkDog.Newfoundland` members have the same underlying value, although they represent different enumeration types. Wywołanie Equals metody wskazuje, że te wartości nie są równe.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
``````

## Uwagi

Enum.Equals(Object)Metoda zastępuje metodę, ValueType.Equals(Object) Aby określić sposób oceniania elementów członkowskich wyliczenia pod kątem równości.The Enum.Equals(Object) method overrides ValueType.Equals(Object) to define how enumeration members are evaluated for equality.