Teoría C#: Variables

Las variables son identificadores asociados a valores. Se declaran indicando el tipo de dato que almacenará y su identificador.
Un identificador puede:

• empezar por "_".
• contener caracteres Unicode en mayúsculas y minúsculas (sensible a mayúsculas y minúsculas).

Un identificador no puede:

• empezar por un número.
• empezar por un símbolo, ni aunque sea una palabra clave.
• contener más de 511 caracteres.

Declarar una variable:

int miNumero; // Declaramos la variable, pero no la inicializamos con ningún valor.

Para asignar un valor a una variable, se indica el identificador de la misma, seguido del símbolo igual (=) y el valor que queremos que almacene:

miNumero = 5; // Asignamos el valor '5'.

También se puede declarar y asignar un valor al mismo tiempo:

int miNumero = 5; // Declaramos la variable, y asignamos el valor '5'.

Las conversiones de tipo de variables en C# se representan en la siguiente tabla en donde la fila es el origen y la columna el destino.

Leyenda
Rojo	Conversión incompatible (I).
Verde	Conversión automática o implícita (A).
Azul	Conversión explícita (E).

Conversiones de tipo de datos
	byte	sbyte	short	ushort	int	uint	long	ulong	float	double	decimal	char	bool
byte		E	A	A	A	A	A	A	E	E	E	E	I
sbyte	E		A	E	A	E	A	A	E	E	E	E	I
short	E	E		E	A	A	A	A	E	E	E	E	I
ushort	E	E	E		A	A	A	A	E	E	E	E	I
int	E	E	E	E		E	A	A	E	E	E	E	I
uint	E	E	E	E	E		A	A	E	E	E	E	I
long	E	E	E	E	E	E		E	E	E	E	E	I
ulong	E	E	E	E	E	E	E		E	E	E	E	I
float	E	E	E	E	E	E	E	E		A	E	I	I
double	E	E	E	E	E	E	E	E	E		E	I	I
decimal	E	E	E	E	E	E	E	E	E	E		I	I
char	E	E	E	A	A	A	A	A	A	A	A		I
bool	I	I	I	I	I	I	I	I	I	I	I	I

• Toda conversión implícita no ocasiona pérdida de información, truncamientos o redondeos.
• Es posible (mas no siempre ocurre) que en una conversión explícita haya pérdida de información, truncamientos o redondeos.
• En toda conversión implícita el tipo de dato destino es mayor que el tipo de dato origen.
• La conversión explícita se realiza indicando el tipo de dato al que se quiere convertir entre paréntesis, seguido del valor:

          long valor = 123; // Conversión implícita

 
          long valor = (long)123; // Conversión explícita

Además de realizarse dentro de una asignación, las conversiones de tipos también tienen lugar dentro de una expresión, pues en cada operación ambos operandos deben de ser del mismo tipo. Si la conversión es del tipo implícito se efectúa el siguiente algoritmo en dicho orden:

1. Si un operando es decimal, el otro operando se transforma a decimal.
2. Si un operando es double, el otro operando se transforma a double.
3. Si un operando es float, el otro operando se transforma a float.
4. Si un operando es ulong, el otro operando se transforma a ulong.
5. Si un operando es long, el otro operando se transforma a long.
6. Si un operando es uint, y si el otro operando es de tipo sbyte, short o int, los dos se transforman a long.
7. Si un operando es uint, el otro operando se transforma a uint.
8. Si no es ninguno de los casos anteriores, los dos operandos se transforman a int.