Variables C#
Published: 2022-08-14 13:37:46

> **Notas:** 
>
> - Nombres de variable = identificadores

---


## **Reglas para variables:**

* Los identificadores deben empezar por su nombre, con una letra o un guion bajo.

```
MAL -> $$variable
BIEN -> _variable
BIEN -> variable
```

* Los identificadores pueden contener números pero no pueden empezar con ellos

```
MAL -> 123alumno
BIEN -> alumno123
```
* Los identificadores no pueden llevar acentos

```
MAL -> varíable
MAL -> pruebä
BIEN -> prueba
BIEN -> variable
```
* Los identificadores no pueden llevar signos a excepción del guion bajo

```
MAL -> var-iable
MAL -> variable/
MAL -> variable)
BIEN -> prueba_final
BIEN -> _pruebaFinal
BIEN -> pruebaFinal_
```
* Los identificadores no pueden llevar espacios

```
MAL -> prueba final
BIEN -> pruebaFinal
```

## **Documentación:**


<img width="100%" style="width:100%" src="https://media.giphy.com/media/bGgsc5mWoryfgKBx1u/giphy.gif">

C# diferencia las mayúsculas de las minúsculas en los identificadores.

Son identificadores diferentes:

```
alumno
Alumno
ALUMNO
```
En C# se utiliza la notación camelCase. Esto quiere decir que la primera letra del identificador es minúscula pero la primera letra de una posible segunda palabra en el identificador debe ir en mayúscula.

Supongamos que tenemos un identificador para la suma de dos números.

```
MAL -> Sumadosnumeros
MAL -> SUMADOSNUMEROS
MAL -> sumadosnumeros
BIEN -> sumaDosNumeros
```
Como se puede observar en el identificador "sumaDosNumeros"

- Empieza por minúscula
- Cada nueva palabra en este caso "dos" y "numeros" empiezan por mayúscula

Otros ejemplos de camelCase:

```
institutoBarcelona
ofertaMayo
llavesObtenidas
UnaDeLasFrasesMasBonitasDelMundo25
```
## **Tipos de variables (Básicas):**
<img width="100%" style="width:100%" src="https://media.giphy.com/media/QuIxFwQo0RMT1tASlV/giphy.gif">


>Fuente: 
><a href="https://docs.microsoft.com/es-es/dotnet/csharp/language-reference/builtin-types/value-types"> Microsoft </a>

De momento vamos a excluir los "nint" y los "nuint"

### **Tipos numéricos enteros:**

> Notas: 
> - En el editor .NET Fiddle solo hago mención de los tipos sbyte, > short, int, long
> - En las próximas partes "incorrectas" he tenido que comentar el código con `//`. El compilador no puede ejecutarse con errores. Si queréis ver los errores eliminar `//`. Adjunto foto para ver un ejemplo de código de error.

![Error variable tipo incorrecto](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/9kyb6yet1a0mk7v2v9vc.JPG)


#### **Con signo (-):**

**sbyte**	
```
De -128 a 127
```
**short**	
```
De -32 768 a 32 767
```
**int**	
```
De -2.147.483.648 a 2.147.483.647
```
**long**	
```
De -9.223.372.036.854.775.808 a 9.223.372.036.854.775.807
```
#### **Sin signo (-):**
**byte**
```
De 0 a 255
```
**ushort**
```
De 0 a 65.535
```
**uint**	
```
De 0 a 4.294.967.295
```
**ulong**	
```
De 0 a 18.446.744.073.709.551.615
```

```
using System;
					
public class Program
{
	public static void Main()
	{
		// Los warnings de color amarillo quieren decir que la variable no se esta utilizando.
		
		//sbyte - correcto
			sbyte sbyteCorrectoNumero = 25;
			sbyte sbyteCorrectoNumero1 = 100; 
			sbyte sbyteCorrectoNumero2 = -120;
			
		//sbyte - incorrecto
			//sbyte sbyteIncorrectoNumero = 129
			//sbyte sbyteIncorrectoNumero1 = 500 
			//sbyte sbyteIncorrectoNumero2 = -129
			
		//short - correcto
			short shortCorrectoNumero = -32500;
			short shortCorrectoNumero1 = 500;
			short shortCorrectoNumero2 = 32750;
			
		//short - incorrecto
			//short shortIncorrectoNumero = -33000;
			//short shortIncorrectoNumero = 33000;
			
		//int - correcto
			int intCorrectoNumero = -2147483647; //-2.147.483.647
			int intCorrectoNumero2 = 500;
			int intCorrectoNumero3 = 500000; //500.000
				
		//int - incorrecto
			//int intIncorrectoNumero = -3147483648; //-3.147.483.648
			//int intIncorrectoNumero1 = -3147483648; //3.147.483.648
		
		//Trabajar a partir de estos números para una primera pasada esta bien, pero para tocar en futuros proyectos de momento no hace falta. Ya que son números extremadamente grandes, los pongo por poner ejemplos
		
		//long - correcto
			long longCorrectoNumero = -9223372036854775808; //-9.223.372.036.854.775.808
			long longCorrectoNumero1 = 9223372036854775807; //9.223.372.036.854.775.807
			
		//long - incorrecto
			//long longIncorrectoNumero = -10223372036854775808; //-10.223.372.036.854.775.808
			//long longIncorrectoNumero1 = -10223372036854775808; //10.223.372.036.854.775.808
		
		
		Console.WriteLine(sbyteCorrectoNumero);
		Console.WriteLine(shortCorrectoNumero);
		Console.WriteLine(intCorrectoNumero);
		Console.WriteLine(longCorrectoNumero);
	}
}
```
Por si quereis hacer pruebas :)

{% embed https://dotnetfiddle.net/jmODqn %}

<img width="50%" style="width:50%" src="https://media.giphy.com/media/edFF9tEQEjVAMkDO3W/giphy.gif">