Hoja de Trucos de C#
Última actualización
Hola Mundo y estructura del programa
Las sentencias de nivel superior (desde .NET 6) te permiten omitir la clase repetitiva.
| Elemento | Código |
|---|---|
| Programa de nivel superior | Console.WriteLine("Hello, World!"); |
| Importar un espacio de nombres | using System; |
| Punto de entrada clásico | static void Main(string[] args) { ... } |
| Imprimir una línea | Console.WriteLine("text"); |
| Leer una línea | string s = Console.ReadLine(); |
| Interpolación de cadenas | Console.WriteLine($"Hi {name}"); |
| Comentarios | // line y /* block */ |
Tipos de datos
| Tipo | Descripción |
|---|---|
int | Entero con signo de 32 bits |
long | Entero con signo de 64 bits |
double / float | Números de punto flotante |
decimal | Decimal de alta precisión (dinero) |
bool | true o false |
char | Un solo carácter Unicode |
string | Texto inmutable |
var | El compilador infiere el tipo |
int? | Tipo de valor anulable |
Variables
| Operación | Sintaxis |
|---|---|
| Declarar e inicializar | int x = 5; |
| Inferencia de tipo | var name = "Ada"; |
| Constante | const double Pi = 3.14159; |
| Campo de solo lectura | readonly int id; |
| Referencia anulable | string? maybe = null; |
| Fusión de nulos | var y = maybe ?? "default"; |
| Condicional de nulo | int? len = text?.Length; |
Control de flujo
| Sentencia | Sintaxis |
|---|---|
| If / else | if (x > 0) { ... } else { ... } |
| Sentencia switch | switch (n) { case 1: ...; break; default: ...; } |
| Expresión switch | var s = n switch { 1 => "one", _ => "other" }; |
| Bucle while | while (i < n) { ... } |
| Bucle do-while | do { ... } while (i < n); |
| Bucle for | for (int i = 0; i < n; i++) { ... } |
| Bucle foreach | foreach (var item in list) { ... } |
| Break / continue | break; sale de un bucle, continue; salta a la siguiente iteración |
Métodos
| Operación | Sintaxis |
|---|---|
| Definir un método | int Add(int a, int b) { return a + b; } |
| Cuerpo de expresión | int Add(int a, int b) => a + b; |
| Sin valor de retorno | void Greet() { ... } |
| Parámetro opcional | int Pow(int b, int e = 2) { ... } |
| Argumentos con nombre | Pow(b: 2, e: 3); |
| Parámetro out | bool TryParse(string s, out int n) { ... } |
| Método estático | static int Square(int x) => x * x; |
| Expresión lambda | Func<int, int> f = x => x * 2; |
Clases y POO
| Operación | Sintaxis |
|---|---|
| Definir una clase | class Dog { ... } |
| Propiedad automática | public string Name { get; set; } |
| Propiedad de solo lectura | public int Id { get; } |
| Constructor | public Dog(string name) { Name = name; } |
| Crear un objeto | var d = new Dog("Rex"); |
| Herencia | class Puppy : Dog { ... } |
| Interfaz | interface IRunnable { void Run(); } |
| Sobrescribir un método | public override void Speak() { ... } |
| Record (inmutable) | record Point(int X, int Y); |
Colecciones
Colecciones genéricas de System.Collections.Generic.
| Tipo | Uso y ejemplo |
|---|---|
List<T> | Array dinámico: list.Add(1); list.Count; |
Dictionary<K, V> | Clave-valor: dict["a"] = 1; dict.ContainsKey("a"); |
HashSet<T> | Valores únicos: set.Add(5); set.Contains(5); |
Queue<T> | FIFO: q.Enqueue(x); q.Dequeue(); |
Stack<T> | LIFO: s.Push(x); s.Pop(); |
| Array | int[] nums = { 1, 2, 3 }; |
| Inicializador de colección | var l = new List<int> { 1, 2, 3 }; |
| Iterar un diccionario | foreach (var kv in dict) { kv.Key; kv.Value; } |
LINQ
Consulta colecciones de forma fluida; de System.Linq.
| Operación | Sintaxis |
|---|---|
| Filtrar | nums.Where(n => n > 0) |
| Proyectar / mapear | nums.Select(n => n * 2) |
| Ordenar | nums.OrderBy(n => n) / OrderByDescending(...) |
| Primera coincidencia | nums.First(n => n > 5) / FirstOrDefault(...) |
| Alguno / todos | nums.Any(n => n < 0) / nums.All(n => n > 0) |
| Contar coincidencias | nums.Count(n => n > 0) |
| Agregar | nums.Sum(), nums.Max(), nums.Average() |
| Agrupar por | items.GroupBy(i => i.Category) |
| Materializar | .ToList() / .ToArray() |
Patrones comunes (propiedades, async)
| Patrón | Sintaxis |
|---|---|
| Método async | async Task<int> GetAsync() { ... } |
| Esperar una tarea | var result = await GetAsync(); |
| Try / catch | try { ... } catch (Exception e) { ... } |
| Finally | finally { ... } siempre se ejecuta |
| Using (liberar) | using var file = File.OpenRead(path); |
| Formato de cadenas | $"Total: {amount:C}" |
| Clase genérica | class Box<T> { public T Value; } |
| Coincidencia de patrones | if (obj is Dog d) { d.Bark(); } |
La sintaxis, las colecciones y las consultas LINQ de C# que más usas, en una sola página. Esta hoja de trucos de C# es una referencia rápida para escribir C#: los tipos de datos, el control de flujo, las clases, las colecciones List/Dictionary, LINQ y los patrones de propiedades y async que definen el código idiomático de .NET.
Todo lo que hay aquí es C# estándar sobre .NET y se ejecuta con la CLI de dotnet. Copia lo que necesites o prueba cualquier fragmento en vivo en el playground de C#, sin instalar ningún SDK.
Preguntas frecuentes sobre la hoja de trucos de C#
¿Esta hoja de trucos de C# es gratis?
Sí. Esta hoja de trucos de C# es completamente gratuita, sin necesidad de registrarse. Guárdala en favoritos y vuelve cuando necesites consultar la sintaxis, una colección o un método de LINQ.
¿Cuál es la diferencia entre tipos de valor y tipos de referencia en C#?
Los tipos de valor (
int, double, bool, struct, enum) contienen sus datos directamente y se copian cuando se asignan o se pasan a un método: cambiar la copia no afecta al original. Los tipos de referencia (class, string, arrays, List<T>) contienen una referencia a datos en el heap, así que dos variables pueden apuntar al mismo objeto y un cambio a través de una es visible a través de la otra. string es un tipo de referencia pero se comporta de forma inmutable.¿Qué es LINQ y cuándo debería usarlo?
LINQ (Language Integrated Query) es un conjunto de métodos como
Where, Select y OrderBy que te permiten filtrar, transformar y agregar colecciones con llamadas legibles y encadenables en lugar de bucles manuales. Úsalo siempre que de otro modo escribirías un bucle para construir una lista filtrada o proyectada: es conciso y se evalúa de forma perezosa hasta que llamas a ToList() o iteras.¿Puedo practicar C# en línea?
Sí. Abre el playground de C# para ejecutar cualquier fragmento de esta hoja de trucos en tu navegador, sin instalar ningún SDK. Cuando quieras estructura, el curso interactivo y gratuito de C# de Coddy te lleva paso a paso desde las variables y los bucles hasta las clases, las colecciones y LINQ.
¿Esta hoja de trucos es buena para principiantes?
Sí. Está organizada desde los componentes básicos más comunes (tipos, control de flujo, métodos) hasta los avanzados (LINQ, async, genéricos), de modo que puedes usar las secciones de arriba desde el primer día e ir avanzando hacia el resto.
Recursos relacionados
Más hojas de referencia
