Exportar (0) Imprimir
Expandir todo

Enum (Estructura)

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
/** @attribute SerializableAttribute() */ 
/** @attribute ComVisibleAttribute(true) */ 
public abstract class Enum extends ValueType implements IComparable, IFormattable, 
	IConvertible
SerializableAttribute 
ComVisibleAttribute(true) 
public abstract class Enum extends ValueType implements IComparable, IFormattable, 
	IConvertible

Una enumeración es una constante con nombre cuyo tipo subyacente es cualquier tipo integral excepto Char. Si no se declara ningún tipo subyacente de forma explícita, se utiliza Int32. 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.

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

Interfaces implementadas

Esta clase se hereda de ValueType e implementa las interfaces IComparable, IFormattable y IConvertible. Utilice la clase Convert para las conversiones en lugar de la implementación de miembro de interfaz explícita IConvertible de esta clase.

Instrucciones para FlagsAttribute y Enum

  • 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 los indicadores individuales.

  • Hay que plantearse la creación de una constante enumerada para las combinaciones de indicadores 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 los indicadores Read y Write. Además, la operación OR bit a bit usada para combinar los indicadores 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 del indicador, puesto que quizás se establezcan muchas de las posiciones del indicador en 1, provocando que el código resulte confuso y que los errores de codificación se produzcan más fácilmente.

  • Una práctica manera de probar si un indicador se ha establecido en un valor numérico es llevar a cabo una operación AND bit a bit entre el valor numérico y la constante enumerada del indicador, que establece en cero todos los bits del valor numérico que no correspondan al indicador, y probar a continuación si el resultado de esa operación es igual a la constante enumerada del indicador.

  • Utilice None como el nombre de la constante enumerada del indicador cuyo valor es cero. No se puede utilizar la constante enumerada None en una operación AND bit a bit para probar un indicador 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.

    Aunque se cree una enumeración de valor en lugar de una enumeración de indicadores, sigue mereciendo la pena crear una constante enumerada None. El motivo es que, 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 represente al valor predeterminado. Si no hay un caso predeterminado, plantéese el uso de una constante enumerada cuyo valor sea cero y que suponga el caso no representado por ninguna de las demás constantes enumeradas.

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

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

El ejemplo de código siguiente muestra cómo utilizar una enumeración para representar valores con nombre y otra enumeración con el fin de representar los campos de bits con nombre.

using System;

public class EnumTest {
    enum Days { Saturday, Sunday, Monday, Tuesday, Wednesday, Thursday, Friday };
    enum BoilingPoints { Celcius = 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);
    }
}

import System.*;

public class EnumTest
{
    enum Days
    {
        saturday (0),
        sunday (1),
        monday (2),
        tuesday (3),
        wednesday (4),
        thursday (5),
        friday (6);
    } //Days

    enum BoilingPoints
    {
        celsius (100),
        fahrenheit (212);
    } //BoilingPoints

    /** @attribute FlagsAttribute()
     */
    enum Colors
    {
        red (1),
        green (2),
        blue (4),
        yellow (8);
    } //Colors

    public static void main(String[] args)
    {
        Type weekdays = Days.class.ToType();
        Type boiling = BoilingPoints.class.ToType();

        Console.WriteLine("The days of the week, and their corresponding"
            + " values in the Days Enum are:");
        String s[] = Enum.GetNames(weekdays);
        for (int iCtr = 0; iCtr < s.length; iCtr++) {
            Console.WriteLine("{0,-11}= {1}", s[iCtr],
                Enum.Format(weekdays, Enum.Parse(weekdays, s[iCtr]), "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:");
        String s1[] = Enum.GetNames(boiling);
        for (int iCtr = 0; iCtr < s1.length; iCtr++) {
            Console.WriteLine("{0,-11}= {1}", s1[iCtr], 
                Enum.Format(boiling, Enum.Parse(boiling, s1[iCtr]), "d"));
        }
        Colors myColors = Colors.red | Colors.blue | Colors.yellow;
        Console.WriteLine();
        Console.WriteLine("myColors holds a combination of colors. Namely: {0}",
            myColors);
    } //main
} //EnumTest

import System;

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

    public static function Main() {

        var weekdays : Type = Days;
        var boiling : Type = BoilingPoints;

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

        for( var i : int in Enum.GetNames(weekdays) )
            Console.WriteLine( "{0,-11}= {1}", Enum.GetNames(weekdays).GetValue(i), 
			Enum.Format( weekdays, Enum.Parse(weekdays, Enum.GetNames(weekdays).GetValue(i)), "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:");

        for ( var j : int in Enum.GetNames(boiling) )
            Console.WriteLine( "{0,-11}= {1}", Enum.GetNames(boiling).GetValue(j), 
			Enum.Format(boiling, Enum.Parse(boiling, Enum.GetNames(boiling).GetValue(j)), "d"));

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

Este tipo es seguro para operaciones multiproceso.

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium, Windows Mobile para Pocket PC, Windows Mobile para Smartphone, Windows Server 2003, Windows XP Media Center, Windows XP Professional x64, Windows XP SP2, Windows XP Starter Edition

.NET Framework no admite todas las versiones de cada plataforma. Para obtener una lista de las versiones admitidas, vea Requisitos del sistema.

.NET Framework

Compatible con: 2.0, 1.1, 1.0

.NET Compact Framework

Compatible con: 2.0, 1.0

Adiciones de comunidad

AGREGAR
Mostrar:
© 2014 Microsoft