Formación corporativa en C#

Sintaxis de C#

La sintaxis de C# define las reglas y estructuras fundamentales que permiten escribir código válido y comprensible. Como lenguaje de programación moderno, C# combina la potencia de la programación orientada a objetos con una sintaxis clara y expresiva que facilita tanto el aprendizaje como el desarrollo profesional.

Estructura básica de un programa

Todo programa en C# se organiza alrededor de clases y espacios de nombres. La estructura mínima incluye una clase que contiene el método Main, punto de entrada de la aplicación:

using System;

namespace MiPrimerPrograma
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("¡Hola, mundo!");
        }
    }
}

El espacio de nombres (namespace) organiza el código y evita conflictos de nombres. La directiva using permite acceder a funcionalidades de otros espacios de nombres sin escribir el nombre completo cada vez.

Elementos sintácticos fundamentales

Identificadores y convenciones

Los identificadores en C# siguen reglas específicas: deben comenzar con una letra o guión bajo, pueden contener letras, números y guiones bajos, y distinguen entre mayúsculas y minúsculas.

C# utiliza diferentes convenciones de nomenclatura según el elemento:

public class CalculadoraFinanciera    // PascalCase para clases
{
    private int numeroOperaciones;     // camelCase para campos privados
    public string NombreUsuario { get; set; }  // PascalCase para propiedades
    
    public void CalcularInteres()      // PascalCase para métodos
    {
        int tasaAnual = 5;            // camelCase para variables locales
    }
}

Delimitadores y separadores

Los delimitadores estructuran el código de manera jerárquica. Las llaves {} definen bloques de código, los paréntesis () agrupan parámetros y expresiones, y los corchetes [] se utilizan para arrays y atributos.

public int[] CalcularFactoriales(int limite)
{
    int[] resultados = new int[limite];
    
    for (int i = 0; i < limite; i++)
    {
        resultados[i] = CalcularFactorial(i + 1);
    }
    
    return resultados;
}

El punto y coma (;) termina las declaraciones, mientras que las comas (,) separan elementos en listas de parámetros, arrays y declaraciones múltiples.

Programación Orientada a Objetos en C#

La programación orientada a objetos (POO) representa un paradigma fundamental en el desarrollo de software moderno, especialmente relevante en C#. Este enfoque permite modelar problemas del mundo real mediante la creación de entidades que encapsulan tanto datos como comportamientos, proporcionando una base sólida para construir aplicaciones robustas y mantenibles.

Fundamentos conceptuales

En C#, todo gira en torno a los objetos. Un objeto es una instancia de una clase que combina propiedades (datos) y métodos (comportamientos) en una sola unidad cohesiva. Esta aproximación facilita la organización del código y mejora significativamente la reutilización de componentes.

Las clases actúan como plantillas o moldes que definen la estructura y comportamiento que tendrán los objetos creados a partir de ellas. Cuando declaramos una clase en C#, estamos estableciendo un nuevo tipo de dato personalizado que puede incluir campos, propiedades, métodos y eventos.

public class Vehiculo
{
    public string Marca { get; set; }
    public string Modelo { get; set; }
    public int Año { get; set; }
    
    public void Acelerar()
    {
        Console.WriteLine($"El {Marca} {Modelo} está acelerando");
    }
}

Pilares fundamentales

La programación orientada a objetos en C# se sustenta sobre cuatro pilares fundamentales que proporcionan estructura y flexibilidad al código.

Encapsulación

La encapsulación permite ocultar los detalles internos de implementación y exponer únicamente las interfaces necesarias. En C#, esto se logra mediante modificadores de acceso que controlan la visibilidad de los miembros de una clase.

public class CuentaBancaria
{
    private decimal saldo; // Campo privado
    
    public decimal Saldo 
    { 
        get { return saldo; } 
        private set { saldo = value; } 
    }
    
    public void Depositar(decimal cantidad)
    {
        if (cantidad > 0)
            saldo += cantidad;
    }
}

Herencia

La herencia establece relaciones jerárquicas entre clases, permitiendo que una clase derive características de otra. La clase base proporciona funcionalidad común, mientras que las clases derivadas pueden especializar o extender este comportamiento.

public class Animal
{
    public string Nombre { get; set; }
    
    public virtual void HacerSonido()
    {
        Console.WriteLine("El animal hace un sonido");
    }
}

