Enum Clase

Definición

Proporciona la clase base para las enumeraciones.

public ref class Enum abstract : ValueType, IComparable, IConvertible, IFormattable
public ref class Enum abstract : ValueType, IComparable, IFormattable
public abstract class Enum : ValueType, IComparable, IConvertible, IFormattable
[System.Serializable]
public abstract class Enum : ValueType, IComparable, IConvertible, IFormattable
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public abstract class Enum : ValueType, IComparable, IConvertible, IFormattable
public abstract class Enum : ValueType, IComparable, IFormattable
type Enum = class
    inherit ValueType
    interface IComparable
    interface IConvertible
    interface IFormattable
[<System.Serializable>]
type Enum = class
    inherit ValueType
    interface IComparable
    interface IFormattable
    interface IConvertible
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type Enum = class
    inherit ValueType
    interface IComparable
    interface IFormattable
    interface IConvertible
type Enum = class
    inherit ValueType
    interface IComparable
    interface IFormattable
Public MustInherit Class Enum
Inherits ValueType
Implements IComparable, IConvertible, IFormattable
Public MustInherit Class Enum
Inherits ValueType
Implements IComparable, IFormattable
Herencia
Derivado
Atributos
Implementaciones

Ejemplos

En el ejemplo siguiente se muestra el uso de una enumeración para representar valores con nombre y otra enumeración para representar campos de bits con nombre.

using namespace System;
enum class Days
{
   Saturday, Sunday, Monday, Tuesday, Wednesday, Thursday, Friday
};

enum class BoilingPoints
{
   Celsius = 100,
   Fahrenheit = 212
};

[Flags]

enum class Colors
{
   Red = 1,
   Green = 2,
   Blue = 4,
   Yellow = 8
};

int main()
{
   Type^ weekdays = Days::typeid;
   Type^ boiling = BoilingPoints::typeid;
   Console::WriteLine(  "The days of the week, and their corresponding values in the Days Enum are:" );
   Array^ a = Enum::GetNames( weekdays );
   Int32 i = 0;
   do
   {
      Object^ o = a->GetValue( i );
      Console::WriteLine(  "{0,-11}= {1}", o->ToString(), Enum::Format( weekdays, Enum::Parse( weekdays, o->ToString() ),  "d" ) );
   }
   while ( ++i < a->Length );

   Console::WriteLine();
   Console::WriteLine(  "Enums can also be created which have values that represent some meaningful amount." );
   Console::WriteLine(  "The BoilingPoints Enum defines the following items, and corresponding values:" );
   i = 0;
   Array^ b = Enum::GetNames( boiling );
   do
   {
      Object^ o = b->GetValue( i );
      Console::WriteLine(  "{0,-11}= {1}", o->ToString(), Enum::Format( boiling, Enum::Parse( boiling, o->ToString() ),  "d" ) );
   }
   while ( ++i < b->Length );

   Array^ c = Enum::GetNames( Colors::typeid );
   Colors myColors = Colors::Red | Colors::Blue | Colors::Yellow;
   Console::WriteLine();
   Console::Write(  "myColors holds a combination of colors. Namely:" );
   for ( i = 0; i < 3; i++ )
      Console::Write(  " {0}", c->GetValue( i ) );
}
using System;

public class EnumTest {
    enum Days { Saturday, Sunday, Monday, Tuesday, Wednesday, Thursday, Friday };
    enum BoilingPoints { Celsius = 100, Fahrenheit = 212 };
    [Flags]
    enum Colors { Red = 1, Green = 2, Blue = 4, Yellow = 8 };

    public static void Main() {

        Type weekdays = typeof(Days);
        Type boiling = typeof(BoilingPoints);

        Console.WriteLine("The days of the week, and their corresponding values in the Days Enum are:");

        foreach ( string s in Enum.GetNames(weekdays) )
            Console.WriteLine( "{0,-11}= {1}", s, Enum.Format( weekdays, Enum.Parse(weekdays, s), "d"));

        Console.WriteLine();
        Console.WriteLine("Enums can also be created which have values that represent some meaningful amount.");
        Console.WriteLine("The BoilingPoints Enum defines the following items, and corresponding values:");

        foreach ( string s in Enum.GetNames(boiling) )
            Console.WriteLine( "{0,-11}= {1}", s, Enum.Format(boiling, Enum.Parse(boiling, s), "d"));

        Colors myColors = Colors.Red | Colors.Blue | Colors.Yellow;
        Console.WriteLine();
        Console.WriteLine("myColors holds a combination of colors. Namely: {0}", myColors);
    }
}
open System

type Days =
    | Saturday = 0
    | Sunday = 1
    | Monday = 2
    | Tuesday = 3
    | Wednesday = 4
    | Thursday = 5
    | Friday = 6

type BoilingPoints =
    | Celsius = 100
    | Fahrenheit = 212

[<Flags>]
type Colors =
    | Red = 1
    | Green = 2
    | Blue = 4
    | Yellow = 8

let weekdays = typeof<Days>
let boiling = typeof<BoilingPoints>

printfn "The days of the week, and their corresponding values in the Days Enum are:"

for s in Enum.GetNames weekdays do
    printfn $"""{s,-11}= {Enum.Format(weekdays, Enum.Parse(weekdays, s), "d")}"""

printfn "\nEnums can also be created which have values that represent some meaningful amount."
printfn "The BoilingPoints Enum defines the following items, and corresponding values:"

for s in Enum.GetNames boiling do
    printfn $"""{s,-11}= {Enum.Format(boiling, Enum.Parse(boiling, s), "d")}"""

