C# Programación funcional

La programación funcional representa un paradigma poderoso que ha ganado relevancia significativa en el ecosistema de C# y .NET durante los últimos años. A diferencia del enfoque imperativo tradicional, donde nos centramos en "cómo" realizar las tareas mediante secuencias de instrucciones, el paradigma funcional nos invita a pensar en términos de "qué" queremos lograr mediante transformaciones de datos y composición de funciones.

¿Qué es la programación funcional en C#?

La programación funcional en C# es un enfoque declarativo que trata las funciones como ciudadanos de primera clase, permitiéndote escribir código más conciso, mantenible y menos propenso a errores. Este paradigma se basa en principios fundamentales como:

• Inmutabilidad: Los datos no cambian una vez creados, evitando efectos secundarios inesperados.
• Funciones puras: Operaciones que siempre producen el mismo resultado para los mismos argumentos, sin efectos colaterales.
• Composición de funciones: Combinación de funciones simples para crear operaciones complejas.
• Evaluación perezosa: Cálculo de valores solo cuando son necesarios, optimizando el rendimiento.

Evolución funcional de C#

C# ha evolucionado significativamente desde sus primeras versiones, incorporando características funcionales que complementan su naturaleza orientada a objetos:

• C# 2.0 introdujo los delegados anónimos
• C# 3.0 trajo las expresiones lambda y LINQ
• C# 7.0 añadió mejoras en pattern matching
• C# 9.0 incorporó los records para datos inmutables
• C# 10.0 y 11.0 refinaron estas características con mejoras sustanciales

Esta evolución ha transformado C# en un lenguaje multiparadigma que permite combinar lo mejor de la programación orientada a objetos con técnicas funcionales avanzadas.

Beneficios del enfoque funcional en C#

Adoptar técnicas funcionales en tus proyectos C# ofrece numerosas ventajas:

• Código más legible: Las expresiones declarativas comunican intención más claramente.
• Menos errores: La inmutabilidad y las funciones puras reducen bugs relacionados con estado compartido.
• Mayor testabilidad: Las funciones puras son inherentemente más fáciles de probar.
• Paralelismo simplificado: El código sin efectos secundarios facilita la ejecución concurrente.
• Mantenimiento mejorado: La composición de funciones permite cambios localizados.

Componentes clave de C# funcional

Expresiones Lambda

Las expresiones lambda son funciones anónimas concisas que puedes usar para crear delegados o tipos de árbol de expresión. Representan el corazón de la programación funcional en C#:

// Lambda simple con un parámetro
Func<int, int> cuadrado = x => x * x;

// Lambda con múltiples parámetros
Func<int, int, int> sumar = (a, b) => a + b;

// Lambda con cuerpo de bloque
Func<string, int> contarCaracteres = s => 
{
    Console.WriteLine($"Analizando: {s}");
    return s.Length;
};

Delegados funcionales

C# proporciona delegados genéricos predefinidos como Func<>, Action<> y Predicate<> que facilitan el trabajo con funciones como valores:

// Func<TInput, TOutput> - función que toma entrada y devuelve salida
Func<string, int> obtenerLongitud = s => s.Length;

// Action<T> - función que realiza una acción sin devolver valor
Action<string> imprimir = s => Console.WriteLine(s);

// Predicate<T> - función que evalúa una condición
Predicate<int> esPar = n => n % 2 == 0;

LINQ funcional

LINQ (Language Integrated Query) es una implementación práctica de programación funcional que permite consultar y transformar colecciones de datos de forma declarativa:

var numeros = new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

// Enfoque funcional con LINQ
var numerosParesDuplicados = numeros
    .Where(n => n % 2 == 0)     // Filtrado
    .Select(n => n * 2)         // Transformación
    .OrderByDescending(n => n)  // Ordenación
    .ToList();                  // Materialización

LINQ ofrece dos sintaxis: la sintaxis de método (como en el ejemplo anterior) y la sintaxis de consulta, más similar a SQL:

// Sintaxis de consulta LINQ
var resultado = from n in numeros
                where n % 2 == 0
                orderby n descending
                select n * 2;

Records

Los records introducidos en C# 9 son tipos de referencia inmutables diseñados específicamente para representar datos sin comportamiento complejo:

// Definición concisa de un record
public record Persona(string Nombre, int Edad);

// Uso de records
var persona1 = new Persona("Ana", 30);
var persona2 = new Persona("Ana", 30);

// Igualdad basada en valores, no en referencia
Console.WriteLine(persona1 == persona2); // True

// Creación de una copia con modificaciones (inmutabilidad)
var persona3 = persona1 with { Edad = 31 };

Pattern Matching

El pattern matching permite escribir lógica condicional expresiva y basada en la estructura de los datos:

// Pattern matching con switch expression
string DescribirValor(object valor) => valor switch
{
    null => "Valor nulo",
    int n when n < 0 => "Número negativo",
    int n => $"Número positivo: {n}",
    string s when s.Length == 0 => "Cadena vacía",
    string s => $"Cadena de longitud {s.Length}",
    [] => "Colección vacía",
    ICollection c => $"Colección con {c.Count} elementos",
    _ => "Otro tipo de objeto"
};

Aplicaciones prácticas

La programación funcional en C# es especialmente útil para:

• Procesamiento de datos: Transformaciones, filtrados y agregaciones de colecciones.
• Manejo de operaciones asíncronas: Combinación con Task<T> y async/await.
• Validación de datos: Composición de reglas de validación.
• Implementación de patrones: Como Strategy, Command o Decorator.
• Desarrollo de DSLs (Domain-Specific Languages): Creación de APIs fluidas.