Sdílet prostřednictvím


Enum.Equals(Object) Metoda

Definice

Vrací hodnotu, která určuje, zda je tato instance rovna zadanému objektu.

public:
 override bool Equals(System::Object ^ obj);
public override bool Equals (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

Objekt pro porovnání s touto instancí nebo null.

Návraty

true if obj je hodnota výčtu stejného typu a se stejnou podkladovou hodnotou jako tato instance; v opačném případě false.

Příklady

Následující příklad ukazuje použití Equals metody .

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
open System

type Colors =
    | Red = 0
    | Green = 1
    | Blue = 2
    | Yellow = 3

type Mammals =
    | Cat = 0
    | Dog = 1
    | Horse = 2
    | Dolphin = 3

let myPet = Mammals.Cat
let myColor = Colors.Red
let yourPet = Mammals.Dog
let yourColor = Colors.Red

printfn 
    $"""My favorite animal is a {myPet}
Your favorite animal is a {yourPet}
Do we like the same animal? {if myPet.Equals yourPet then "Yes" else "No"}

My favorite color is {myColor}
Your favorite color is {yourColor}
Do we like the same color? {if myColor.Equals yourColor then "Yes" else "No"}

The value of my color ({myColor}) is {Enum.Format(typeof<Colors>, myColor, "d")}
The value of my pet (a {myPet}) is {Enum.Format(typeof<Mammals>, myPet, "d")}
Even though they have the same value, are they equal? {if myColor.Equals myPet then "Yes" else "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

Následující příklad definuje dva typy výčtu a SledDogWorkDog. Výčet SledDog má dva členy, SledDog.AlaskanMalamute a SledDog.Malamute, které mají stejnou podkladovou hodnotu. Volání Equals metody indikuje, že tyto hodnoty jsou stejné, protože jejich podkladové hodnoty jsou stejné. Členy SledDog.Malamute a WorkDog.Newfoundland mají stejnou podkladovou hodnotu, i když představují různé typy výčtu. Volání Equals metody indikuje, že tyto hodnoty nejsou stejné.

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;
      SledDog dog2 = SledDog.AlaskanMalamute;
      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
type SledDog =
    | Unknown = 0
    | AlaskanMalamute = 1
    | Malamute = 1
    | Husky = 2
    | SiberianHusky = 2

type WorkDog =
    | Unknown = 0
    | Newfoundland = 1
    | GreatPyrennes = 2

let dog1 = SledDog.Malamute
let dog2 = SledDog.AlaskanMalamute
let dog3 = WorkDog.Newfoundland

printfn $"{dog1:F} ({dog1:D}) = {dog2:F} ({dog2:D}): {dog1.Equals dog2}"
printfn $"{dog1:F} ({dog1:D}) = {dog3:F} ({dog3:D}): {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
   AlaskanMalamute=1
   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

Poznámky

Metoda Enum.Equals(Object) přepisuje ValueType.Equals(Object) , aby definovala, jak jsou členy výčtu vyhodnoceny z hlediska rovnosti.

Platí pro

Viz také