let myColors = Colors.Red ||| Colors.Blue ||| Colors.Yellow
printfn $"\nmyColors holds a combination of colors. Namely: {myColors}"
Public Class EnumTest
    Enum Days
        Saturday
        Sunday
        Monday
        Tuesday
        Wednesday
        Thursday
        Friday
    End Enum 
    
    Enum BoilingPoints
        Celsius = 100
        Fahrenheit = 212
    End Enum 
    
    <Flags()> _
    Enum Colors
        Red = 1
        Green = 2
        Blue = 4
        Yellow = 8
    End Enum 

    Public Shared Sub Main()
        Dim weekdays As Type = GetType(Days)
        Dim boiling As Type = GetType(BoilingPoints)

        Console.WriteLine("The days of the week, and their corresponding values in the Days Enum are:")

        Dim s As String
        For Each s In  [Enum].GetNames(weekdays)
            Console.WriteLine("{0,-11} = {1}", s, [Enum].Format(weekdays, [Enum].Parse(weekdays, s), "d"))
        
        Next s
        Console.WriteLine()
        Console.WriteLine("Enums can also be created which have values that represent some meaningful amount.")
        Console.WriteLine("The BoilingPoints Enum defines the following items, and corresponding values:")

        For Each s In  [Enum].GetNames(boiling)
            Console.WriteLine("{0,-11} = {1}", s, [Enum].Format(boiling, [Enum].Parse(boiling, s), "d"))
        Next s

        Dim myColors As Colors = Colors.Red Or Colors.Blue Or Colors.Yellow
        Console.WriteLine()
        Console.WriteLine("myColors holds a combination of colors. Namely: {0}", myColors)
    End Sub 
End Class

Comentarios

Una enumeración es un conjunto de constantes con nombre cuyo tipo subyacente es cualquier tipo entero. Si no se declara explícitamente ningún tipo subyacente, Int32 se usa . Enumes la clase base para todas las enumeraciones de .NET Framework. Los tipos de enumeración se definen mediante la enum palabra clave en C#, la Enumconstrucción ...End Enum en Visual Basic y la type palabra clave en F#.

Enum proporciona métodos para comparar instancias de esta clase, convertir el valor de una instancia en su representación de cadena, convertir la representación de cadena de un número en una instancia de esta clase y crear una instancia de una enumeración y un valor especificados.

También puede tratar una enumeración como un campo de bits. Para obtener más información, vea la sección Non-Exclusive Members (Miembros no exclusivos) y flags Attribute (Atributos de marcas) y el FlagsAttribute tema .

En este tema:

Creación de un tipo de enumeración Creación de instancias de un tipo de enumeración Procedimientos recomendados de enumeración Realización de operaciones con enumeraciones Análisis de valores de enumeración De formato valores deenumeración Iteración de miembros de enumeraciónNo exclusivos y el atributo FlagsAdición de métodos de enumeración

Creación de un tipo de enumeración

Los lenguajes de programación suelen proporcionar sintaxis para declarar una enumeración que consta de un conjunto de constantes con nombre y sus valores. En el ejemplo siguiente se muestra la sintaxis usada por C#, F# y Visual Basic para definir una enumeración. Crea una enumeración denominada ArrivalStatus que tiene tres miembros: ArrivalStatus.Early, ArrivalStatus.OnTimey ArrivalStatus.Late. Tenga en cuenta que, en todos los casos, la enumeración no hereda explícitamente de Enum; el compilador controla implícitamente la relación de herencia.

public enum ArrivalStatus { Late=-1, OnTime=0, Early=1 };
type ArrivalStatus =
    | Late = -1
    | OnTime = 0
    | Early = 1
Public Enum ArrivalStatus As Integer
   Late = -1
   OnTime = 0
   Early = 1
End Enum

Advertencia

Nunca debe crear un tipo de enumeración cuyo tipo subyacente no sea entero o Char. Aunque puede crear este tipo de enumeración mediante reflexión, las llamadas a métodos que usan el tipo resultante no son confiables y también pueden producir excepciones adicionales.

Creación de instancias de un tipo de enumeración

Puede crear una instancia de un tipo de enumeración al igual que crea una instancia de cualquier otro tipo de valor: declarando una variable y asignando una de las constantes de la enumeración. En el ejemplo siguiente se crea una instancia de un ArrivalStatus cuyo valor es ArrivalStatus.OnTime.

public class Example
{
   public static void Main()
   {
      ArrivalStatus status = ArrivalStatus.OnTime;
      Console.WriteLine("Arrival Status: {0} ({0:D})", status);
   }
}
// The example displays the following output:
//       Arrival Status: OnTime (0)
let status = ArrivalStatus.OnTime
printfn $"Arrival Status: {status} ({status:D})"
// The example displays the following output:
//       Arrival Status: OnTime (0)
Public Module Example
   Public Sub Main()
      Dim status As ArrivalStatus = ArrivalStatus.OnTime
      Console.WriteLine("Arrival Status: {0} ({0:D})", status)
   End Sub
End Module
' The example displays the following output:
'        Arrival Status: OnTime (0)

