La enumeración (o enumeración) es un tipo de datos de valor en C#. Se utiliza principalmente para asignar nombres o valores de string a constantes integrales, que hacen que un programa sea fácil de leer y mantener. Por ejemplo, los 4 palos en una baraja de naipes pueden ser 4 enumeradores llamados Trébol, Diamante, Corazón y Pica, pertenecientes a un tipo enumerado llamado Palo. Otros ejemplos incluyen tipos enumerados naturales (como los planetas, días de la semana, colores, direcciones, etc.). El objetivo principal de enum es definir nuestros propios tipos de datos (Tipos de datos enumerados). La enumeración se declara usando la palabra clave enum directamente dentro de un espacio de nombres, clase o estructura.
Sintaxis:
enum Enum_variable
{
string_1...;
string_2...;
.
.
}
En la sintaxis anterior, Enum_variable es el nombre del enumerador, y string_1 se adjunta con el valor 0, string_2 se adjunta el valor 1 y así sucesivamente. Porque de forma predeterminada, el primer miembro de una enumeración tiene el valor 0, y el valor de cada miembro de enumeración sucesivo aumenta en 1. Podemos cambiar este valor predeterminado.
- Ejemplo 1: Considere el siguiente código para la enumeración. Aquí se crea una enumeración con el nombre del mes y sus miembros de datos son el nombre de meses como enero, febrero, marzo, abril, mayo. Ahora intentemos imprimir los valores enteros predeterminados de estas enumeraciones. Se requiere una conversión explícita para convertir de un tipo de enumeración a un tipo integral.
C#
// C# program to illustrate the enums
// with their default values
using System;
namespace ConsoleApplication1 {
// making an enumerator 'month'
enum month
{
// following are the data members
jan,
feb,
mar,
apr,
may
}
class Program {
// Main Method
static void Main(string[] args)
{
// getting the integer values of data members..
Console.WriteLine("The value of jan in month " +
"enum is " + (int)month.jan);
Console.WriteLine("The value of feb in month " +
"enum is " + (int)month.feb);
Console.WriteLine("The value of mar in month " +
"enum is " + (int)month.mar);
Console.WriteLine("The value of apr in month " +
"enum is " + (int)month.apr);
Console.WriteLine("The value of may in month " +
"enum is " + (int)month.may);
}
}
}
The value of jan in month enum is 0 The value of feb in month enum is 1 The value of mar in month enum is 2 The value of apr in month enum is 3 The value of may in month enum is 4
- Ejemplo 2: en el siguiente código, se crea un enumerador con formas de nombre con miembros de datos de string como Circle , que se inicializa de forma predeterminada en el valor 0 y, de manera similar, se asigna el valor 1 a Square dentro de la clase Perimeter. También hay una función miembro peri() que toma un parámetro como valor para inicializar el lado/radio. Otro parámetro se usa para juzgar la forma si es un círculo o un cuadrado en forma de un valor entero (0 o 1). Ahora en el método main(), se crea un objeto de la clase Perimeter. Durante la llamada del método peri(), Perimeter.shapes.circle denota que es un círculo con valor 0 y similar es el caso de Perimeter.shapes.squarecon valor 1. Entonces, dentro del método, si el objeto s1 tiene valor 0, entonces es un círculo y, por lo tanto, se calcula su circunferencia y lo mismo ocurre con el
perímetro cuadrado.
C#
// C# program to illustrate the Enums
using System;
namespace ConsoleApplication2 {
class Perimeter {
// declaring enum
public enum shapes
{
circle,
square
}
public void peri(int val, shapes s1)
{
// checking for shape to be circle
if (s1 == 0)
{
// Output the circumference
Console.WriteLine("Circumference of the circle is " +
2 * 3.14 * val);
}
else
{
// else output the perimeter of the square
Console.WriteLine("Perimeter of the square is " +
4 * val);
}
}
}
class Program {
// Main Method
static void Main(string[] args)
{
Perimeter a1 = new Perimeter();
a1.peri(3, Perimeter.shapes.circle);
a1.peri(4, Perimeter.shapes.square);
}
}
}
Circumference of the circle is 18.84 Perimeter of the square is 16
Inicialización de enumeración: como se discutió anteriormente, el valor predeterminado del primer miembro de enumeración se establece en 0 y aumenta en 1 para los demás miembros de datos de enumeración. Sin embargo, el usuario también puede cambiar estos valores predeterminados.
- Ejemplo:
enum days {
day1 = 1,
day2 = day1 + 1,
day3 = day1 + 2
.
.
}
En el ejemplo anterior, el usuario le asigna el valor ‘1’ al día 1, el valor ‘2’ al día 2 y algo similar ocurre con el miembro del día 3. Entonces, solo tiene que cambiar el valor del primer miembro de datos de la enumeración, los miembros de datos adicionales de las enumeraciones aumentarán en 1 que el anterior automáticamente.
Nota: ahora, si el miembro de datos del miembro de enumeración no se ha inicializado, su valor se establece de acuerdo con las reglas que se indican a continuación:
- si es el primer miembro, entonces su valor se establece en 0 de lo contrario
- Establece el valor que se obtiene al sumar 1 al valor anterior del miembro de datos de enumeración
Ejemplo:
enum random {
A,
B,
C = 6;
D
}
Aquí, A se establece en 0 de forma predeterminada, B se incrementará a 1. Sin embargo, como C se inicializa con 6, el valor de D será 7
- Programa: para demostrar la inicialización del miembro de datos de enumeración con valores definidos por el usuario y también algún caso especial de inicialización.
C#
// C# program to illustrate the enum
// data member Initialisation
using System;
namespace ConsoleApplication3 {
// enum declaration
enum days {
// enum data members
monday,
tuesday,
wednesday,
thursday,
friday,
saturday,
sunday
}
// enum declaration
enum color {
// enum data members
Red,
Yellow,
Blue,
// assigning value yellow(1) + 5
Green = Yellow + 5,
Brown,
// assigning value Green(6) + 3
Black = Green + 3
}
class Program {
// Main Method
static void Main(string[] args)
{
Console.WriteLine("Demonstrating the difference "+
"between Special Initialisation" +
"cases and non-initialisation cases\n\n");
// first of all non-initialized enum
// 'days' will be displayed
// as mentioned already, the first
// member is initialized to 0
// hence the output will numbers
// from 0 1 2 3 4 5 6
Console.WriteLine("Value of Monday is " +
(int)days.monday);
Console.WriteLine("Value of Tuesday is " +
(int)days.tuesday);
Console.WriteLine("Value of Wednesday is " +
(int)days.wednesday);
Console.WriteLine("Value of Thursday is " +
(int)days.thursday);
Console.WriteLine("Value of Friday is " +
(int)days.friday);
Console.WriteLine("Value of Saturday is " +
(int)days.saturday);
Console.WriteLine("Value of Sunday is " +
(int)days.sunday);
// Now the use of special initialisation
// cases is demonstrated as expected Red
// will be assigned 0 value similarly
// yellow will be 1 and blue will be 2
// however, green will be assigned the
// value 1+5=6 similarly is the case
// with brown and black
Console.WriteLine("\n\nColor Enum");
Console.WriteLine("Value of Red Color is " +
(int)color.Red);
Console.WriteLine("Value of Yellow Color is " +
(int)color.Yellow);
Console.WriteLine("Value of Blue Color is " +
(int)color.Blue);
Console.WriteLine("Value of Green Color is " +
(int)color.Green);
Console.WriteLine("Value of Brown Color is " +
(int)color.Brown);
Console.WriteLine("Value of Black Color is " +
(int)color.Black);
}
}
}
Demonstrating the difference between Special Initialisationcases and non-initialisation cases Value of Monday is 0 Value of Tuesday is 1 Value of Wednesday is 2 Value of Thursday is 3 Value of Friday is 4 Value of Saturday is 5 Value of Sunday is 6 Color Enum Value of Red Color is 0 Value of Yellow Color is 1 Value of Blue Color is 2 Value of Green Color is 6 Value of Brown Color is 7 Value of Black Color is 9
- Explicación: en el código anterior, tenemos dos tipos de enumeraciones, es decir , color y días . En el caso de enumeración de días , no se realiza ninguna inicialización. Entonces, según las reglas , el lunes se asignará a 0 y, en incrementos de 1, se decidirán los valores de martes , miércoles y otros días. Sin embargo, en el caso de enum color , Red se le asignará 0, Yellow se le dará el valor 1 y lo mismo ocurre con Blue . Pero en el caso de Verde, su valor se decidirá sumando el valor de Amarillo con 5, lo que da como resultado el valor 6. De nuevo, en el caso de Marrón, su valor será 7 y en el caso de Negro, su valor será (7 + 3) que es 10.
Cambiar el tipo de miembro de datos de Enum: de forma predeterminada, el tipo de datos base del enumerador en C# es int . Sin embargo, el usuario puede cambiarlo según su conveniencia, como bool, long, double, etc.
- Ejemplo:
// byte type
enum button : byte {
// OFF will be assigned 0
OFF,
//ON will be assigned 1
ON
// However, if we assign 100 to ON then,
// this will give error as byte cannot hold this
}
- Programa: Para demostrar el cambio de tipo de datos de miembros de enum
C#
// C# program to illustrate the changing
// of data type of enum members
using System;
namespace ConsoleApplication4 {
// changing the type to byte using :
enum Button : byte {
// OFF denotes the Button is
// switched Off... with value 0
OFF,
// ON denotes the Button is
// switched on.. with value 1
ON
}
class Program {
// Main Method
static void Main(string[] args)
{
Console.WriteLine("Enter 0 or 1 to know the " +
"state of electric switch!");
byte i = Convert.ToByte(Console.ReadLine());
if (i == (byte)Button.OFF)
{
Console.WriteLine("The electric switch is Off");
}
else if (i == (byte)Button.ON)
{
Console.WriteLine("The electric switch is ON");
}
else
{
Console.WriteLine("byte cannot hold such" +
" large value");
}
}
}
}
- Aporte:
1
- Producción:
Enter 0 or 1 to know the state of electric switch! The electric switch is ON
Publicación traducida automáticamente
Artículo escrito por keshav_786 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA