Exportar (0) Imprimir
Expandir todo
Este artículo proviene de un motor de traducción automática. Mueva el puntero sobre las frases del artículo para ver el texto original. Más información.
Traducción
Original

Enum (Clase)

Proporciona la clase base para las enumeraciones.

Espacio de nombres:  System
Ensamblado:  mscorlib (en mscorlib.dll)

[SerializableAttribute]
[ComVisibleAttribute(true)]
public abstract class Enum : ValueType, 
	IComparable, IFormattable, IConvertible

El tipo Enum expone los siguientes miembros.

  NombreDescripción
Método protegidoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsEnumInicializa una nueva instancia de la clase Enum.
Arriba

  NombreDescripción
Método públicoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsCompareToCompara esta instancia con un objeto especificado y devuelve una indicación de los valores relativos.
Método públicoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsEqualsDevuelve un valor que indica si esta instancia equivale a un objeto especificado. (Invalida a ValueType.Equals(Object)).
Método protegidoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsFinalize Permite que un objeto intente liberar recursos y realizar otras operaciones de limpieza antes de ser reclamado por la recolección de elementos no utilizados. (Se hereda de Object).
Método públicoMiembro estáticoCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsFormatConvierte el valor especificado de un tipo enumerado especificado en la representación de cadena equivalente de acuerdo con el formato especificado.
Método públicoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsGetHashCodeDevuelve el código hash del valor de esta instancia. (Invalida a ValueType.GetHashCode()).
Método públicoMiembro estáticoCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsGetNameRecupera el nombre de la constante de la enumeración especificada que tiene el valor especificado.
Método públicoMiembro estáticoCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsGetNamesRecupera una matriz con los nombres de las constantes de una enumeración especificada.
Método públicoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsGetType Obtiene el Type de la instancia actual. (Se hereda de Object).
Método públicoCompatible con XNA FrameworkGetTypeCodeDevuelve el TypeCode subyacente para esta instancia.
Método públicoMiembro estáticoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsGetUnderlyingTypeDevuelve el tipo subyacente de la enumeración especificada.
Método públicoMiembro estáticoCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsGetValuesRecupera una matriz con los valores de las constantes de una enumeración especificada.
Método públicoCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsHasFlagDetermina si hay uno o varios campos de bits establecidos en la instancia actual.
Método públicoMiembro estáticoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsIsDefinedDevuelve una indicación en la que se precisa si existe una constante con un valor especificado en una enumeración especificada.
Método protegidoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsMemberwiseClone Crea una copia superficial del Object actual. (Se hereda de Object).
Método públicoMiembro estáticoCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsParse(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.
Método públicoMiembro estáticoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsParse(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 distingue mayúsculas de minúsculas.
Método públicoMiembro estáticoToObject(Type, Byte)Convierte el entero de 8 bits sin signo especificado en un miembro de enumeración.
Método públicoMiembro estáticoToObject(Type, Int16)Convierte el entero de 16 bits con signo especificado en un miembro de enumeración.
Método públicoMiembro estáticoToObject(Type, Int32)Convierte el entero de 32 bits con signo especificado en un miembro de enumeración.
Método públicoMiembro estáticoToObject(Type, Int64)Convierte el entero de 64 bits con signo especificado en un miembro de enumeración.
Método públicoMiembro estáticoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsToObject(Type, Object)Convierte el objeto especificado con un valor entero en un miembro de enumeración.
Método públicoMiembro estáticoToObject(Type, SByte)Convierte el valor entero de 8 bits con signo especificado en un miembro de enumeración.
Método públicoMiembro estáticoToObject(Type, UInt16)Convierte el valor entero de 16 bits sin signo especificado en un miembro de enumeración.
Método públicoMiembro estáticoToObject(Type, UInt32)Convierte el valor entero de 32 bits sin signo especificado en un miembro de enumeración.
Método públicoMiembro estáticoToObject(Type, UInt64)Convierte el valor entero de 64 bits sin signo especificado en un miembro de enumeración.
Método públicoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsToString()Convierte el valor de esta instancia en la representación de cadena equivalente. (Invalida a ValueType.ToString()).
Método públicoCompatible con XNA FrameworkToString(IFormatProvider) Obsoleta. Esta sobrecarga del método está en desuso; utilice Enum.ToString().
Método públicoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsToString(String)Convierte el valor de esta instancia en la representación de cadena equivalente utilizando el formato especificado.
Método públicoCompatible con XNA FrameworkToString(String, IFormatProvider) Obsoleta. Esta sobrecarga del método está en desuso; utilice Enum.ToString(String).
Método públicoMiembro estáticoCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsTryParse<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.
Método públicoMiembro estáticoCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsTryParse<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.
Arriba

  NombreDescripción
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToBooleanInfraestructura. Convierte el valor actual en un valor booleano basado en el tipo subyacente.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToByteInfraestructura. Convierte el valor actual en un entero de 8 bits sin signo basado en el tipo subyacente.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToCharInfraestructura. Convierte el valor actual en un carácter Unicode basado en el tipo subyacente.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToDateTimeInfraestructura. Convierte el valor actual en DateTime basado en el tipo subyacente.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToDecimalInfraestructura. Convierte el valor actual en Decimal basado en el tipo subyacente.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToDoubleInfraestructura. Convierte el valor actual en número de punto flotante de precisión doble basado en el tipo subyacente.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToInt16Infraestructura. Convierte el valor actual en un entero de 16 bits con signo basado en el tipo subyacente.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToInt32Infraestructura. Convierte el valor actual en un entero de 32 bits con signo basado en el tipo subyacente.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToInt64Infraestructura. Convierte el valor actual en un entero de 64 bits con signo basado en el tipo subyacente.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToSByteInfraestructura. Convierte el valor actual en un entero de 8 bits con signo basado en el tipo subyacente.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToSingleInfraestructura. Convierte el valor actual en un número de punto flotante de precisión sencilla basándose en el tipo subyacente.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToTypeInfraestructura. Convierte el valor actual en un tipo especificado basado en el tipo subyacente.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToUInt16Infraestructura. Convierte el valor actual en un entero de 16 bits sin signo basado en el tipo subyacente.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToUInt32Infraestructura. Convierte el valor actual en un entero de 32 bits sin signo basado en el tipo subyacente.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToUInt64Infraestructura. Convierte el valor actual en un entero de 64 bits sin signo basado en el tipo subyacente.
Implementación explícita de interfacesMétodo privadoCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsIFormattable.ToStringInfraestructura. Obsoleta. Esta sobrecarga del método está en desuso; utilice Enum.ToString(String).
Arriba

Una enumeración es un conjunto de constantes con nombre cuyo un tipo subyacente es cualquier tipo entero. Si no se declara ningún tipo subyacente de forma explícita, se utiliza Int32. Enum es la clase base para todas las enumeraciones de .NET Framework.

Enum proporciona métodos que permiten 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 valor especificados.

Una enumeración también se puede considerar como campo de bits. Para obtener más información, vea la sección Atributo Flags y miembros no exclusivos y el tema FlagsAttribute.

Crear un tipo de enumeración

Normalmente, los lenguajes de programación proporcionan la sintaxis necesaria para declarar una enumeración, que está compuesto por un conjunto de constantes con nombre y sus valores. En el siguiente ejemplo se muestra la sintaxis utilizada por C# 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. Observe que en ambos casos, la enumeración no hereda explícitamente de Enum; el compilador administra implícitamente la relación de la herencia.


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


Nota de precauciónPrecaución

Nunca debería crear un tipo de enumeración cuyo un tipo subyacente no entero o sea Char. Aunque puede crear este tipo de enumeración utilizando la reflexión, las llamadas al método que usan el tipo resultante es no confiable y puede producir excepciones adicionales.

Crear instancias de un tipo de enumeración

Puede crear instancias de un tipo de enumeración igual que crea instancias de cualquier otro tipo de valor: declarando una variable y asignándole una de las constantes de la enumeración. En el siguiente ejemplo se crea 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)


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

  • Utilizando las características de un lenguaje de programación determinado para convertir (cast en C#) o (convert en Visual Basic) un valor entero en un valor de enumeración. En el siguiente ejemplo se crea un objeto ArrivalStatus cuyo valor es ArrivalStatus.Early, como se muestra.

    
    ArrivalStatus status2 = (ArrivalStatus) 1;
    Console.WriteLine("Arrival Status: {0} ({0:D})", status2);
    // The example displays the following output:
    //       Arrival Status: Early (1)
    
    
    
  • Mediante una llamada a su constructor predeterminado implícito. Como se muestra en el ejemplo siguiente, en este caso el valor subyacente de la instancia de enumeración es 0. Sin embargo, este 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)
    
    
    
  • Llamando al método TryParse o Parse para analizar una cadena que contiene el nombre de una constante en la enumeración. Para obtener más información, vea Analizar valores de enumeración.

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

Procedimientos recomendados de enumeración

Es recomendable utilizar los siguientes procedimientos recomendados al definir los tipos de enumeración:

  • Si no ha definido ningún miembro de enumeración cuyo valor es 0, considere crear una constante enumerada None. De forma predeterminada, Common Language Runtime inicializa a cero la memoria utilizada para la enumeración. Por consiguiente, si no se define una constante cuyo valor sea cero, la enumeración contendrá un valor ilegal al crearla.

  • Si existe un caso predeterminado obvio que la aplicación deba representar, considere el uso de una constante enumerada cuyo valor sea cero para que lo represente. Si no hay un caso predeterminado, plantéese el uso de una constante enumerada cuyo valor sea cero para especificar el caso no representado por ninguna de las demás constantes enumeradas.

  • No hay que especificar constantes enumeradas que estén reservadas para un uso futuro.

  • Cuando se define un método o propiedad que toma una constante enumerada como un valor, se debe considerar la validación del valor. El motivo es que se puede convertir un valor numérico en el tipo de enumeración incluso en el caso de que dicho valor numérico no esté definido en la enumeración.

Se hace una lista de procedimientos recomendados adicionales para los tipos de enumeración cuyas constantes son los campos de bits en la sección Atributo Flags y miembros no exclusivos.

Realizar operaciones con enumeraciones

No se puede definir nuevos métodos cuando se está creando una enumeración. Sin embargo, un tipo de enumeración hereda un conjunto completo de métodos estáticos y de instancia de la clase Enum. En las siguientes secciones se inspecciona la mayoría de estos métodos, además de varios otros métodos que se utilizan al trabajar normalmente con valores de enumeración.

1zt1ybx4.collapse_all(es-es,VS.110).gifRealizar conversiones

Puede convertir entre un miembro de enumeración y su tipo subyacente utilizando una conversión (en C#) o un operador de conversión (en Visual Basic). El ejemplo siguiente utiliza la conversión o operadores de conversión para realizar conversiones de un entero en un valor de enumeración y un valor de enumeración en un entero.


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

int value4 = (int) status3;


La clase Enum también incluye un método ToObject que convierte un valor de cualquier tipo entero en un valor de enumeración. El ejemplo siguiente utiliza el método ToObject(Type, Int32) para convertir un Int32 en un valor ArrivalStatus. Observe que, porque ToObject devuelve un valor de tipo Object, el uso de un marco o de un operador de conversión puede seguir siendo necesario convertir el objeto al tipo de enumeración.


int number = -1;
ArrivalStatus arrived = (ArrivalStatus) ArrivalStatus.ToObject(typeof(ArrivalStatus), number);


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


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


Aunque la clase Enum proporciona implementaciones de interfaz explícita de la interfaz IConvertible para convertir un valor de enumeración en un tipo entero, se deben utilizar los métodos de la clase Convert, como ToInt32, para realizar estas conversiones. El siguiente ejemplo muestra cómo se puede utilizar el método GetUnderlyingType junto con el método Convert.ChangeType para convertir un valor de enumeración en su tipo subyacente. Observe que este ejemplo no exige conocer 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


1zt1ybx4.collapse_all(es-es,VS.110).gifAnalizar valores de enumeración

Los métodos Parse 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 o el nombre o el valor subyacente de una constante de enumeración. Observe que los métodos de análisis convertirán representaciones de cadena de números que no son miembros de una enumeración determinada correctamente si las cadenas se pueden convertir en un valor del tipo subyacente a la enumeración. Para evitarlo, se puede llamar al método IsDefined para asegurarse de que el resultado del método de análisis sea un valor de enumeración válido. El ejemplo muestra este enfoque y muestra las llamadas a los métodos Parse(Type, String) y Enum.TryParse<TEnum>(String, TEnum). Observe que el método de análisis no genérico devuelve un objeto que puede tener que convertir (cast en C#) o convertir (convert en Visual Basic) en el 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


1zt1ybx4.collapse_all(es-es,VS.110).gifDar formato a los valores de enumeración

Puede convertir los valores de enumeración en sus representaciones de cadena llamando al método Format estático, así como a las sobrecargas del método ToString de la instancia. Puede utilizar una cadena de formato para controlar la manera precisa en la 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 siguiente ejemplo se utiliza cada una de las cadenas de formato de enumeración compatibles para convertir un miembro de la enumeración ArrivalStatus 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


1zt1ybx4.collapse_all(es-es,VS.110).gifRecorrer en iteración los miembros de enumeración

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

  • Puede llamar al método GetNames para recuperar una matriz de cadena que contenga los nombres de los miembros de la enumeración. Después, para cada elemento de la matriz de cadenas, puede llamar al método Parse 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)      
    
    
    
  • Puede llamar al método GetValues para recuperar una matriz que contiene los valores subyacentes en la enumeración. Después, para cada elemento de la matriz, puede llamar al método ToObject 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 (var value in values) {
       ArrivalStatus status = (ArrivalStatus) Enum.ToObject(typeof(ArrivalStatus), value);
       Console.WriteLine("   {0} ({0:D})", status);
    }                                       
    // The example displays the following output:
    //       Members of ArrivalStatus:
    //          OnTime (0)
    //          Early (1)
    //          Unknown (-3)
    //          Late (-1)
    
    
    

Atributo Flags y miembros no exclusivos

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

En otros casos, sin embargo, 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 atributo FlagsAttribute se puede utilizar para indicar que la enumeración está compuesta de campos de bits. Por ejemplo, se puede utilizar una enumeración denominada Pets para indicar los tipos de animales domésticos de una casa. Se puede definir como sigue.


[Flags] public enum Pets { None=0, Dog=1, Cat=2, Bird=4, Rodent=8,
                           Reptile=16, Other=32 };



La enumeración Pets se puede utilizar a continuación como se muestra en el siguiente ejemplo.


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


Se debe utilizar los siguientes procedimientos recomendados cuando se define una enumeración bit a bit y se aplica el atributo FlagsAttribute.

  • Sólo se debe utilizar el atributo personalizado FlagsAttribute para una enumeración si se va a llevar a cabo una operación bit a bit (AND, OR, EXCLUSIVE OR) con un valor numérico.

  • Las constantes de enumeración se deben definir en potencias de dos, es decir, 1, 2, 4, 8 y así sucesivamente. Esto consigue que en las constantes de enumeración combinadas no se superpongan las marcas individuales.

  • Hay que plantearse la creación de una constante enumerada para las combinaciones de marcas utilizadas frecuentemente. Por ejemplo, si una enumeración utilizada para las operaciones de E/S con archivos contiene las constantes enumeradas Read = 1 y Write = 2, considere la creación de la constante enumerada ReadWrite = Read OR Write, que combina las marcas Read y Write. Además, la operación OR bit a bit usada para combinar las marcas puede que en algunas circunstancias sea un concepto avanzado que no resulte necesario para las tareas sencillas.

  • Se debe tener cuidado al definir un número negativo como constante enumerada de la marca, puesto que quizás se establezcan muchas de las posiciones de la marca en 1, provocando que el código resulte confuso y que los errores de codificación se produzcan más fácilmente.

  • Una manera práctica de probar si una marca se ha establecido en un valor numérico es llamar al método HasFlag de la instancia, 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.      
    
    
    

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

    
    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.      
    
    
    
  • Utilice None como el nombre de la constante enumerada de la marca cuyo valor es cero. No se puede utilizar la constante enumerada None en una operación AND bit a bit para probar una marca puesto que el resultado siempre es cero. No obstante, se puede llevar a cabo una comparación lógica, no bit a bit, entre el valor numérico y la constante enumerada None para determinar si están establecidos algunos bits del valor numérico. Esto se muestra en el siguiente ejemplo.

    
    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.      
    
    
    
  • No se debe definir un valor de enumeración únicamente para reflejar el estado de la propia enumeración. Por ejemplo, no defina una constante enumerada que meramente marque el final de la enumeración. Si necesita determinar el último valor de la enumeración, compruebe ese valor explícitamente. Además, puede realizar una verificación de intervalo para la primera y la última de las constantes enumeradas si todos los valores del intervalo son válidos.

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


using System;

public class EnumTest {
    enum Days { Saturday, Sunday, Monday, Tuesday, Wednesday, Thursday, Friday };
    enum BoilingPoints { Celsius = 100, Fahrenheit = 212 };
    [FlagsAttribute]
    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);
    }
}


.NET Framework

Compatible con: 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Compatible con: 4, 3.5 SP1

Biblioteca de clases portable

Compatible con: Biblioteca de clases portable

.NET para aplicaciones de la Tienda Windows

Compatible con: Windows 8

.NET para aplicaciones de Windows Phone

Compatible con: Windows Phone 8, Silverlight 8.1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (no se admite el rol Server Core), Windows Server 2008 R2 (se admite el rol Server Core con SP1 o versiones posteriores; no se admite Itanium)

.NET Framework no admite todas las versiones de todas las plataformas. Para obtener una lista de las versiones compatibles, vea Requisitos de sistema de .NET Framework.

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

Adiciones de comunidad

AGREGAR
Mostrar:
© 2014 Microsoft