También puede crear una instancia de un valor de enumeración de las siguientes maneras:

  • Mediante el uso de las características de un lenguaje de programación determinado para convertir (como en C#) o convertir (como en Visual Basic) un valor entero en un valor de enumeración. En el ejemplo siguiente se crea un ArrivalStatus objeto cuyo valor está ArrivalStatus.Early de esta manera.

    ArrivalStatus status2 = (ArrivalStatus) 1;
    Console.WriteLine("Arrival Status: {0} ({0:D})", status2);
    // The example displays the following output:
    //       Arrival Status: Early (1)
    
    let status2 = enum<ArrivalStatus> 1
    printfn $"Arrival Status: {status2} ({status2:D})"
    // The example displays the following output:
    //       Arrival Status: Early (1)
    
    Dim status2 As ArrivalStatus = CType(1, ArrivalStatus)
    Console.WriteLine("Arrival Status: {0} ({0:D})", status2)
    ' The example displays the following output:
    '       Arrival Status: Early (1)
    
  • Mediante una llamada a su constructor implícito sin parámetros. Como se muestra en el ejemplo siguiente, en este caso el valor subyacente de la instancia de enumeración es 0. Sin embargo, esto no es necesariamente el valor de una constante válida en la enumeración.

    ArrivalStatus status1 = new ArrivalStatus();
    Console.WriteLine("Arrival Status: {0} ({0:D})", status1);
    // The example displays the following output:
    //       Arrival Status: OnTime (0)
    
    let status1 = ArrivalStatus()
    printfn $"Arrival Status: {status1} ({status1:D})"
    // The example displays the following output:
    //       Arrival Status: OnTime (0)
    
    Dim status1 As New ArrivalStatus()
    Console.WriteLine("Arrival Status: {0} ({0:D})", status1)
    ' The example displays the following output:
    '        Arrival Status: OnTime (0)
    
  • Llamando al Parse método o TryParse para analizar una cadena que contiene el nombre de una constante en la enumeración. Para obtener más información, vea la sección Analizar valores de enumeración .

  • Llamando al ToObject método para convertir un valor entero en un tipo de enumeración. Para obtener más información, vea la sección Realizar conversiones .

Procedimientos recomendados de enumeración

Se recomienda usar los siguientes procedimientos recomendados al definir tipos de enumeración:

  • Si no ha definido un miembro de enumeración cuyo valor es 0, considere la posibilidad de crear una None constante enumerada. De forma predeterminada, la memoria usada para la enumeración se inicializa en cero mediante Common Language Runtime. Por lo tanto, si no define una constante cuyo valor es cero, la enumeración contendrá un valor no válido cuando se cree.

  • Si hay un caso predeterminado obvio que la aplicación tiene que representar, considere la posibilidad de usar una constante enumerada cuyo valor es cero para representarla. Si no hay ningún caso predeterminado, considere la posibilidad de usar una constante enumerada cuyo valor es cero para especificar el caso que no está representado por ninguna de las otras constantes enumeradas.

  • No especifique constantes enumeradas reservadas para uso futuro.

  • Al definir un método o una propiedad que toma una constante enumerada como un valor, considere la posibilidad de validar el valor. El motivo es que puede convertir un valor numérico al tipo de enumeración incluso si ese valor numérico no está definido en la enumeración.

Los procedimientos recomendados adicionales para los tipos de enumeración cuyas constantes son campos de bits se enumeran en la sección Miembros no exclusivos y atributo Flags .

Realización de operaciones con enumeraciones

No se pueden definir nuevos métodos al crear una enumeración. Sin embargo, un tipo de enumeración hereda un conjunto completo de métodos estáticos e de instancia de la Enum clase . En las secciones siguientes se muestran la mayoría de estos métodos, además de otros métodos que se usan habitualmente al trabajar con valores de enumeración.

Realización de conversiones

Puede convertir entre un miembro de enumeración y su tipo subyacente mediante una conversión (en C# y F#) o un operador de conversión (en Visual Basic). En F#, también se usa la enum función . En el ejemplo siguiente se usan operadores de conversión o conversión para realizar conversiones de un entero a un valor de enumeración y de un valor de enumeración a un entero.

int value3 = 2;
ArrivalStatus status3 = (ArrivalStatus) value3;

int value4 = (int) status3;
let value3 = 2
let status3 = enum<ArrivalStatus> value3

let value4 = int status3
Dim value3 As Integer = 2
Dim status3 As ArrivalStatus = CType(value3, ArrivalStatus)

Dim value4 As Integer = CInt(status3)

La Enum clase también incluye un ToObject método que convierte un valor de cualquier tipo entero en un valor de enumeración. En el ejemplo siguiente se usa el ToObject(Type, Int32) método para convertir en Int32 un ArrivalStatus valor . Tenga en cuenta que, dado ToObject que devuelve un valor de tipo Object, el uso de un operador de conversión o conversión puede ser necesario para convertir el objeto al tipo de enumeración.

int number = -1;
ArrivalStatus arrived = (ArrivalStatus) ArrivalStatus.ToObject(typeof(ArrivalStatus), number);
let number = -1
let arrived = ArrivalStatus.ToObject(typeof<ArrivalStatus>, number) :?> ArrivalStatus
Dim number As Integer = -1
Dim arrived As ArrivalStatus = CType(ArrivalStatus.ToObject(GetType(ArrivalStatus), number), ArrivalStatus)

Al convertir un entero en un valor de enumeración, es posible asignar un valor que no sea realmente miembro de la enumeración. Para evitar esto, puede pasar el entero al IsDefined método antes de realizar la conversión. En el ejemplo siguiente se usa este método para determinar si los elementos de una matriz de valores enteros se pueden convertir en ArrivalStatus valores.

using System;

public enum ArrivalStatus { Unknown=-3, Late=-1, OnTime=0, Early=1 };

public class Example
{
   public static void Main()
   {
      int[] values = { -3, -1, 0, 1, 5, Int32.MaxValue };
      foreach (var value in values)
      {
         ArrivalStatus status;
         if (Enum.IsDefined(typeof(ArrivalStatus), value))
            status = (ArrivalStatus) value;
         else
            status = ArrivalStatus.Unknown;
         Console.WriteLine("Converted {0:N0} to {1}", value, status);
      }
   }
}
// The example displays the following output:
//       Converted -3 to Unknown
//       Converted -1 to Late
//       Converted 0 to OnTime
//       Converted 1 to Early
//       Converted 5 to Unknown
//       Converted 2,147,483,647 to Unknown
open System

type ArrivalStatus =
    | Unknown = -3
    | Late = -1
    | OnTime = 0
    | Early = 1

let values = [ -3; -1; 0; 1; 5; Int32.MaxValue ]
for value in values do
    let status =
        if Enum.IsDefined(typeof<ArrivalStatus>, value) then
            enum value
        else
            ArrivalStatus.Unknown
    printfn $"Converted {value:N0} to {status}"
// The example displays the following output:
//       Converted -3 to Unknown
//       Converted -1 to Late
//       Converted 0 to OnTime
//       Converted 1 to Early
//       Converted 5 to Unknown
//       Converted 2,147,483,647 to Unknown
Public Enum ArrivalStatus As Integer
   Unknown = -3
   Late = -1
   OnTime = 0
   Early = 1
End Enum

Module Example
   Public Sub Main()
      Dim values() As Integer = { -3, -1, 0, 1, 5, Int32.MaxValue }
      For Each value In values
         Dim status As ArrivalStatus
         If [Enum].IsDefined(GetType(ArrivalStatus), value)
            status = CType(value, ArrivalStatus) 
         Else
            status = ArrivalStatus.Unknown
         End If
         Console.WriteLine("Converted {0:N0} to {1}", value, status)
      Next   
   End Sub
End Module
' The example displays the following output:
'       Converted -3 to Unknown
'       Converted -1 to Late
'       Converted 0 to OnTime
'       Converted 1 to Early
'       Converted 5 to Unknown
'       Converted 2,147,483,647 to Unknown

Aunque la Enum clase proporciona implementaciones de interfaz explícitas de la IConvertible interfaz para convertir de un valor de enumeración a un tipo entero, debe usar los métodos de la Convert clase , como ToInt32, para realizar estas conversiones. En el ejemplo siguiente se muestra cómo puede usar el GetUnderlyingType método junto con el Convert.ChangeType método para convertir un valor de enumeración en su tipo subyacente. Tenga en cuenta que este ejemplo no requiere que se conozca el tipo subyacente de la enumeración en tiempo de compilación.

ArrivalStatus status = ArrivalStatus.Early;
var number = Convert.ChangeType(status, Enum.GetUnderlyingType(typeof(ArrivalStatus)));
Console.WriteLine("Converted {0} to {1}", status, number);
// The example displays the following output:
//       Converted Early to 1
let status = ArrivalStatus.Early
let number = Convert.ChangeType(status, Enum.GetUnderlyingType typeof<ArrivalStatus>)
printfn $"Converted {status} to {number}"
// The example displays the following output:
//       Converted Early to 1
Dim status As ArrivalStatus = ArrivalStatus.Early
Dim number = Convert.ChangeType(status, [Enum].GetUnderlyingType(GetType(ArrivalStatus)))
Console.WriteLine("Converted {0} to {1}", status, number)
' The example displays the following output:
'       Converted Early to 1

Análisis de valores de enumeración

Los Parse métodos y TryParse permiten convertir la representación de cadena de un valor de enumeración en ese valor. La representación de cadena puede ser el nombre o el valor subyacente de una constante de enumeración. Tenga en cuenta que los métodos de análisis convertirán correctamente representaciones de cadena de números que no son miembros de una enumeración determinada si las cadenas se pueden convertir en un valor del tipo subyacente de la enumeración. Para evitar esto, IsDefined se puede llamar al método para asegurarse de que el resultado del método de análisis es un valor de enumeración válido. En el ejemplo se muestra este enfoque y se muestran las llamadas a los Parse(Type, String) métodos y Enum.TryParse<TEnum>(String, TEnum) . Tenga en cuenta que el método de análisis no genérico devuelve un objeto que puede tener que convertir (en C# y F#) o convertir (en Visual Basic) al tipo de enumeración adecuado.

string number = "-1";
string name = "Early";

try {
   ArrivalStatus status1 = (ArrivalStatus) Enum.Parse(typeof(ArrivalStatus), number);
   if (!(Enum.IsDefined(typeof(ArrivalStatus), status1)))
      status1 = ArrivalStatus.Unknown;
   Console.WriteLine("Converted '{0}' to {1}", number, status1);
}
catch (FormatException) {
   Console.WriteLine("Unable to convert '{0}' to an ArrivalStatus value.",
                     number);
}

ArrivalStatus status2;
if (Enum.TryParse<ArrivalStatus>(name, out status2)) {
   if (!(Enum.IsDefined(typeof(ArrivalStatus), status2)))
      status2 = ArrivalStatus.Unknown;
   Console.WriteLine("Converted '{0}' to {1}", name, status2);
}
else {
   Console.WriteLine("Unable to convert '{0}' to an ArrivalStatus value.",
                     number);
}
// The example displays the following output:
//       Converted '-1' to Late
//       Converted 'Early' to Early
let number = "-1"
let name = "Early"

try
    let status1 = Enum.Parse(typeof<ArrivalStatus>, number) :?> ArrivalStatus
    let status1 =
        if not (Enum.IsDefined(typeof<ArrivalStatus>, status1) ) then
            ArrivalStatus.Unknown
        else 
            status1
        
    printfn $"Converted '{number}' to {status1}"
with :? FormatException ->
    printfn $"Unable to convert '{number}' to an ArrivalStatus value."

match Enum.TryParse<ArrivalStatus> name with
| true, status2 ->
    let status2 = 
        if not (Enum.IsDefined(typeof<ArrivalStatus>, status2) ) then
            ArrivalStatus.Unknown
        else 
            status2
    printfn $"Converted '{name}' to {status2}"
| _ ->
    printfn $"Unable to convert '{number}' to an ArrivalStatus value."
// The example displays the following output:
//       Converted '-1' to Late
//       Converted 'Early' to Early
Dim number As String = "-1"
Dim name As String = "Early"
Dim invalid As String = "32"

Try 
   Dim status1 As ArrivalStatus = CType([Enum].Parse(GetType(ArrivalStatus), number), ArrivalStatus)
   If Not [Enum].IsDefined(GetType(ArrivalStatus), status1) Then status1 = ArrivalStatus.Unknown
   Console.WriteLine("Converted '{0}' to {1}", number, status1)
Catch e As FormatException
   Console.WriteLine("Unable to convert '{0}' to an ArrivalStatus value.", 
                     number)
End Try   
   
Dim status2 As ArrivalStatus
If [Enum].TryParse(Of ArrivalStatus)(name, status2) Then
   If Not [Enum].IsDefined(GetType(ArrivalStatus), status2) Then status2 = ArrivalStatus.Unknown
   Console.WriteLine("Converted '{0}' to {1}", name, status2)
Else
   Console.WriteLine("Unable to convert '{0}' to an ArrivalStatus value.", 
                     number)
End If
' The example displays the following output:
'       Converted '-1' to Late
'       Converted 'Early' to Early

Aplicar formato a los valores de enumeración

Puede convertir los valores de enumeración en sus representaciones de cadena llamando al método estático Format , así como a las sobrecargas del método de instancia ToString . Puede usar una cadena de formato para controlar la forma precisa en que un valor de enumeración se representa como una cadena. Para obtener más información, vea Cadenas de formato de enumeración. En el ejemplo siguiente se usa cada una de las cadenas de formato de enumeración admitidas ("G" o "g", "D" o "d", "X" o "x" y "F" o "f" ) para convertir un miembro de la ArrivalStatus enumeración en sus representaciones de cadena.

string[] formats= { "G", "F", "D", "X"};
ArrivalStatus status = ArrivalStatus.Late;
foreach (var fmt in formats)
   Console.WriteLine(status.ToString(fmt));

// The example displays the following output:
//       Late
//       Late
//       -1
//       FFFFFFFF
let formats = [ "G"; "F"; "D"; "X" ]
let status = ArrivalStatus.Late
for fmt in formats do
    printfn $"{status.ToString fmt}"

// The example displays the following output:
//       Late
//       Late
//       -1
//       FFFFFFFF
Dim formats() As String = { "G", "F", "D", "X"}
Dim status As ArrivalStatus = ArrivalStatus.Late
For Each fmt As String In formats
   Console.WriteLine(status.ToString(fmt))
Next
' The example displays the following output:
'       Late
'       Late
'       -1
'       FFFFFFFF

Iteración de miembros de enumeración

El Enum tipo no implementa la IEnumerable interfaz o IEnumerable<T> , lo que le permitiría iterar miembros de una colección mediante una foreach construcción (en C#), for..in (en F#) o For Each (en Visual Basic). Sin embargo, puede enumerar los miembros de cualquiera de estas dos maneras.

  • Puede llamar al GetNames método para recuperar una matriz de cadenas que contenga los nombres de los miembros de enumeración. A continuación, para cada elemento de la matriz de cadenas, puede llamar al Parse método para convertir la cadena en su valor de enumeración equivalente. En el ejemplo siguiente se muestra este enfoque.

    string[] names = Enum.GetNames(typeof(ArrivalStatus));
    Console.WriteLine("Members of {0}:", typeof(ArrivalStatus).Name);
    Array.Sort(names);
    foreach (var name in names) {
       ArrivalStatus status = (ArrivalStatus) Enum.Parse(typeof(ArrivalStatus), name);
       Console.WriteLine("   {0} ({0:D})", status);
    }
    // The example displays the following output:
    //       Members of ArrivalStatus:
    //          Early (1)
    //          Late (-1)
    //          OnTime (0)
    //          Unknown (-3)
    
    let names = Enum.GetNames typeof<ArrivalStatus>
    printfn $"Members of {nameof ArrivalStatus}:"
    let names = Array.sort names
    for name in names do
        let status = Enum.Parse(typeof<ArrivalStatus>, name) :?> ArrivalStatus
        printfn $"   {status} ({status:D})"
    // The example displays the following output:
    //       Members of ArrivalStatus:
    //          Early (1)
    //          Late (-1)
    //          OnTime (0)
    //          Unknown (-3)
    
    Dim names() As String = [Enum].GetNames(GetType(ArrivalStatus))
    Console.WriteLine("Members of {0}:", GetType(ArrivalStatus).Name)
    Array.Sort(names)
    For Each name In names
       Dim status As ArrivalStatus = CType([Enum].Parse(GetType(ArrivalStatus), name),
                                     ArrivalStatus)
       Console.WriteLine("   {0} ({0:D})", status)
    Next
    ' The example displays the following output:
    '       Members of ArrivalStatus:
    '          Early (1)
    '          Late (-1)
    '          OnTime (0)
    '          Unknown (-3)
    
  • Puede llamar al GetValues método para recuperar una matriz que contenga los valores subyacentes en la enumeración. A continuación, para cada elemento de la matriz, puede llamar al ToObject método para convertir el entero en su valor de enumeración equivalente. En el ejemplo siguiente se muestra este enfoque.

    var values = Enum.GetValues(typeof(ArrivalStatus));
    Console.WriteLine("Members of {0}:", typeof(ArrivalStatus).Name);
    foreach (ArrivalStatus status in values) {
       Console.WriteLine("   {0} ({0:D})", status);
    }
    // The example displays the following output:
    //       Members of ArrivalStatus:
    //          OnTime (0)
    //          Early (1)
    //          Unknown (-3)
    //          Late (-1)
    
    let values = Enum.GetValues typeof<ArrivalStatus>
    printfn $"Members of {nameof ArrivalStatus}:"
    for status in values do
        printfn $"   {status} ({status:D})"
    // The example displays the following output:
    //       Members of ArrivalStatus:
    //          OnTime (0)
    //          Early (1)
    //          Unknown (-3)
    //          Late (-1)
    
    Dim values = [Enum].GetValues(GetType(ArrivalStatus))
    Console.WriteLine("Members of {0}:", GetType(ArrivalStatus).Name)
    For Each value In values
       Dim status As ArrivalStatus = CType([Enum].ToObject(GetType(ArrivalStatus), value),
                                           ArrivalStatus)
       Console.WriteLine("   {0} ({0:D})", status)
    Next                                       
    ' The example displays the following output:
    '       Members of ArrivalStatus:
    '          OnTime (0)
    '          Early (1)
    '          Unknown (-3)
    '          Late (-1)
    

Miembros no exclusivos y el atributo Flags

Un uso común de una enumeración es representar un conjunto de valores mutuamente excluyentes. Por ejemplo, una ArrivalStatus instancia puede tener un valor de Early, OnTimeo Late. No tiene sentido que el valor de una ArrivalStatus instancia refleje más de una constante de enumeración.

Sin embargo, en otros casos, el valor de un objeto de enumeración puede incluir varios miembros de enumeración y cada miembro representa un campo de bits en el valor de enumeración. El FlagsAttribute atributo se puede usar para indicar que la enumeración consta de campos de bits. Por ejemplo, una enumeración denominada Pets podría usarse para indicar los tipos de mascotas en un hogar. Se puede definir de la siguiente manera.

[Flags] public enum Pets { None=0, Dog=1, Cat=2, Bird=4, Rodent=8,
                           Reptile=16, Other=32 };
[<Flags>] 
type Pets =
    | None = 0
    | Dog = 1
    | Cat = 2
    | Bird = 4
    | Rodent = 8
    | Reptile = 16
    | Other = 32
<Flags> Public Enum Pets As Integer
   None = 0
   Dog = 1
   Cat = 2
   Bird = 4
   Rodent = 8
   Reptile = 16
   Other = 32
End Enum

A Pets continuación, la enumeración se puede usar como se muestra en el ejemplo siguiente.

Pets familyPets = Pets.Dog | Pets.Cat;
Console.WriteLine("Pets: {0:G} ({0:D})", familyPets);
// The example displays the following output:
//       Pets: Dog, Cat (3)
let familyPets = Pets.Dog ||| Pets.Cat
printfn $"Pets: {familyPets:G} ({familyPets:D})"
// The example displays the following output:
//       Pets: Dog, Cat (3)
Dim familyPets As Pets = Pets.Dog Or Pets.Cat
Console.WriteLine("Pets: {0:G} ({0:D})", familyPets)
' The example displays the following output:
'       Pets: Dog, Cat (3)

Se deben usar los procedimientos recomendados siguientes al definir una enumeración bit a bit y aplicar el FlagsAttribute atributo .

  • Use el FlagsAttribute atributo personalizado para una enumeración solo si se va a realizar una operación bit a bit (AND, OR, EXCLUSIVE OR) en un valor numérico.

  • Defina constantes de enumeración en potencias de dos, es decir, 1, 2, 4, 8, etc. Esto significa que las marcas individuales de las constantes de enumeración combinadas no se superponen.

  • Considere la posibilidad de crear una constante enumerada para combinaciones de marcas usadas habitualmente. Por ejemplo, si tiene una enumeración usada para las operaciones de E/S de archivos que contiene las constantes enumeradas Read = 1 y Write = 2, considere la posibilidad de crear la constante ReadWrite = Read OR Writeenumerada , que combina las Read marcas y Write . Además, la operación OR bit a bit usada para combinar las marcas puede considerarse un concepto avanzado en algunas circunstancias que no deben ser necesarias para tareas sencillas.

  • Tenga cuidado si define un número negativo como una constante enumerada de marca porque muchas posiciones de marca pueden establecerse en 1, lo que podría hacer que el código sea confuso y fomentar errores de codificación.

  • Una manera cómoda de probar si una marca está establecida en un valor numérico es llamar al método de instancia HasFlag , como se muestra en el ejemplo siguiente.

    Pets familyPets = Pets.Dog | Pets.Cat;
    if (familyPets.HasFlag(Pets.Dog))
       Console.WriteLine("The family has a dog.");
    // The example displays the following output:
    //       The family has a dog.
    
    let familyPets = Pets.Dog ||| Pets.Cat
    if familyPets.HasFlag Pets.Dog then
        printfn "The family has a dog."
    // The example displays the following output:
    //       The family has a dog.
    
    Dim familyPets As Pets = Pets.Dog Or Pets.Cat
    If familyPets.HasFlag(Pets.Dog) Then
       Console.WriteLine("The family has a dog.")
    End If
    ' The example displays the following output:
    '       The family has a dog.
    

    Equivale a realizar una operación AND bit a bit entre el valor numérico y la constante enumerada de marca, que establece todos los bits del valor numérico en cero que no corresponden a la marca y, a continuación, comprueba si el resultado de esa operación es igual a la constante enumerada de marca. Esto se muestra en el ejemplo siguiente.

    Pets familyPets = Pets.Dog | Pets.Cat;
    if ((familyPets & Pets.Dog) == Pets.Dog)
       Console.WriteLine("The family has a dog.");
    // The example displays the following output:
    //       The family has a dog.
    
    let familyPets = Pets.Dog ||| Pets.Cat
    if (familyPets &&& Pets.Dog) = Pets.Dog then
        printfn "The family has a dog."
    // The example displays the following output:
    //       The family has a dog.
    
    Dim familyPets As Pets = Pets.Dog Or Pets.Cat
    If familyPets And Pets.Dog = Pets.Dog Then
       Console.WriteLine("The family has a dog.")
    End If   
    ' The example displays the following output:
    '       The family has a dog.
    
  • Use None como nombre de la constante enumerada de la marca cuyo valor es cero. No puede usar la None constante enumerada en una operación AND bit a bit para probar una marca porque el resultado siempre es cero. Sin embargo, puede realizar una comparación lógica, no bit a bit, entre el valor numérico y la None constante enumerada para determinar si se establecen bits en el valor numérico. Esto se muestra en el ejemplo siguiente.

    Pets familyPets = Pets.Dog | Pets.Cat;
    if (familyPets == Pets.None)
       Console.WriteLine("The family has no pets.");
    else
       Console.WriteLine("The family has pets.");
    // The example displays the following output:
    //       The family has pets.
    
    let familyPets = Pets.Dog ||| Pets.Cat
    if familyPets = Pets.None then
        printfn "The family has no pets."
    else
        printfn "The family has pets."
    // The example displays the following output:
    //       The family has pets.
    
    Dim familyPets As Pets = Pets.Dog Or Pets.Cat
    If familyPets = Pets.None Then
       Console.WriteLine("The family has no pets.")
    Else
       Console.WriteLine("The family has pets.")   
    End If
    ' The example displays the following output:
    '       The family has pets.
    
  • No defina un valor de enumeración únicamente para reflejar el estado de la propia enumeración. Por ejemplo, no defina una constante enumerada que simplemente marque el final de la enumeración. Si necesita determinar el último valor de la enumeración, compruebe explícitamente ese valor. Además, puede realizar una comprobación de intervalo para la primera y la última constante enumerada si todos los valores del intervalo son válidos.

Adición de métodos de enumeración

Dado que los tipos de enumeración se definen mediante estructuras de lenguaje, como enum (C#) y Enum (Visual Basic), no se pueden definir métodos personalizados para un tipo de enumeración distinto de los métodos heredados de la Enum clase . Sin embargo, puede usar métodos de extensión para agregar funcionalidad a un tipo de enumeración determinado.

En el ejemplo siguiente, la enumeración Grades representa las posibles calificaciones con letras que un alumno puede recibir en una clase. Un método de extensión denominado Passing se agrega al tipo Grades para que cada instancia de ese tipo "sepa" ahora si representa una calificación de aprobado o no. La Extensions clase también contiene una variable de lectura y escritura estática que define el grado mínimo de aprobación. El valor devuelto del método de Passing extensión refleja el valor actual de esa variable.

using System;

// Define an enumeration to represent student grades.
public enum Grades { F = 0, D = 1, C = 2, B = 3, A = 4 };

// Define an extension method for the Grades enumeration.
public static class Extensions
{
  public static Grades minPassing = Grades.D;

  public static bool Passing(this Grades grade)
  {
      return grade >= minPassing;
  }
}

class Example
{
  static void Main()
  {
      Grades g1 = Grades.D;
      Grades g2 = Grades.F;
      Console.WriteLine("{0} {1} a passing grade.", g1, g1.Passing() ? "is" : "is not");
      Console.WriteLine("{0} {1} a passing grade.", g2, g2.Passing() ? "is" : "is not");

      Extensions.minPassing = Grades.C;
      Console.WriteLine("\nRaising the bar!\n");
      Console.WriteLine("{0} {1} a passing grade.", g1, g1.Passing() ? "is" : "is not");
      Console.WriteLine("{0} {1} a passing grade.", g2, g2.Passing() ? "is" : "is not");
  }
}
// The exmaple displays the following output:
//       D is a passing grade.
//       F is not a passing grade.
//
//       Raising the bar!
//
//       D is not a passing grade.
//       F is not a passing grade.
open System
open System.Runtime.CompilerServices
// Define an enumeration to represent student grades.
type Grades =
    | F = 0
    | D = 1
    | C = 2
    | B = 3
    | A = 4

let mutable minPassing = Grades.D

// Define an extension method for the Grades enumeration.
[<Extension>]
type Extensions =
    [<Extension>]
    static member Passing(grade) = grade >= minPassing

let g1 = Grades.D
let g2 = Grades.F
printfn $"""{g1} {if g1.Passing() then "is" else "is not"} a passing grade."""
printfn $"""{g2} {if g2.Passing() then "is" else "is not"} a passing grade."""

minPassing <- Grades.C
printfn "\nRaising the bar!\n"
printfn $"""{g1} {if g1.Passing() then "is" else "is not"} a passing grade."""
printfn $"""{g2} {if g2.Passing() then "is" else "is not"} a passing grade."""
// The exmaple displays the following output:
//       D is a passing grade.
//       F is not a passing grade.
//
//       Raising the bar!
//
//       D is not a passing grade.
//       F is not a passing grade.
Imports System.Runtime.CompilerServices

' Define an enumeration to represent student grades.
Public Enum Grades As Integer
   F = 0
   D = 1
   C = 2
   B = 3
   A = 4
End Enum   

' Define an extension method for the Grades enumeration.
Public Module Extensions
  Public minPassing As Grades = Grades.D
 
  <Extension>
  Public Function Passing(grade As Grades) As Boolean
     Return grade >= minPassing
  End Function
End Module

Public Module Example
  Public Sub Main()
      Dim g1 As Grades = Grades.D
      Dim g2 As Grades = Grades.F
      Console.WriteLine("{0} {1} a passing grade.", 
                        g1, If(g1.Passing(), "is", "is not"))
      Console.WriteLine("{0} {1} a passing grade.", 
                        g2, If(g2.Passing(), "is", "is not"))
      Console.WriteLine()
      
      Extensions.minPassing = Grades.C
      Console.WriteLine("Raising the bar!")
      Console.WriteLine()
      Console.WriteLine("{0} {1} a passing grade.", 
                        g1, If(g1.Passing(), "is", "is not"))
      Console.WriteLine("{0} {1} a passing grade.", 
                        g2, If(g2.Passing(), "is", "is not"))
  End Sub
End Module
' The exmaple displays the following output:
'       D is a passing grade.
'       F is not a passing grade.
'       
'       Raising the bar!
'       
'       D is not a passing grade.
'       F is not a passing grade.

Constructores

Enum()

Inicializa una nueva instancia de la clase Enum.

Métodos

CompareTo(Object)

Compara esta instancia con un objeto especificado y devuelve una indicación de los valores relativos.

Equals(Object)

Devuelve un valor que indica si esta instancia equivale a un objeto especificado.

Format(Type, Object, String)

Convierte el valor especificado de un tipo enumerado especificado en la representación de cadena equivalente de acuerdo con el formato especificado.

GetHashCode()

Devuelve el código hash del valor de esta instancia.

GetName(Type, Object)

Recupera el nombre de la constante de la enumeración especificada que tiene el valor especificado.

GetName<TEnum>(TEnum)

Recupera el nombre de la constante del tipo de enumeración especificado que tiene el valor especificado.

GetNames(Type)

Recupera una matriz con los nombres de las constantes de una enumeración especificada.

GetNames<TEnum>()

Recupera una matriz con los nombres de las constantes de un tipo de enumeración especificado.

GetType()

Obtiene el Type de la instancia actual.

(Heredado de Object)
GetTypeCode()

Devuelve el código de tipo del tipo subyacente de este miembro de enumeración.

GetUnderlyingType(Type)

Devuelve el tipo subyacente de la enumeración especificada.

GetValues(Type)

Recupera una matriz con los valores de las constantes de una enumeración especificada.

GetValues<TEnum>()

Recupera una matriz con los valores de las constantes de un tipo de enumeración especificado.

HasFlag(Enum)

Determina si hay uno o varios campos de bits establecidos en la instancia actual.

IsDefined(Type, Object)

Devuelve un booleano que indica si un valor integral especificado, o bien su nombre en forma de cadena, existe en una enumeración especifica.

IsDefined<TEnum>(TEnum)

Devuelve un booleano que indica si un valor integral especificado, o bien su nombre en forma de cadena, existe en una enumeración especifica.

MemberwiseClone()

Crea una copia superficial del Object actual.

(Heredado de Object)
Parse(Type, ReadOnlySpan<Char>)

Convierte el intervalo de caracteres que representa el nombre o el valor numérico de una o varias constantes enumeradas en un objeto enumerado equivalente.

Parse(Type, ReadOnlySpan<Char>, Boolean)

Convierte el intervalo de caracteres que representa el nombre o el valor numérico de una o varias constantes enumeradas en un objeto enumerado equivalente. Un parámetro especifica si la operación no distingue mayúsculas de minúsculas.

Parse(Type, String)

Convierte la representación de cadena del nombre o valor numérico de una o varias constantes enumeradas en un objeto enumerado equivalente.

Parse(Type, String, Boolean)

Convierte la representación de cadena del nombre o valor numérico de una o varias constantes enumeradas en un objeto enumerado equivalente. Un parámetro especifica si la operación no distingue mayúsculas de minúsculas.

Parse<TEnum>(ReadOnlySpan<Char>)

Convierte el intervalo de caracteres que representa el nombre o el valor numérico de una o varias constantes enumeradas especificadas por TEnum en un objeto enumerado equivalente.

Parse<TEnum>(ReadOnlySpan<Char>, Boolean)

Convierte el intervalo de caracteres que representa el nombre o el valor numérico de una o varias constantes enumeradas especificadas por TEnum en un objeto enumerado equivalente. Un parámetro especifica si la operación no distingue mayúsculas de minúsculas.

Parse<TEnum>(String)

Convierte la representación de cadena del nombre o valor numérico de una o varias constantes enumeradas especificadas por TEnum en un objeto enumerado equivalente.

Parse<TEnum>(String, Boolean)

Convierte la representación de cadena del nombre o valor numérico de una o varias constantes enumeradas especificadas por TEnum en un objeto enumerado equivalente. Un parámetro especifica si la operación no distingue mayúsculas de minúsculas.

ToObject(Type, Byte)

Convierte el entero de 8 bits sin signo especificado en un miembro de enumeración.

ToObject(Type, Int16)

Convierte el entero de 16 bits con signo especificado en un miembro de enumeración.

ToObject(Type, Int32)

Convierte el entero de 32 bits con signo especificado en un miembro de enumeración.

ToObject(Type, Int64)

Convierte el entero de 64 bits con signo especificado en un miembro de enumeración.

ToObject(Type, Object)

Convierte el objeto especificado con un valor entero en un miembro de enumeración.

ToObject(Type, SByte)

Convierte el valor entero de 8 bits con signo especificado en un miembro de enumeración.

ToObject(Type, UInt16)

Convierte el valor entero de 16 bits sin signo especificado en un miembro de enumeración.

ToObject(Type, UInt32)

Convierte el valor entero de 32 bits sin signo especificado en un miembro de enumeración.

ToObject(Type, UInt64)

Convierte el valor entero de 64 bits sin signo especificado en un miembro de enumeración.

ToString()

Convierte el valor de esta instancia en la representación de cadena equivalente.

ToString(IFormatProvider)
Obsoleto.
Obsoleto.

Esta sobrecarga del método está en desuso; use ToString().

ToString(String)

Convierte el valor de esta instancia en la representación de cadena equivalente usando el formato especificado.

ToString(String, IFormatProvider)
Obsoleto.
Obsoleto.

Esta sobrecarga del método está en desuso; use ToString(String).

TryParse(Type, ReadOnlySpan<Char>, Boolean, Object)

Convierte el intervalo de caracteres que representa el nombre o el valor numérico de una o varias constantes enumeradas en un objeto enumerado equivalente. Un parámetro especifica si la operación no distingue mayúsculas de minúsculas.

TryParse(Type, ReadOnlySpan<Char>, Object)

Convierte el intervalo de caracteres que representa el nombre o el valor numérico de una o varias constantes enumeradas en un objeto enumerado equivalente.

TryParse(Type, String, Boolean, Object)

Convierte la representación de cadena del nombre o valor numérico de una o varias constantes enumeradas en un objeto enumerado equivalente.

TryParse(Type, String, Object)

Convierte la representación de cadena del nombre o valor numérico de una o varias constantes enumeradas en un objeto enumerado equivalente.

TryParse<TEnum>(ReadOnlySpan<Char>, Boolean, TEnum)

Convierte la representación de cadena del nombre o valor numérico de una o varias constantes enumeradas en un objeto enumerado equivalente. Un parámetro especifica si la operación distingue mayúsculas de minúsculas. El valor devuelto indica si la conversión se realizó correctamente.

TryParse<TEnum>(ReadOnlySpan<Char>, TEnum)

Convierte la representación de cadena del nombre o valor numérico de una o varias constantes enumeradas en un objeto enumerado equivalente.

TryParse<TEnum>(String, Boolean, TEnum)

Convierte la representación de cadena del nombre o valor numérico de una o varias constantes enumeradas en un objeto enumerado equivalente. Un parámetro especifica si la operación distingue mayúsculas de minúsculas. El valor devuelto indica si la conversión se realizó correctamente.

TryParse<TEnum>(String, TEnum)

Convierte la representación de cadena del nombre o valor numérico de una o varias constantes enumeradas en un objeto enumerado equivalente. El valor devuelto indica si la conversión se realizó correctamente.

Implementaciones de interfaz explícitas

IConvertible.GetTypeCode()

Devuelve el código de tipo de esta instancia Enum.

IConvertible.ToBoolean(IFormatProvider)

Convierte el valor actual en un valor booleano basado en el tipo subyacente.

IConvertible.ToByte(IFormatProvider)

Convierte el valor actual en un entero de 8 bits sin signo basado en el tipo subyacente.

IConvertible.ToChar(IFormatProvider)

Convierte el valor actual en un carácter Unicode basado en el tipo subyacente.

IConvertible.ToDateTime(IFormatProvider)

Convierte el valor actual en DateTime basado en el tipo subyacente.

IConvertible.ToDecimal(IFormatProvider)

Convierte el valor actual en Decimal basado en el tipo subyacente.

IConvertible.ToDouble(IFormatProvider)

Convierte el valor actual en número de punto flotante de precisión doble basado en el tipo subyacente.

IConvertible.ToInt16(IFormatProvider)

Convierte el valor actual en un entero de 16 bits con signo basado en el tipo subyacente.

IConvertible.ToInt32(IFormatProvider)

Convierte el valor actual en un entero de 32 bits con signo basado en el tipo subyacente.

IConvertible.ToInt64(IFormatProvider)

Convierte el valor actual en un entero de 64 bits con signo basado en el tipo subyacente.

IConvertible.ToSByte(IFormatProvider)

Convierte el valor actual en un entero de 8 bits con signo basado en el tipo subyacente.

IConvertible.ToSingle(IFormatProvider)

Convierte el valor actual en un número de punto flotante de precisión sencilla basándose en el tipo subyacente.

IConvertible.ToString(IFormatProvider)
Obsoleto.

Esta sobrecarga del método está en desuso; en su lugar, use ToString().

IConvertible.ToType(Type, IFormatProvider)

Convierte el valor actual en un tipo especificado basado en el tipo subyacente.

IConvertible.ToUInt16(IFormatProvider)

Convierte el valor actual en un entero de 16 bits sin signo basado en el tipo subyacente.

IConvertible.ToUInt32(IFormatProvider)

Convierte el valor actual en un entero de 32 bits sin signo basado en el tipo subyacente.

IConvertible.ToUInt64(IFormatProvider)

Convierte el valor actual en un entero de 64 bits sin signo basado en el tipo subyacente.

IFormattable.ToString(String, IFormatProvider)
Obsoleto.

Esta sobrecarga del método está en desuso; use ToString(String).

Se aplica a

Seguridad para subprocesos

Este tipo es seguro para la ejecución de subprocesos.

Consulte también