Análisis y Programación: enero 2022

C # divide los tipos de valor en dos categorías distintas conocidas como estructuras y enumeraciones. Las estructuras se dividen a su vez en subcategorías llamadas tipos numéricos (tipos enteros, tipos decimales de coma flotante y decimales), tipos booleanos y estructuras definidas por el usuario. Las enumeraciones se forman como un conjunto de tipos declarados usando la palabra clave enum.

Tipos de valores predefinidos

Los tipos de valor identifican valores específicos de datos. C# incluye tipos de datos intrínsecos comunes a muchos otros lenguajes de programación y se usan para almacenar valores simples. Los tipos de datos intrínsecos de C # tienen asignaciones directas a los tipos de .NET. Los nombres listados en la columna de tipos de la siguiente tabla son conocidos como alias para los tipos .NET. Todos los tipos de valores derivan de System.ValueType.

La Tabla enumera los tipos de valores básicos que admite C#, incluido el rango de los valores de datos que estos soportan.

Tipo	Valor	Tamaño	Tipo .Net
bool	true/false	1 byte	System.Boolean
byte	Signed 32-bit	1 byte	System.Byte
char	0000–FFFF Unicode	16 bit	System.Char
decimal	±1 0 × 10−28 a ±7 9 × 1028	28-20 digitos significativos	System.Decimal
double	±5 0 × 10−324 a ±1 7 × 10308	15-16 digitos	System.Double
enum	Colección de constantes definidas por el usuario
float	±1 5 × 10−45 to ±3 4 × 1038	7 digitos	System.Single
int	–2,147,483,648 a 2,147,483,647	Signed 32-bit	System.Int32
long	9,223,372,036,854,775,808 a 9,223,372,036,854,775,807	Signed 64-bit	System.Int64
sbyte	–128 a 127	Signed 8-bit	System.SByte
short	–32,768 a 32,767	Signed 16-bit	System.Int16
struct	Incluye los tipos numéricos listados en esta tabla, incluyendo el boolean y estructuras definidas por el usuario
uint	0 a 4,294,967,295	Unsigned 32-bit	System.UInt32
ulong	0 a 18,446,744,073,709,551,615	Unsigned 64-bit	System.UInt64
ushort	0 a 65,535	Unsigned 16-bit	System.Uint16

Para trabajar con los tipos de datos, declaramos una variable del tipo que deseamos. Después almacenamos en ella un valor del tipo declarado a través de una asignación. La asignación también se puede incluir como parte de la declaración. El siguiente código demuestra ambas opciones:

// declaramos una variable integer

int miEntero;

// Y le asignamos un valor

miEntero = 3;

// Declaramos y signamos en la misma instrucción

int miSegundoEntero = 50;

La palabra clave int se utiliza para indicar que la variable será de tipo entero, que es el alias para el tipo System.Int32. Como resultado, podrá contener cualquier valor desde 2,147,482,648 negativo a 2,147,482,647 positivo.

Nota: No confundir los tipos de datos de C# con nombres similares que se encuentran en los conceptos matemáticos. Por ejemplo, el tipo de datos int, que es la abreviatura de entero, no es lo mismo que el concepto de entero matemático. Los enteros en matemáticas pueden contener valores desde menos infinito hasta infinito positivo. Sin embargo, los tipos de datos en C # dependen de la cantidad de bits utilizados para contener el tipo de datos. En este caso, int tiene 32 bits ; 2 elevado a la potencia de 32 proporciona un máximo de 4,294,967,296. Quitamos 1 bit para usar para el signo, y tendremos los valores listados en la tabla anterior para int.

Hay que tener en cuenta un par de restricciones con los tipos. No podemos derivar un nuevo tipo de un tipo de valor, y los tipos de valor no pueden contener un valor nulo. Ahora, aquí es donde el uso del alias para un tipo de valor y el tipo de sistema .NET difieren. Intentando usar un alias con una variable no asignada en código, resultará que Visual Studio generará un error sobre el uso de una variable no asignada. Cada tipo de valor tiene un tipo correspondiente de .NET en el espacio de nombres del sistema, y podemos utilizar una versión de este tipo sin firmar. Esto es posible porque los tipos de sistema son clases (tipos de referencia), se crean mediante el uso del nuevo operador y contienen un valor predeterminado.

