Esta documentación está archivada y no tiene mantenimiento.

Tipos de enumeración definidos por el usuario (J#)

Visual Studio 2005

Visual J# proporciona compatibilidad para crear tipos de enumeración. Un tipo de enumeración es un valor int que contiene constantes con nombre que representan diferentes valores posibles.

Una enumeración es un tipo de valor definido por el usuario. Se aplican las reglas para la semántica de los tipos de valor. Para obtener más información, vea Tipos de valores definidos por el usuario.

Una declaración de un tipo de enumeración es similar a una declaración de clase. Sin embargo, se aplican las reglas adicionales siguientes:

  • La palabra clave enum se utiliza en lugar de la palabra clave class.

  • Los tipos de enumeración extienden Enum implícitamente.

  • Los tipos de enumeración son implícitamente static y final.

  • Los tipos de enumeración no se pueden declarar como abstract.

  • Los tipos de enumeración pueden ser public o private o con ámbito de paquete, pero no protected.

  • Los tipos de enumeración no pueden tener métodos, propiedades ni eventos.

  • Los tipos de enumeración no pueden implementar interfaces.

  • Los tipos de enumeración no están disponibles con la opción /x (Deshabilitar extensiones de lenguaje).

Los valores con nombre de un tipo de enumeración se declaran como miembros static final de la enumeración y se inicializan con expresiones constantes, como se muestra en el ejemplo siguiente:

// enum1.jsl
// compile with: /target:library
public enum ColorEnum
{
    Red,
    Green,
    Blue
}

Se puede hacer referencia a un valor de enumeración como un campo estático, tal como se muestra a continuación:

int i = (int) ColorEnum.Red

Es un error intentar crear instancias de un valor de enumeración utilizando la palabra clave new.

El valor de tipo integral de un miembro enum se puede establecer utilizando la sintaxis siguiente:

public enum ColorEnum
{
    Red(1),
    Green(2),
    Blue(3)
}

Si no se establecen explícitamente, los valores de tipo integral se establecen implícitamente. El primer valor de enumeración en la declaración de enumeración se establece en 0. Cualquier miembro subsiguiente, si no se establece explícitamente, se determina a partir del valor del miembro anterior incrementado en una unidad. Por ejemplo, en la declaración siguiente:

public enum ColorEnum
{
   Red,
   Green(10),
   Blue
}

Red obtiene el valor 0, Green obtiene el valor 10 y Blue obtiene el valor 11.

Varios miembros de tipo de enumeración pueden compartir el mismo valor de tipo integral.

Se permiten las dependencias de miembros de un valor enum a otros miembros, siempre que la dependencia no sea circular.

// enum2.jsl
// compile with: /target:library
public enum ColorEnum
{
   Red,
   Blue,
   Green(Blue);
}

Los métodos y las propiedades heredados de Enum se pueden utilizar en los valores de un tipo de enumeración.

Los tipos de enumeración no se pueden convertir implícitamente en su tipo subyacente ni en cualquier otro tipo integral o de enumeración. Se deben convertir explícitamente utilizando una conversión de tipos. El siguiente fragmento no es correcto:

int i = Color.Red; // error
int i = (int) Color.Red;  // OK

Se pueden utilizar los operadores siguientes en los valores de tipos de enumeración: ==, !=, <, >, <=, >=, +, -, ^, &, |, ~.

Los tipos de enumeración son tipos de valor y participan en conversiones boxing al igual que otros tipos de valor.

Los tipos de enumeración se pueden utilizar en una instrucción switch. Los miembros de enumeración se pueden utilizar como etiquetas de caso.

ColorEnum color = Color.Red;
switch( color )
{
    case ColorEnum.Red:
    // ...
    break;
    case ColorEnum.Blue:
    // ...
    break;
    case ColorEnum.Green:
    //...
    break;
    default:
    break;
}

Cada tipo enum define un tipo único; se requiere una conversión de enumeración explícita para convertir entre dos tipos enum. El conjunto de valores que puede tomar un tipo enum no está limitado por sus miembros enum. En particular, cualquier valor del tipo subyacente de un valor enum se puede convertir en el tipo enum y es un valor único de ese tipo enum.

Al igual que otros tipos de valor, los tipos de enumeración no admiten la reflexión de Java y no se pueden serializar como tipos de Java. Utilice la reflexión de .NET Framework y la serialización de .NET Framework para estos tipos.

// enum_example.jsl
import System.*;

public enum RGBColor
{
    Red,
    Blue,
    Green
}

public final class RGB
{
    private int[] m_colors = new int[3];

    public RGB()
    {
        for (RGBColor rgb1 = RGBColor.Red;
            (int)rgb1 <= (int)RGBColor.Green;
            rgb1 = (RGBColor)((int)rgb1 + 1))
        {
        m_colors[(int)rgb1] = 0;
        }
    }

    public RGB(int r1, int r2, int r3)
    {
        // Enums must be converted to an integral type 
        // for use as array indices.
    m_colors[(int)RGBColor.Red] = r1;
    m_colors[(int)RGBColor.Green] = r2;
    m_colors[(int)RGBColor.Blue] = r3;
    }

    int get_Color(RGBColor c)
    {
    return m_colors[(int)c];
    }

    public static void printRGBColor(RGBColor c)
    {
    switch( c )
    {
        case RGBColor.Red:
        Console.WriteLine("Red");
        break;
        case RGBColor.Blue:
             Console.WriteLine("Blue");
            break;
        case RGBColor.Green:
            Console.WriteLine("Green");
            break;
        default:
            break;
    }

    }
    
}

public class CMain
{
    public static void main()
    {
    RGB black = new RGB();
    RGB white = new RGB(255, 255, 255);

    Console.WriteLine("Black consists of R: " + 
    black.get_Color(RGBColor.Red)
        + " G: " + black.get_Color(RGBColor.Green) 
        + " B: " + black.get_Color(RGBColor.Blue));
    
    Console.WriteLine("White consists of R: " + 
    white.get_Color(RGBColor.Red)
        + " G: " + white.get_Color(RGBColor.Green) 
        + " B: " + white.get_Color(RGBColor.Blue));

    RGB.printRGBColor( RGBColor.Red);
  }
}

Black consists of R: 0 G: 0 B: 0
White consists of R: 255 G: 255 B: 255
Red
Mostrar: