Variables primitivas en C# con var y tipos

Cursos Empresas Blog Live Conf Precios

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

Variables primitivas en C# con var y tipos

Resumen

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.

Comentarios6

Carlos Rodrigo Ayala Alvarado

Estudiante

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

}

William Schnaider Torres Bermon

Estudiante

🧠 ¿Qué es una variable?

Una variable es un espacio en la memoria que usas para guardar un valor (como un número, texto o fecha) que puede cambiar mientras el programa se ejecuta.

En C#, primero debes indicar el tipo de dato que va a guardar la variable, y luego le das un nombre.

🔢 Tipos de Datos Primitivos en C#

Estos son los tipos más básicos, usados para guardar información sencilla:

Ivan Gonzalez Gonzalez

Estudiante

// Declaración de variables usando distintos tipos de datos

var nombre = "Alberto"; // Variable de tipo string, inferida automáticamente

string apellido = "González"; // Variable de tipo string explícita

int edad = 30; // Variable de tipo entero

bool isProfePlatzi = true; // Variable booleana indicando si es profesor en Platzi

double precio1 = 14.5; // Primer precio, tipo double

double precio2 = 10.5; // Segundo precio, tipo double

// Creación de un mensaje usando interpolación de cadenas

string mensaje = $"Hello, {nombre} {apellido}. Tienes {edad} años. " +

$"¿Es profe en Platzi? {isProfePlatzi}. " +

$"El precio es: {precio1} y {precio2}.";

// Mostrar el mensaje en la consola

Console.WriteLine(mensaje);

Ronaldo Jiménez

Estudiante

Recomiendo esta estructura:

vars.cs contiene:

namespace curso_dotnet.fundamentals;

public static class Variables
{
    public static void Run()
    {
        string name = "Ronaldo";
        bool isDeveloper = true;
        int age = 21;
        double height = 1.84;

        Console.WriteLine("Hola, " + name + "!");
        Console.WriteLine($"Hola, {name}!");
        Console.WriteLine($"Hola, {name}! Tienes {age} años y mides {height} metros. Eres desarrollador: {isDeveloper}.");
    }
}

Ronaldo Jiménez

Estudiante

string name = "Ronaldo";
Console.WriteLine("Hola, " + name + "!");
Console.WriteLine($"Hola, {name}!");

Edward Rodríguez

Estudiante

Por si se les hace muy engorroso concatenar la cadena de texto, la forma de interpolar en C# es:

string name = "Edward";

Console.WriteLine($"Hola, mi nombre es {name}");

// 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

}

namespace curso_dotnet.fundamentals;

public static class Variables
{
    public static void Run()
    {
        string name = "Ronaldo";
        bool isDeveloper = true;
        int age = 21;
        double height = 1.84;

        Console.WriteLine("Hola, " + name + "!");
        Console.WriteLine($"Hola, {name}!");
        Console.WriteLine($"Hola, {name}! Tienes {age} años y mides {height} metros. Eres desarrollador: {isDeveloper}.");
    }
}

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