public class Perro : Animal
{
    public override void HacerSonido()
    {
        Console.WriteLine($"{Nombre} ladra: ¡Guau!");
    }
}

Polimorfismo

El polimorfismo permite que objetos de diferentes tipos respondan de manera específica a la misma interfaz. En C#, esto se implementa principalmente através de métodos virtuales, sobrescritura y interfaces.

Animal[] animales = { new Perro(), new Gato(), new Pajaro() };

foreach (Animal animal in animales)
{
    animal.HacerSonido(); // Cada animal hace su sonido específico
}

Abstracción

La abstracción se centra en definir contratos y comportamientos esenciales sin especificar los detalles de implementación. Las clases abstractas y las interfaces son las herramientas principales para lograr este objetivo.

public abstract class Forma
{
    public abstract double CalcularArea();
    
    public void MostrarInformacion()
    {
        Console.WriteLine($"Área: {CalcularArea()}");
    }
}

Colecciones y LINQ en C#

Las colecciones en C# representan uno de los pilares fundamentales para el manejo eficiente de datos en aplicaciones modernas. A diferencia de los arrays tradicionales, las colecciones ofrecen flexibilidad dinámica y funcionalidades avanzadas que permiten almacenar, organizar y manipular conjuntos de elementos de manera más sofisticada.

Fundamentos de las colecciones

El namespace System.Collections.Generic proporciona las estructuras de datos más utilizadas en el desarrollo profesional. Estas colecciones están tipadas, lo que significa que garantizan la seguridad de tipos en tiempo de compilación y ofrecen mejor rendimiento que sus contrapartes no genéricas.

Las colecciones genéricas más importantes incluyen List<T>, Dictionary<TKey, TValue>, HashSet<T> y Queue<T>. Cada una está diseñada para escenarios específicos y ofrece diferentes características de rendimiento según las operaciones que necesites realizar.

// Declaración de diferentes tipos de colecciones
List<string> nombres = new List<string>();
Dictionary<int, string> usuarios = new Dictionary<int, string>();
HashSet<int> numerosUnicos = new HashSet<int>();

Manipulación básica de colecciones

La interfaz ICollection<T> define las operaciones fundamentales que todas las colecciones deben implementar. Esto incluye métodos para agregar, eliminar y verificar la existencia de elementos, así como propiedades para conocer el tamaño de la colección.

List<int> numeros = new List<int> { 1, 2, 3, 4, 5 };

// Operaciones básicas
numeros.Add(6);              // Agregar elemento
numeros.Remove(3);           // Eliminar elemento específico
bool existe = numeros.Contains(4);  // Verificar existencia
int cantidad = numeros.Count;       // Obtener tamaño

Las operaciones de búsqueda en colecciones varían según el tipo utilizado. Mientras que List<T> realiza búsquedas lineales, Dictionary<TKey, TValue> y HashSet<T> ofrecen búsquedas en tiempo constante promedio gracias a su implementación basada en tablas hash.

Programación funcional en C#

La programación funcional representa un paradigma de desarrollo que se centra en el uso de funciones como elementos fundamentales para construir aplicaciones. A diferencia de la programación imperativa tradicional, donde nos enfocamos en cómo hacer las cosas paso a paso, la programación funcional se concentra en qué queremos obtener como resultado.

En C#, este paradigma ha ganado relevancia especialmente desde la introducción de LINQ y las expresiones lambda. Microsoft ha incorporado características funcionales que permiten escribir código más expresivo, conciso y fácil de mantener.

Conceptos fundamentales

El paradigma funcional se basa en varios principios clave que transforman la manera en que estructuramos nuestro código. Las funciones puras constituyen el pilar fundamental: son funciones que siempre devuelven el mismo resultado para los mismos parámetros de entrada y no producen efectos secundarios.

// Función pura - siempre devuelve el mismo resultado
public static int Sumar(int a, int b)
{
    return a + b;
}

// Función impura - depende de estado externo
private static int contador = 0;
public static int IncrementarContador()
{
    return ++contador; // Modifica estado externo
}

La inmutabilidad es otro concepto esencial. En lugar de modificar objetos existentes, creamos nuevos objetos con los cambios deseados. Esto elimina muchos errores relacionados con el estado compartido y hace que el código sea más predecible.

// Enfoque inmutable
public static List<int> AgregarElemento(List<int> lista, int elemento)
{
    var nuevaLista = new List<int>(lista);
    nuevaLista.Add(elemento);
    return nuevaLista;
}

