# 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
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 `Enum`construcció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

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.OnTime`y `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
``````

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 .

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.

• 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`, `OnTime`o `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 Write`enumerada , 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
{

{
}
}

class Example
{
static void Main()
{
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");

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.
| F = 0
| D = 1
| C = 2
| B = 3
| A = 4

// Define an extension method for the Grades enumeration.
[<Extension>]
type Extensions =
[<Extension>]

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."""

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.
F = 0
D = 1
C = 2
B = 3
A = 4
End Enum

' Define an extension method for the Grades enumeration.
Public Module Extensions

<Extension>
End Function
End Module

Public Module Example
Public Sub Main()
g1, If(g1.Passing(), "is", "is not"))
g2, If(g2.Passing(), "is", "is not"))
Console.WriteLine()

Console.WriteLine("Raising the bar!")
Console.WriteLine()
g1, If(g1.Passing(), "is", "is not"))
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

 Inicializa una nueva instancia de la clase Enum.

## Métodos

 Compara esta instancia con un objeto especificado y devuelve una indicación de los valores relativos. Devuelve un valor que indica si esta instancia equivale a un objeto especificado. Convierte el valor especificado de un tipo enumerado especificado en la representación de cadena equivalente de acuerdo con el formato especificado. Devuelve el código hash del valor de esta instancia. Recupera el nombre de la constante de la enumeración especificada que tiene el valor especificado. Recupera el nombre de la constante del tipo de enumeración especificado que tiene el valor especificado. Recupera una matriz con los nombres de las constantes de una enumeración especificada. Recupera una matriz con los nombres de las constantes de un tipo de enumeración especificado. Obtiene el Type de la instancia actual. (Heredado de Object) Devuelve el código de tipo del tipo subyacente de este miembro de enumeración. Devuelve el tipo subyacente de la enumeración especificada. Recupera una matriz con los valores de las constantes de una enumeración especificada. Recupera una matriz con los valores de las constantes de un tipo de enumeración especificado. Determina si hay uno o varios campos de bits establecidos en la instancia actual. Devuelve un booleano que indica si un valor integral especificado, o bien su nombre en forma de cadena, existe en una enumeración especifica. Devuelve un booleano que indica si un valor integral especificado, o bien su nombre en forma de cadena, existe en una enumeración especifica. Crea una copia superficial del Object actual. (Heredado de 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. 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. Convierte la representación de cadena del nombre o valor numérico de una o varias constantes enumeradas en un objeto enumerado equivalente. 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. 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. 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. 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. 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. Convierte el entero de 8 bits sin signo especificado en un miembro de enumeración. Convierte el entero de 16 bits con signo especificado en un miembro de enumeración. Convierte el entero de 32 bits con signo especificado en un miembro de enumeración. Convierte el entero de 64 bits con signo especificado en un miembro de enumeración. Convierte el objeto especificado con un valor entero en un miembro de enumeración. Convierte el valor entero de 8 bits con signo especificado en un miembro de enumeración. Convierte el valor entero de 16 bits sin signo especificado en un miembro de enumeración. Convierte el valor entero de 32 bits sin signo especificado en un miembro de enumeración. Convierte el valor entero de 64 bits sin signo especificado en un miembro de enumeración. Convierte el valor de esta instancia en la representación de cadena equivalente. Obsoleto. Obsoleto. Esta sobrecarga del método está en desuso; use ToString(). Convierte el valor de esta instancia en la representación de cadena equivalente usando el formato especificado. Obsoleto. Obsoleto. Esta sobrecarga del método está en desuso; use ToString(String). 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. 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. Convierte la representación de cadena del nombre o valor numérico de una o varias constantes enumeradas en un objeto enumerado equivalente. Convierte la representación de cadena del nombre o valor numérico de una o varias constantes enumeradas en un objeto enumerado equivalente. 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. Convierte la representación de cadena del nombre o valor numérico de una o varias constantes enumeradas en un objeto enumerado equivalente. 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. 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.