Tipos de datos fundamentales ()

Booleanos

Las variables booleanas pueden albergar dos valores: true (verdadero) o false (falso).

Declarando una variable del tipo booleana:
bool a;


Caracteres

Para almacenar un caracter en una variable debemos escpecificar su tipo en char. Ejemplo:

char a;

Este tipo de datos puede albergar un carácter del tipo Unicode, pensado especialmente para alfabetos orientales que poseen una cantidad mayor a 256. Existen ciertos tipos de caracteres "especiales" que son interpretados por el compilador dentro de la cadena de texto. Éstos son conocidos como caracteres de escape, y en la siguiente table pueden apreciarse algunos de ellos:

Tabla Carateres de Escape

Nombre Secuencia de Escape

linea nueva \n
tab horizontal \t
backspace \b
retorno de carro \r
barra invertida \\
comilla doble \"

Si escribimos en pantalla el siguiente texto:

Console.Write("\tTexto1\nTexto2");

El primer carácter (\t) será interpretado como un tab horizontal, y el carácter \n como una linea nueva, por lo que en pantalla podremos observar:

Texto1

Texto2

Lista de tipos de datos primitivos

Se listan a continuación los tipos de datos fundamentales del lenguaje C#:

Tipo de dato fundamental Tamaño en bytes Tipo estructura Descripción

bool 1 System.Booleano Booleano. Su valor puede
true(verdadero) o falso (false)
sbyte 1 System.Sbyte Byte no signado

byte 1 System.Byte Byte

char 2 System.Char Carácter

short 2 System.Int16 Entero corto

ushort 2 System.UInt16 Entero corto no signado

int 4 System.Int32 Entero

uint 4 System.UInt32 Entero no signado

long 8 System.Int64 Entero largo

ulong 8 System.UInt64 Entero largo no signado

float 4 System.Single Número no entero de
precisión simple
double 8 System.Double Número no entero de
precisión simple
decimal 16 System.Decimal Número no entero de
máxima precisión

Como se puede observar en la tabla anterior, todo tipo de dato primitivo que define el lenguaje se mapea con una estructura de la librería BCL. Todos los lenguajes que se construyen para la plataforma .NET deberán hacer esta tarea, y de este modo la intercomunicación entre ellos será mucho más sencilla debido a que, en definitiva, utilizan los mismos tipos de datos fundamentales.

Así es que declarar una variable entera como:

int a;

es exactamente igual a hacerlo del siguiente modo:

System.Int32 a;

Notemos que el nombre de la estructura relacionada está compuesto por dos partes: el tipo de dato (con la primera letra en mayúscula) y la cantidad de bits que ocupa en la memoria. De este modo también podemos inferir que un int siempre ocupará 4 bytes, más allá de la plataforma en la cual estemos trabajando (algo que no sucede en C o C++, donde la especificación no ata los tipos de datos a tamaños físicos, sino que simplemente exige una relación entre éstos).


Asignar valor a una variable

Para la asignación de valor para variables se utilizará el símbolo = como operador de asignación.

int a = 1;


/////¿Dónde están los Strings?/////

C# utiliza una clase que representa los strings y se llama string (o System.String). Esta implementación es algo distinta del resto de los tipos de datos, ya que éstos son básicamente estructuras. La razón es que los strings, la cantidad de memoria que se requerirá para la cadena será variable, dependiendo de su contenido. Declarando un string: string miVariableString

////////////////////////////////

Constantes

Existen tres constantes:

Literales: especificadas por medio de un valor escrito en el código.

int a = 25;
string nombre = "Tito";

En el caso citado, 25 es una constante literal al igual que Tito.

Simbólicas: especificadas por medio de identificadores asociados a un literal. Son más recomendables que el uso de literales de modo directo, ya que en ciertos contextos éstos podrían ser vistos como números mágicos sacados de un sombrero de mago.

Estas constantes son muy similares a las variables, con la diferencia de que éstas sólo se les podrá dar un valor en el momento de su declaración. Luego, cualquier intento de modificación será tomado como un error por parte del compilador. Las constantes simbólicas se declaran del mismo modo que las variables, aunque se les debe anteponer la palabra const.

const int unaConstante = 1;

Enumeradores: los enumeradores también son considerados como un tipo de constantes, y adquieren una gran utilidad cuando debemos especificar un grupo de constantes estrechamente relacionadas.
Supongamos que deseamos que una variable pueda adoptar el valor de un mes específico del año. Podríamos definir que esta variable fuese numérica entera y adoptar la convención de que su número equivaliera al número del mes en cuestión. Sin embargo, esta "convención" debería estar especificada en algún documento que se encuentre al alcance de todos los programadores; incluso nosotros, tiempo después de haber escrito el código, podríamos dudar acerca de si el mes de enero era representado por el 1 o acaso por el 0.

Para evitar este tipo de inconvenientes y, también, que algún descuidado especifique un número fuera de rango para el mes (por ejemplo 13), sin tener que estar colocando que el código realice esta verificación, podríamos crear el siguiente enumerador:

enum{
Enero,
Febrero,
Marzo,
Abril,
Mayo,
Junio,
Julio,
Agosto,
Septiembre,
Octubre,
Noviembre,
Diciembre
}


Luego, podríamos declarar una variable como del tipo Mes. Veamos:

Mes m;

Ahora, m sólo podrá adoptar los valores constantes especificados en el enumerador Mes.

m = Mes.Enero;


Estas constantes podrían poseer un valor literal asignado a ellas por medio del operador de asignación:

enum{
Enero = 1,
Febrero = 2,
Marzo = 3,
Abril = 4,
Mayo = 5,
Junio = 6,
Julio = 7,
Agosto = 8,
Septiembre = 9,
Octubre = 10,
Noviembre = 11,
Diciembre = 12
}

En realidad, cada constante dentro de un enumerador siempre posee un valor literal numérico asociado a ella, sólo que si no lo especificamos, lo hará automáticamente el compilador, empezando por el número 0 e incrementando en una unidad. De hecho, podríamos consultar por el valor numérico asociado a una variable de tipo enumerador por medio de conversiones de tipo.

////Más acerca de enumeradores///
Dos constantes definidas dentro de un enumerador podrían poseer el mismo valor numérico. Esto sería útil para definir constantes que sean sinónimos; por ejemplo, tanto "setiembre" como "septiembre" podrían estar relacionados con el valor 9.
////////////////////////////////


U.1.45