Funciones de orden superior

Las funciones de orden superior son aquellas que pueden recibir otras funciones como parámetros o devolver funciones como resultado. C# facilita este concepto a través de delegados y tipos como Func<T> y Action<T>.

// Función que recibe otra función como parámetro
public static List<T> Filtrar<T>(List<T> lista, Func<T, bool> predicado)
{
    var resultado = new List<T>();
    foreach (var elemento in lista)
    {
        if (predicado(elemento))
        {
            resultado.Add(elemento);
        }
    }
    return resultado;
}

// Uso de la función
var numeros = new List<int> { 1, 2, 3, 4, 5, 6 };
var pares = Filtrar(numeros, x => x % 2 == 0);

La programación asíncrona en C# permite ejecutar tareas de manera no bloqueante, mejorando el rendimiento de las aplicaciones. En el contexto de C#, la programación asíncrona se realiza principalmente utilizando las palabras clave async y await, además de las clases Task y Task<T>. A continuación, se presentan conceptos clave y ejemplos prácticos para entender y aplicar programación asíncrona en C#.

Conceptos básicos

async y await

Las palabras clave async y await son fundamentales en la programación asíncrona de C#. La palabra clave async se utiliza para marcar un método como asíncrono, mientras que await se utiliza para esperar de manera asíncrona la finalización de una tarea.

public async Task EjemploAsincrono()
{
    await TareaAsincrona();
}

Task y Task<T>

La clase Task representa una operación asíncrona que no devuelve un valor, mientras que Task<T> representa una operación asíncrona que devuelve un valor de tipo T.

public async Task<int> ObtenerResultadoAsincrono()
{
    await Task.Delay(1000); // Simula una operación asíncrona
    return 42;
}

Implementación de métodos asíncronos

Métodos que no devuelven valor

Para implementar un método asíncrono que no devuelva un valor, se utiliza Task como tipo de retorno y se emplea await para esperar la finalización de tareas asíncronas.

public async Task ProcesarDatosAsincrono()
{
    // Simula una operación de procesamiento de datos
    await Task.Delay(2000);
    Console.WriteLine("Datos procesados");
}

Métodos que devuelven valor

Para métodos que devuelven un valor, se utiliza Task<T> como tipo de retorno y se emplea await para obtener el resultado de la tarea.

public async Task<string> ObtenerDatosAsincrono()
{
    await Task.Delay(1000); // Simula una operación asíncrona
    return "Datos obtenidos";
}

Manejo de excepciones

En la programación asíncrona, las excepciones pueden ser manejadas utilizando bloques try-catch dentro de los métodos marcados con async.

public async Task ManejarExcepcionesAsincrono()
{
    try
    {
        await Task.Run(() => throw new InvalidOperationException("Error simulado"));
    }
    catch (InvalidOperationException ex)
    {
        Console.WriteLine($"Excepción manejada: {ex.Message}");
    }
}

Testing en C#

El testing o pruebas de software constituye una disciplina fundamental en el desarrollo profesional que garantiza la calidad y confiabilidad del código. En C#, las pruebas automatizadas permiten verificar que nuestro código funciona correctamente y detectar errores antes de que lleguen a producción.

Fundamentos del testing

Las pruebas unitarias representan el nivel más básico de testing, donde se verifica el comportamiento de unidades individuales de código, típicamente métodos o clases. Estas pruebas deben ser independientes, rápidas de ejecutar y fáciles de entender.

El framework de testing más utilizado en el ecosistema .NET es MSTest, que viene integrado con Visual Studio, aunque también existen alternativas como NUnit y xUnit. Estos frameworks proporcionan las herramientas necesarias para escribir, organizar y ejecutar pruebas de manera eficiente.

Estructura básica de una prueba

Una prueba unitaria típica sigue el patrón AAA (Arrange, Act, Assert):

• Arrange: Preparar los datos y objetos necesarios
• Act: Ejecutar el método que queremos probar
• Assert: Verificar que el resultado es el esperado

[TestMethod]
public void Sumar_DosNumeros_RetornaResultadoCorrecto()
{
    // Arrange
    var calculadora = new Calculadora();
    int a = 5;
    int b = 3;
    
    // Act
    int resultado = calculadora.Sumar(a, b);
    
    // Assert
    Assert.AreEqual(8, resultado);
}