Al final de cada ejemplo pondremos la instrucción

Console.ReadLine();

Para que la pantalla se detenga y podamos leer el resultado. Saldremos de esta pantalla pulsando Enter.

Comparación de tipos de valor y sus alias [value_type_alias]

// crea una variable para mantener un tipo por valor

// utilizando el formulario de alias

// pero no asigna la variable

int miEntero;

int miNuevoEntero = new int();

// crea una variable para un tipo .NET

// Este tipo es la versión .NET alias de la forma int

// el uso de new, crea un objeto de la clase System.Int32

int miEntero32 = new System.Int32();

// tendremos que comentar esta primera declaración de //Console.WriteLine pues .Net mostrará un error sobre el uso de una variable no asignada

// Esto se hace para evitar el uso de un valor que se //almacenó en la ubicación de la memoria antes de la //creación de esta variable

Console.WriteLine(miEntero);

// Imprime el valor por defecto asignado a la variable int

// que no tenía un valor asignado previamente //Console.WriteLine(miNuevoEntero);

// Esta instrucción imprimirá el valor por defecto de este //tipo de datos, por defecto el 0

Console.WriteLine(miEntero32);

Console.ReadLine();

En el ejemplo de código anterior, la variable miEntero32 se crea como un nuevo objeto del tipo System.Int32 .NET. No se proporciona un valor en la declaración System.Int32

int miEntero32 = new System.Int32();

Como resultado, Visual Studio llama al constructor predeterminado para este objeto y le asigna el valor predeterminado. Se crea una variable llamada miNuevoEntero usando la palabra clave new. .NET Framework reconoce que esta forma de declaración de variable es la misma que al usar el estilo de variable System.Int32. Aunque la declaración de

int miEntero;

no permite generar el valor de esta variable si no se ha asignado, la declaración de

int miNuevoEntero = new int();

Permite generar la variable no asignada. Sin embargo, esta segunda versión no se usa a menudo cuando se trata de tipos simples, aunque nada impide usarla.

.NET Framework proporciona valores predeterminados para todos los tipos de valores del sistema creados de esta manera. Los valores predeterminados para todos los tipos numéricos son equivalentes a cero. Cualquiera de los tipos de coma flotante como decimal, double o float será 0.0. El valor predeterminado para boolean es false, char es '\ 0', enum es (E) 0 y las estructuras se establecen en nulo. Otro aspecto importante que debe entenderse sobre los tipos de valor es la forma en que se administran los valores. .NET Framework almacena los tipos de valor en la pila (stack) en lugar de en el montón (heap). El resultado es que si asignamos un tipo de valor a otro, se copiará el valor del primero al segundo. Los tipos por referencia copian una referencia (dirección de memoria) en oposición a los valores reales. El siguiente código de ejemplo muestra la creación de dos variables enteras. Se asigna un valor a una de las variables y luego se asigna una variable a otra.

// asignando un tipo de valor a otro

int miEntero;

int segundoEntero;

//se asigna 2 a miEntero

miEntero = 2;

// segundoEntero contendrá el valor 2

segundoEntero = miEntero;

// Mostramos el valor de las variables

Console.WriteLine(miEntero);

Console.WriteLine(segundoEntero);

Console.WriteLine();

Aunque en los ejemplos anteriores sólo se ha mostrado el tipo de datos enteros, trabajar con los otros tipos de valores simples es similar.

Usando value types [using_value_types]

// declaramos algunos tipos de dato numéricos

int miInt;

double miDouble;

byte miByte;

char miChar;

decimal miDecimal;

float miFloat;

long miLong;

short miShort;

bool miBool;

// asignamos valores a estos tipos

// los imprimimos en la consola

// utilizamos sizeOf para determinar

// el numero de bytes que ocupa cada tipo

miInt = 5000;

Console.WriteLine("Integer");

Console.WriteLine(miInt);

Console.WriteLine(miInt.GetType());

Console.WriteLine(sizeof(int));

Console.WriteLine();

miDouble = 5000.0;

Console.WriteLine("Double");

Console.WriteLine(miDouble);

Console.WriteLine(miDouble.GetType());

Console.WriteLine(sizeof(double));

Console.WriteLine();

miByte = 254; Console.WriteLine("Byte");

Console.WriteLine(miByte);

Console.WriteLine(miByte.GetType());