CSharp Cheat sheet

Los tipos básicos en C# incluyen int, string, bool, etc. Se utilizan para almacenar y manipular datos.

• int para números enteros
• string para cadenas de texto
• bool para valores booleanos (verdadero/falso)
• float para números con punto flotante de precisión simple
• double para números con punto flotante de doble precisión
• char para caracteres individuales
• long para enteros de mayor tamaño

Mas Info

int number = 5;
string text = "Hello";
bool isActive = true;
float pi = 3.14f;
double e = 2.7182818284;
char letter = 'A';
long largeNumber = 123456789L;
            

La estructura condicional if-else permite tomar decisiones en el flujo del programa.

Mas Info

if (condition) {
    // Acción si la condición es verdadera
} else {
    // Acción si la condición es falsa
}
             

El bucle "For Loop" en C# es una estructura de control que ejecuta un bloque de código de manera repetida un número determinado de veces.

Mas Info

for(int i = 0; i < 10; i++) {
    Console.WriteLine(i);
}
            

Los bucles while y do-while se utilizan para repetir un bloque de código mientras una condición sea verdadera.

Mas Info

while(condition) {
    // Código a ejecutar mientras la condición sea verdadera

do {
    // Código a ejecutar
} while(condition);
            

El bucle 'foreach' en C# itera sobre una colección de elementos de manera secuencial.

Mas Info

foreach (var item in collection) {
    // Acción para cada elemento de la colección
}
            

Los arrays en C# son colecciones de elementos del mismo tipo, con un tamaño fijo.

Mas Info

int[] numbers = { 1, 2, 3, 4, 5 };
string[] names = { "Alice", "Bob", "Charlie" };
            

Listas y diccionarios en C# permiten almacenar colecciones de datos. Las listas ofrecen una serie de elementos ordenados, mientras que los diccionarios almacenan pares clave-valor.

Mas Info

List<int> numbers = new List<int>() { 1, 2, 3 };
Dictionary<string, string> capitals = new Dictionary<string, string>() {
    { "France", "Paris" },
    { "Japan", "Tokyo" }
};
            

Los métodos en C# son bloques de código que realizan una acción. Son útiles para reutilizar código, organizar y estructurar programas.

Mas Info

public int Multiply(int a, int b) {
    return a * b;
}
           

Las clases son plantillas para objetos en C#. Un objeto es una instancia de una clase y representa entidades con estado y comportamiento.

Mas Info

public class Car {
    public string Brand { get; set; }
    public void Drive() {
        Console.WriteLine("Driving");
    }
}

Car myCar = new Car();
myCar.Brand = "Toyota";
myCar.Drive();
             

Parse en C# se utiliza para convertir una cadena a otro tipo de dato, como de string a int. Es crucial manejar posibles excepciones en caso de conversiones inválidas.

Mas Info

string numberString = "123";
int number = int.Parse(numberString);
// number ahora es un entero con valor 123
 

TryParse es similar a Parse pero no lanza excepciones en conversiones fallidas. En su lugar, devuelve un booleano indicando si la conversión fue exitosa o no.

Mas Info

string numberString = "123";
if (int.TryParse(numberString, out int number)) {
// Uso del número convertido
} else {
// Manejo del caso en que la cadena no es un número válido
}
 

La interpolación de strings en C# es una manera cómoda y legible de componer strings, permitiendo insertar valores de variables directamente en la cadena de texto.

Mas Info

string name = "Alice";
int age = 30;
string greeting = $"Hello, my name is {name} and I am {age} years old.";
 

La palabra clave 'out' en C# se utiliza para pasar argumentos a métodos que se espera que sean modificados por el método. Es útil para devolver múltiples valores de un método.

Mas Info

public void GetValues(out int a, out int b) {
a = 5;
b = 10;
}

GetValues(out int myA, out int myB);
// myA y myB ahora tienen los valores 5 y 10, respectivamente
 

La herencia y el polimorfismo son principios de la programación orientada a objetos. Permiten crear nuevas clases basadas en otras y cambiar su comportamiento.

Mas Info

public class Vehicle {
    public virtual void Drive() {
        Console.WriteLine("Driving a vehicle");
    }
}

public class Car : Vehicle {
    public override void Drive() {
        Console.WriteLine("Driving a car");
    }
}
             

Las interfaces definen contratos que las clases pueden implementar. Proporcionan una forma de lograr la abstracción y el polimorfismo en C#.

Mas Info

public interface IDriveable {
    void Drive();
}

public class Car : IDriveable {
    public void Drive() {
        Console.WriteLine("Driving a car");
    }
}
             

Los bloques try-catch en C# se utilizan para manejar errores y excepciones en un programa, proporcionando una forma de reaccionar y manejar situaciones excepcionales.

Mas Info

try {
    // Código que puede generar excepciones
} catch (Exception ex) {
    // Manejo de la excepción
    Console.WriteLine(ex.Message);
}
             

LINQ (Language Integrated Query) en C# proporciona un método coherente para consultar datos de diferentes fuentes (como colecciones, bases de datos, archivos XML) utilizando una sintaxis consistente.

Mas Info

var numbers = new List() { 1, 2, 3, 4, 5 };
var evenNumbers = numbers.Where(n => n % 2 == 0);
             

Async y Await son palabras clave en C# que facilitan la escritura de código asíncrono, permitiendo que las operaciones que consumen mucho tiempo se ejecuten sin bloquear el hilo principal de la aplicación.

Mas Info

public async Task GetNumberAsync() {
    await Task.Delay(1000);
    return 5;
}
             

'Parallel.For' en C# permite la ejecución paralela de un bucle for, aprovechando múltiples núcleos del procesador.

Mas Info

Parallel.For(0, 10, i => {
    // Código a ejecutar en paralelo para cada iteración
});
             

'Parallel.Foreach' en C# permite la ejecución paralela de un bucle foreach, procesando simultáneamente múltiples elementos de la colección.

Mas Info

Parallel.ForEach(collection, item => {
    // Código a ejecutar en paralelo para cada elemento
});
             

Los genéricos en C# permiten escribir clases y métodos con un marcador de posición para el tipo, lo que los hace reutilizables y seguros en cuanto a tipos.

Mas Info

public class GenericList<T> {
void Add(T input) { }
}

var list = new GenericList<int>();
list.Add(1);
 

La reflexión en C# es una técnica que permite inspeccionar y manipular objetos en tiempo de ejecución, como obtener información sobre tipos, crear instancias de clases y llamar a métodos dinámicamente.

Mas Info

Type typeInfo = typeof(MyClass);
MethodInfo methodInfo = typeInfo.GetMethod("MyMethod");
object myClassInstance = Activator.CreateInstance(typeInfo);
methodInfo.Invoke(myClassInstance, null);
 

Los delegados son tipos que representan métodos y los eventos son un mecanismo para la comunicación entre objetos en C#. Los eventos se basan en delegados para proporcionar notificaciones a los suscriptores.

Mas Info

public delegate void MyDelegate(string message);
public event MyDelegate MyEvent;

public void OnMyEvent(string message) {
    MyEvent?.Invoke(message);
}
             

La palabra clave 'throw' en C# se utiliza para lanzar una excepción manualmente, permitiendo que se maneje más arriba en la pila de llamadas o muestre un mensaje de error adecuado.

Mas Info

if (someCondition) {
    throw new InvalidOperationException("Algo salió mal");
}
             

El manejo de StatusCode en solicitudes web es crucial para determinar cómo se debe proceder con la respuesta, especialmente al lidiar con solicitudes HTTP en aplicaciones web.

Mas Info

HttpResponseMessage response = await httpClient.GetAsync(url);
if (response.IsSuccessStatusCode) {
    // Procesar respuesta
} else {
    // Manejar errores o estados de respuesta no exitosos
}
             

'Task' en C# representa una operación asincrónica. Es fundamental en la programación asíncrona para realizar tareas sin bloquear el hilo principal.

Mas Info

public async Task<int> CalculateValueAsync() {
    await Task.Delay(1000); // Simula un trabajo asincrónico
    return 42;
}
             

Los Threads en C# permiten que una aplicación realice múltiples tareas a la vez en procesos separados.

Mas Info

Thread myThread = new Thread(new ThreadStart(WorkMethod));
myThread.Start();

void WorkMethod() {
    // Código a ejecutar en el hilo
}
             

Las expresiones lambda son funciones anónimas que proporcionan una sintaxis concisa para trabajar con colecciones, eventos y otros tipos de datos.

Mas Info

List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
var filtered = numbers.FindAll(x => x > 2);
             

Los métodos de extensión permiten añadir nuevos métodos a tipos existentes sin modificar su código fuente.

Mas Info

public static class StringExtensions {
    public static int WordCount(this string str) {
        return str.Split(new char[] { ' ', '.', '?' }, 
                         StringSplitOptions.RemoveEmptyEntries).Length;
    }
}

string text = "Hola mundo";
int count = text.WordCount();
             

Los tipos nullables y el operador ?. en C# permiten trabajar con valores que pueden ser nulos, proporcionando una forma de acceder a miembros y métodos de manera segura.

Mas Info

int? nullableInt = null;
int result = nullableInt?.GetValueOrDefault() ?? -1;
             

Pattern Matching en C# es una forma de verificar el tipo de un objeto y enlazar variables a sus propiedades en una única declaración expresiva.

Mas Info

object obj = "Hello World";
if (obj is string s) {
    Console.WriteLine($"String of length {s.Length}");
}
             

Los 'records' en C# son tipos de referencia inmutables que proporcionan una manera simplificada de crear objetos de datos con igualdad de valor semántica.

Mas Info

public record User(string Name, int Age);

User user1 = new User("Alice", 30);
User user2 = new User("Alice", 30);
bool areEqual = user1 == user2; // true
             

Las tuplas en C# permiten agrupar múltiples elementos de datos en una sola estructura compuesta.

Mas Info

var person = (Name: "Alice", Age: 30);
Console.WriteLine($"Name: {person.Name}, Age: {person.Age}");
             

Los Async Streams y IAsyncEnumerable en C# permiten representar secuencias de datos que se obtienen de manera asíncrona, ideal para trabajar con flujos de datos en tiempo real.

Mas Info

public async IAsyncEnumerable<int> GetNumbersAsync() {
    for (int i = 0; i < 10; i++) {
        await Task.Delay(100);
        yield return i;
    }
}
             

Los atributos y anotaciones de datos en C# se utilizan para agregar información adicional a los elementos del código, como clases y propiedades, a menudo utilizados en la serialización de datos y en frameworks ORM.

Mas Info

[Serializable]
public class MyClass {
    [Required]
    public string Name { get; set; }
}
             

La inyección de dependencias en C# es una técnica de diseño de software que permite a una clase recibir las instancias de objetos que necesita desde una fuente externa en lugar de crearlos internamente.

Mas Info

public class Service {
    private readonly IRepository _repository;

    public Service(IRepository repository) {
        _repository = repository;
    }

    // Uso del objeto _repository
}
             

Entity Framework es un ORM (Object-Relational Mapper) en C# que permite trabajar con bases de datos de manera abstracta, utilizando objetos y clases en lugar de consultas SQL directas.

Mas Info

using (var context = new MyDbContext()) {
    var users = context.Users.ToList();
    // Trabajar con la lista de usuarios
}
             

La programación orientada a aspectos en C# es un paradigma que busca separar las preocupaciones transversales (como logging, seguridad) del código principal, mejorando la modularidad.

Mas Info

// Ejemplo hipotético utilizando un atributo de aspecto
[LoggingAspect]
public void MyMethod() {
    // Lógica del método
}