Variables y Tipos de Datos

## Objetivos de Aprendizaje - Declarar e inicializar variables - Comprender tipos de valor y tipos de referencia - Trabajar con tipos anulables - Dominar la conversión de tipos ## Variables ### Declaración ```csharp int age; // Declaración age = 25; // Asignación int score = 100; // Declaración + Inicialización ``` ### Reglas de Nomenclatura - Comenzar con letra o guión bajo - Puede contener números (después del primer carácter) - No usar palabras reservadas - Sensible a mayúsculas/minúsculas - No puede tener espacios en blanco ```csharp int age; // Válido int _count; // Válido int totalScore; // Válido int 2ndPlace; // Inválido - comienza con número int class; // Inválido - palabra reservada ``` ## Tipos de Valor ### Tipos Enteros | Tipo | Tamaño | Rango | |------|--------|-------| | sbyte | 1 byte | -128 a 127 | | short | 2 bytes | -32,768 a 32,767 | | int | 4 bytes | -2.1B a 2.1B | | long | 8 bytes | Muy grande | | byte | 1 byte | 0 a 255 | | ushort | 2 bytes | 0 a 65,535 | | uint | 4 bytes | 0 a 4.2B | | ulong | 8 bytes | 0 a 18.4 quintillones | ```csharp byte b = 100; short s = 32000; int i = 2000000; long l = 9000000000L; // Nota el sufijo L ulong ul = 9000000000UL; // Long sin signo ``` ### Tipos de Punto Flotante | Tipo | Tamaño | Precisión | |------|--------|-----------| | float | 4 bytes | ~6-7 dígitos | | double | 8 bytes | ~15-16 dígitos | | decimal | 16 bytes | 28-29 dígitos | ```csharp float pi = 3.14f; // Nota el sufijo f double precise = 3.14159265359; decimal money = 19.99m; // Nota el sufijo m (para moneda) ``` ### Tipo Carácter ```csharp char grade = 'A'; char symbol = '\u0041'; // Unicode char newline = '\n'; ``` ### Tipo Booleano ```csharp bool isActive = true; bool hasPermission = false; ``` ## Tipos de Referencia ### Cadenas de Texto ```csharp string name = "Alice"; string greeting = new string("Hello"); string empty = string.Empty; string nullStr = null; ``` ### Arreglos ```csharp int[] numbers = { 1, 2, 3, 4, 5 }; string[] names = new string[3]; ``` ### Clases ```csharp string name = "Alice"; // String es una clase object obj = new object(); ``` ## Tipos Anulables ### Los Tipos de Valor Pueden Ser Nulos ```csharp int? nullableInt = null; double? nullableDouble = 3.14; if (nullableInt.HasValue) { Console.WriteLine(nullableInt.Value); } // O usar coalescencia nula int value = nullableInt ?? 0; ``` ### Los Tipos de Referencia Son Anulables por Defecto ```csharp string name = null; // Válido para tipos de referencia ``` ## La Palabra Clave var ### Tipado Implícito ```csharp var name = "Alice"; // El compilador infiere string var age = 25; // El compilador infiere int var list = new List(); // Tipo largo inferido // No se puede cambiar el tipo después de la inferencia var x = 10; // x = "hello"; // Error - x es int ``` ### Cuándo Usar var ```csharp // Buen uso - claro por el lado derecho var person = new Person("Alice", 25); var dictionary = new Dictionary(); var numbers = new[] { 1, 2, 3 }; // Mal uso - tipo unclear var obj = GetSomeObject(); // ¿De qué tipo es esto? ``` ## Conversión de Tipos ### Implícita (Ampliación) ```csharp int i = 100; long l = i; // int a long (automático) double d = i; // int a double (automático) ``` ### Explícita (Reducción) ```csharp double d = 3.99; int i = (int)d; // Trunca a 3 // Con verificación de desbordamiento int big = 300; checked { byte b = (byte)big; // OverflowException } ``` ### Cadena a Número ```csharp string s = "123"; int i = int.Parse(s); double d = double.Parse(s); // Con manejo de errores try { int result = int.Parse("abc"); } catch (FormatException) { Console.WriteLine("Número inválido"); } // TryParse - enfoque más seguro if (int.TryParse(s, out int result)) { Console.WriteLine("Parsed: " + result); } else { Console.WriteLine("No se pudo analizar"); } ``` ### Número a Cadena ```csharp int i = 42; string s = i.ToString(); string s2 = Convert.ToString(i); string s3 = "" + i; // Concatenación ``` ### Clase Convert ```csharp int i = 42; double d = Convert.ToDouble(i); string s = Convert.ToString(i); bool b = Convert.ToBoolean(1); // true ``` ## Constantes ### const vs readonly ```csharp const double PI = 3.14159; const int MAX_SIZE = 100; // const debe inicializarse en tiempo de compilación // PI = 3.14; // ¡Error! // readonly - puede establecerse en tiempo de ejecución class Person { readonly int _createdAt; public Person() { _createdAt = DateTime.Now.Year; } } ``` ## Alcance de Variables ```csharp public class Scope { int global = 10; // Variable de instancia public void Method() { int local = 20; // Variable local for (int i = 0; i < 5; i++) // Variable de bloque { // i solo existe en este bucle } } } ``` ## Tipo de Valor vs Tipo de Referencia ```csharp // Tipo de valor - copia del valor int a = 10; int b = a; b = 20; // a sigue siendo 10 // Tipo de referencia - copia de la referencia int[] arr1 = { 1, 2, 3 }; int[] arr2 = arr1; arr2[0] = 99; // arr1[0] también es 99 (mismo arreglo) ``` ## Valores por Defecto ```csharp int i = default; // 0 bool b = default; // false string s = default; // null int[] arr = default; // null // Valores por defecto explícitos int zero = default(int); bool flag = default(bool); ``` ## Resumen - Las variables almacenan valores de datos - Tipos de valor: int, long, float, double, decimal, bool, char - Tipos de referencia: string, arreglos, objetos - Usa `const` para constantes en tiempo de compilación - Usa `readonly` para constantes en tiempo de ejecución - `var` infiere el tipo del lado derecho - La conversión implícita es automática; la explícita requiere casteo - `int.TryParse()` es más seguro que `int.Parse()`