Variables primitivas en C# con var y tipos

Contenido del curso

Fundamentos

Tipos de Datos y Variables

Control de Flujo

Programación Orientada a Objetos

Interfaces y Arquitectura

Herramientas y Entorno de Desarrollo

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:004:57

Variables primitivas en C# con var y tipos

Curso de Introducción a .NET con C#

Clase 6 de 25

Clase 6 / 25

Recursos

Trabajar con variables es el primer paso real para programar en C#. Aquí aprenderás cómo declarar tipos de variables en C# usando palabras reservadas como var, string, int, bool y double, además de cómo concatenarlas para mostrar resultados en consola. Es una base imprescindible si estás dando tus primeros pasos en .NET.

¿Cómo se declara una variable en C# con var?

La palabra reservada var le dice al compilador que infiera el tipo a partir del valor que asignas. Es rápido, cómodo y muy usado cuando ya sabes qué dato vas a manejar.

Por ejemplo, si escribes var nombre = "Amin";, .NET entiende por defecto que estás trabajando con una cadena, aunque nunca lo hayas especificado. Lo mismo pasa si escribes var edad = 40;, porque el compilador interpreta que es un entero.

Un detalle que no puedes pasar por alto: toda sentencia en C# debe terminar con punto y coma. Es una costumbre que al inicio causa errores, pero con el tiempo se vuelve automática.

¿Qué hace la palabra reservada var en C#? Permite declarar una variable sin escribir su tipo explícito. El compilador lo deduce del valor asignado, así que var nombre = "Amin" equivale a string nombre = "Amin".

¿Cuándo conviene usar tipos explícitos como string, int, bool o double?

Usar tipos explícitos te da control visual sobre lo que estás manejando. Cuando lees el código semanas después, sabes exactamente qué espera cada variable.

Estas son las declaraciones más comunes que vas a encontrar:

string apellido = "Espinosa"; para cadenas de texto.
int edad = 40; para números enteros.
bool esProfePlatzi = true; para valores verdadero o falso.
double precio = 10.5; para números con punto decimal.

Cualquiera de estas formas es válida y produce el mismo resultado que usar var. La preferencia entre var y el tipo explícito suele ser de estilo, aunque tener las variables tipadas ayuda mucho cuando no tienes claro qué tipo de dato vas a manejar.

¿Por qué C# es un lenguaje de tipado fuerte?

C# es de tipado fuerte porque cada variable tiene un tipo definido y no puedes mezclarlos sin una conversión explícita. Si quisieras convertir un int con valor 40 a una cadena, necesitarías usar métodos de conversión para que C# no se equivoque al tratar el dato.

Esto evita errores silenciosos: el compilador te avisa antes de que tu programa se rompa en producción.

¿Cómo concatenar variables en una salida por consola?

Una vez que tienes tus datos, lo natural es mostrarlos. En lugar del clásico Console.WriteLine("Hello, world!"), puedes construir un mensaje con tus propias variables.

Un ejemplo de concatenación con el operador + se vería así: Console.WriteLine("Hola " + nombre + " " + apellido);. El resultado en consola sería Hola Amin Espinosa, porque cada variable se une dentro de una sola cadena.

¿Qué pasa si declaro una variable y no la uso en C#? El compilador muestra una advertencia indicando que la variable está asignada pero nunca utilizada. Tu app se sigue ejecutando, pero conviene eliminarla para optimizar el desempeño.

Al correr el programa con dotnet run, podrías ver advertencias por variables como edad, esProfePlatzi o precio si las declaraste pero no las usaste. Son señales del compilador para que mantengas tu código limpio.

Conceptos y datos clave de la clase

Algunos términos y datos que vale la pena reforzar para fijar el aprendizaje:

Palabra reservada var [0:25]: declara variables con tipo inferido por el compilador.
Punto y coma como cierre de sentencia [0:48]: obligatorio en cada línea de C#.
Inferencia de tipo string [1:10]: al asignar texto entre comillas, .NET asume string.
Declaración explícita con string [1:25]: útil para mantener control visual del código.
Tipo int para enteros [1:55]: como int edad = 40.
Tipo bool con valores true o false [2:15]: ejemplo, bool esProfePlatzi = true.
Tipo double para decimales [2:25]: como double precio = 10.5.
Concatenación con + [2:55]: une variables y cadenas en una sola salida.
Comando dotnet run [3:15]: ejecuta la aplicación desde la terminal.
Advertencias por variables no usadas [3:25]: el compilador sugiere eliminarlas para optimizar.
Tipado fuerte y conversión de datos [3:55]: convertir un entero a cadena requiere métodos específicos.

¿Qué tipo de variable usas más en tus primeros proyectos en C#: var o el tipo explícito? Cuéntame en los comentarios cómo te organizas para no perder claridad en tu código.

Carlos Rodrigo Ayala Alvarado

Hace un año

Comparto 10 formas de declarar variables:

// 1. Declaración explícita con inicialización
int numero = 10;               // Declara una variable entera llamada 'numero' y le asigna 10

// 2. Declaración explícita sin inicializar
string texto;                  // Declara una variable de texto llamada 'texto' sin valor inicial
texto = "¡Hola, C#!";          // Asigna el valor "¡Hola, C#!" a la variable 'texto'

// 3. Declaración implícita con 'var'
var precio = 19.99m;           // El compilador infiere que 'precio' es decimal por el sufijo 'm'

// 4. Declaración de constante
const double PI = 3.14159265359; // Define una constante de tipo double llamada 'PI' (su valor no cambia)

// 5. Declaración múltiple en una sola línea
int x = 1, y = 2, z = 3;       // Declara tres variables enteras 'x', 'y' y 'z' con valores 1, 2 y 3

// 6. Declaración de un tipo nullable
int? contador = null;          // Declara un entero que puede ser null, útil para valores opcionales

// 7. Declaración con 'dynamic'
dynamic dato = "cadena";       // 'dato' puede cambiar de tipo en tiempo de ejecución
dato = 123;                    // Ahora almacena un entero sin error de compilación

// 8. Declaración de arreglo
int[] edades = new int[5];     // Crea un arreglo de enteros de tamaño 5 (valores inicializados a 0)

// 9. Declaración y asignación con tupla
(var nombre, var apellido) = ("Ana", "García");  
                                // Crea dos variables 'nombre' y 'apellido' a partir de una tupla

// 10. Declaración de campo en una clase (nivel de clase, no dentro de un método)
public class Alumno               // Define una clase llamada 'Alumno'
{
    private bool activo;          // Campo privado 'activo' de tipo bool inicializado a false por defecto
}
```// 1. Declaración explícita con inicialización

int numero = 10;               // Declara una variable entera llamada 'numero' y le asigna 10



// 2. Declaración explícita sin inicializar

string texto;                  // Declara una variable de texto llamada 'texto' sin valor inicial

texto = "¡Hola, C#!";          // Asigna el valor "¡Hola, C#!" a la variable 'texto'



// 3. Declaración implícita con 'var'

var precio = 19.99m;           // El compilador infiere que 'precio' es decimal por el sufijo 'm'



// 4. Declaración de constante

const double PI = 3.14159265359; // Define una constante de tipo double llamada 'PI' (su valor no cambia)



// 5. Declaración múltiple en una sola línea

int x = 1, y = 2, z = 3;       // Declara tres variables enteras 'x', 'y' y 'z' con valores 1, 2 y 3



// 6. Declaración de un tipo nullable

int? contador = null;          // Declara un entero que puede ser null, útil para valores opcionales



// 7. Declaración con 'dynamic'

dynamic dato = "cadena";       // 'dato' puede cambiar de tipo en tiempo de ejecución

dato = 123;                    // Ahora almacena un entero sin error de compilación



// 8. Declaración de arreglo

int\[] edades = new int\[5];     // Crea un arreglo de enteros de tamaño 5 (valores inicializados a 0)



// 9. Declaración y asignación con tupla

(var nombre, var apellido) = ("Ana", "García"); &#x20;

&#x20;                               // Crea dos variables 'nombre' y 'apellido' a partir de una tupla



// 10. Declaración de campo en una clase (nivel de clase, no dentro de un método)

public class Alumno               // Define una clase llamada 'Alumno'

{

&#x20;   private bool activo;          // Campo privado 'activo' de tipo bool inicializado a false por defecto

}

Fundamentos

Por qué C# sigue dominando el desarrollo

C# vs .NET: no son lo mismo

Instalación de .NET 8 en Ubuntu con WSL

Crea y ejecuta tu primer proyecto .NET

Depurar .NET con F5 en VS Code

Tipos de Datos y Variables

Variables primitivas en C# con var y tipos

Const vs variable en C# cuándo usar cada una

Leer y escribir datos en consola con C#

Control de Flujo

Sentencia if y operadores lógicos en C#

for y while en C# sin errores

Ciclo foreach en C# para iterar caracteres y cadenas

Diferencia entre arreglos y listas en C#

Sentencia switch en C# con arreglos y listas

Métodos en C# con void y return

Programación Orientada a Objetos

Clases y namespaces en C# con Calculator

Métodos públicos y privados en clases de C#

Clases estáticas en C# sin instanciar objetos

Interfaces y Arquitectura

Qué son las interfaces en C#

Interfaces en C# con un proyecto Logger

Configuración de depuración en Visual Studio Code para múltiples proyectos

Herramientas y Entorno de Desarrollo

Visual Studio vs VS Code para .NET

Creación de archivos SLN en .NET con múltiples proyectos

Instalación y uso de paquetes NuGet en proyectos .NET

dotnet publish para ejecutables sin SDK

Comandos esenciales de la terminal de .NET

Variables primitivas en C# con var y tipos