¿Qué es fixed en C#?

La palabra clave fixed en C# se usa en dos contextos, ambos relacionados con el trabajo de bajo nivel y el manejo de memoria no administrada (unsafe code).

Para obtener un puntero fijo a una variable administrada

En C#, los objetos administrados pueden moverse en memoria (por el Garbage Collector). Si queremos trabajar con punteros (como en C o C++), necesitamos asegurarnos de que el objeto no se mueva durante el uso del puntero.

Ahí entra fixed, le indica al runtime que fije el objeto en memoria.

unsafe 

{

    int[] numeros = { 1, 2, 3, 4 };

    fixed (int* p = numeros)

    {

        for (int i = 0; i < 4; i++)

        {

            Console.WriteLine(*(p + i));

        }

    }

}

• fixed bloquea el arreglo numeros en memoria.
• int* p es un puntero al primer elemento.
• Mientras esté dentro del bloque fixed, numeros no se moverá.

Para fijar buffers dentro de structs fixed size buffer

C# permite declarar buffers de tamaño fijo dentro de structs cuando estás trabajando en código unsafe.

unsafe struct MiBuffer

{

    public fixed byte datos[10];

}

• Aquí datos es un array de 10 bytes directamente dentro del struct.
• Es muy usado cuando interoperás con código nativo o estructuras de bajo nivel.

Cosas importantes:

• Solo se puede usar fixed dentro de código marcado como unsafe.
• Necesitás habilitar la opción /unsafe en el compilador o el flag en el proyecto.
• Ayuda a interoperar con APIs nativas, como Win32, o trabajar con bloques de memoria directamente.
• No es algo común en código de negocio habitual en C#, pero sí muy usado en interop, performance crítica o trabajo con hardware.

new vs override en C#: ¿cuál es la diferencia y cuándo usar cada uno?

Cuando trabajamos con herencia en C#, dos palabras clave aparecen para definir comportamiento en clases derivadas: new y override. A primera vista pueden parecer similares, pero representan intenciones diferentes. Entenderlas bien puede evitarte muchos errores.

En C# una clase puede heredar miembros (métodos, propiedades, etc.) de otra. ¿Pero qué pasa si queremos cambiar el comportamiento de un método heredado?

Ahí entran en juego override y new.

Cuando queremos modificar el comportamiento de un método heredado, usámos override.

class Animal

{

    public virtual void Hablar()

    {

        Console.WriteLine("Hace un sonido");

    }

}

class Perro : Animal

{

    public override void Hablar()

    {

        Console.WriteLine("Guau");

    }

}

Y ahora mirá esto:

Animal a = new Perro();

a.Hablar(); // Imprime "Guau"

Con override, el comportamiento depende del tipo real del objeto, no del tipo de la variable. Esto se llama polimorfismo.

En cambio, new oculta el método de la clase base. No lo reemplaza a nivel del sistema de tipos.

class Animal

{

    public void Hablar()

    {

        Console.WriteLine("Hace un sonido");

    }

}

class Gato : Animal

{

    public new void Hablar()

    {

        Console.WriteLine("Miau");

    }

}

Probá esto:

Animal a = new Gato();

a.Hablar(); // Imprime "Hace un sonido"

Porque a es del tipo Animal, y el método Hablar() de Gato no lo reemplazó: solo lo ocultó. Pero:

Gato g = new Gato();

g.Hablar(); // Imprime "Miau"

¿cuándo uso new?

• Cuando querés ocultar intencionalmente un método de la clase base, pero sin reemplazarlo para el sistema de tipos.
• Generalmente se evita, porque puede causar confusión. Se usa cuando no podés cambiar la clase base (por ejemplo, una librería externa) pero necesitás un método con el mismo nombre y diferente comportamiento.

¿Qué pasa si no usás ni new ni override? El compilador mostrará una advertencia si detecta que estás ocultando un miembro sin decirlo explícitamente.

// Esto compila, pero da warning:

public void Hablar() { ... } // Oculta un método de la base

Siempre que ocultes un miembro heredado, C# quiere que lo declares con new o override, para que tu intención sea clara.

Conversiones implicit y explicit en C#

En C#, los operadores implicit y explicit nos permiten definir conversiones personalizadas entre tipos. Esto es útil cuando trabajamos con estructuras o clases que representan conceptos que pueden transformarse naturalmente en otros valores, como metros a kilómetros, grados a radianes, o monedas.

Cuando diseñamos tipos personalizados, muchas veces necesitamos que se comporten como si fueran valores comunes. Por ejemplo, si tenemos un struct Metros, queremos poder escribir:

Metros distancia = 100.0;

En lugar de tener que usar un constructor o un método auxiliar. O, si ya tenemos un objeto de tipo Metros, queremos poder convertirlo a double sin esfuerzo.

Sin conversiones definidas, tendríamos que hacer algo como:

var distancia = new Metros(100.0);

double d = distancia.Valor;

Definiendo operadores de conversión, podemos hacer que esta interacción sea más fluida.

El modificador implicit permite definir una conversión automática cuando no hay pérdida de información. El compilador permitirá esta conversión sin necesidad de cast.

Por ejemplo:

public struct Metros

{

    public double Valor { get; }

    public Metros(double valor) => Valor = valor;

    public static implicit operator Metros(double valor) => new Metros(valor);

}

Uso:

Metros distancia = 100.0; // conversión implícita desde double

Cuando una conversión puede perder información, o puede fallar, se recomienda marcarla como explicit. Esto obliga al programador a escribir el cast, dejando claro que está realizando una operación que podría tener consecuencias.

Por ejemplo:

public static explicit operator double(Metros metros) => metros.Valor;

Uso:

double d = (double)distancia; // cast explícito requerido

Las conversiones implicit y explicit en C# permiten diseñar APIs más amigables, legibles y seguras. Usá implicit cuando estés seguro de que la conversión no va a fallar ni perder datos, y explicit cuando quieras que el programador sea consciente del riesgo de la conversión.

Trabajando con partes de colecciones sin copiar: slices, spans y más

Cuando trabajamos con colecciones o buffers de datos, es muy común necesitar operar solo sobre una parte de ellos: una porción de un array, un segmento de texto, o un rango de bytes. La solución más directa suele ser copiar esa parte a una nueva estructura… pero eso introduce sobrecarga innecesaria de memoria y CPU. Si queremos trabajar con partes de una colección (por ejemplo, un array, un string o un buffer de bytes) sin crear copias, es decir, tener una vista o referencia a un fragmento de la colección original.  

Es decir, queremos qu esta solución sea:

• Ligera en memoria (sin asignaciones adicionales)
• Segura (sin acceder fuera de los límites)
• Eficiente (idealmente sin costo en tiempo de ejecución)

Muchos lenguajes modernos han ido incorporando construcciones para resolver este problema. Veamos cómo lo hacen C#, Go y Rust.

A partir de C# 7.2, se introdujo Span<T>, una estructura de tipo ref struct que representa una ventana sobre memoria contigua. 

int[] datos = { 10, 20, 30, 40 };

Span<int> segmento = datos.AsSpan(1, 2); // contiene {20, 30}

Podés usar Span<T> para:

• Evitar copiar arrays o strings.
• Trabajar con memoria en el stack (stackalloc).
• Reutilizar buffers en pipelines o parsers.
• Procesar archivos grandes en trozos.

Span<byte> buffer = stackalloc byte[1024]; // sin heap

Limitaciones:

• No puede usarse como campo de clases (sólo en structs).
• No se puede usar con async/await ni capturar en lambdas.
• Solo dentro del alcance del stack (por diseño).

Go tiene slices desde siempre: son una capa por encima de los arrays. Un slice guarda un puntero al array subyacente, longitud y capacidad.

arr := [5]int{1, 2, 3, 4, 5}

s := arr[1:4] // contiene {2, 3, 4}

Ventajas:

• Livianos y eficientes.
• Se puede modificar el contenido (afecta al array original).
• Permiten crecer mediante append si hay capacidad.

s[0] = 99 // también cambia arr[1]

La semántica de slicing en Go es natural y permite componer operaciones sin asignar memoria.

Rust maneja este problema con referencias segmentadas: &[T] para vistas inmutables y &mut [T] para mutables.

let arr = [1, 2, 3, 4];

let slice = &arr[1..3]; // &[2, 3]

Características:

• Completamente seguras en tiempo de compilación.
• El borrow checker impide aliasing mutable.
• Altamente eficientes, sin sobrecarga.
• Son la base de muchas APIs estándar.

fn print_slice(s: &[i32]) {

    for val in s {

        println!("{}", val);

    }

}

¿Y cuál conviene?

• Si estás en un lenguaje GC-friendly como C#, Span<T> te da poder sin pagar costo de GC.
• Si buscás simplicidad y velocidad de desarrollo, Go es imbatible con su slicing natural.
• Si necesitás seguridad al máximo y performance nativa, Rust con slices es lo más robusto.

Es decir, depende del lenguaje que estes usando ... 

Y Otros lenguajes tambien tenemos cosas parecidas: 

• C++20: std::span<T> cumple un rol casi idéntico a Span<T> de C#, y también es zero-copy.
• Python: memoryview permite trabajar con buffers sin copiar, aunque menos seguro.
• Java: No tiene slices como tal, pero ByteBuffer puede simularlos.
• Nim, Zig, D: Todos ofrecen slices como vistas eficientes sobre datos.

En la práctica, estas estructuras son fundamentales para escribir código eficiente, especialmente en procesamiento de datos, parsers, sistemas embebidos o cualquier aplicación donde el rendimiento importa.  

Span en C#: Acceso seguro y eficiente a la memoria

A partir de C# 7.2 y .NET Core 2.1, Microsoft introdujo una de las herramientas más poderosas para manipular memoria sin sacrificar seguridad: Span<T>. Esta estructura permite trabajar con porciones contiguas de memoria (arrays, segmentos de strings, buffers, etc.) de forma eficiente, sin generar asignaciones en el heap ni usar punteros directamente.

Span<T> es una estructura stack-only que representa una ventana mutable sobre un bloque contiguo de memoria. Podés usarlo para acceder, cortar o modificar datos de arrays, slices de strings, buffers nativos, y más, sin necesidad de copiar datos.

Veamos un ejemplo: 

int[] numbers = { 1, 2, 3, 4, 5 };

Span<int> slice = numbers.AsSpan(1, 3); // Contiene 2, 3, 4

slice[0] = 42;

Console.WriteLine(numbers[1]); // Muestra 42 (modificó el array original)

¿Por qué usar Span<T>?

• Evita copias de memoria innecesarias
• No genera asignaciones en el heap 
• Mejora la performance en procesamiento de strings, buffers y arrays  
• Ofrece seguridad de tipos y bounds-checking
• Solo puede usarse dentro del stack (no puede almacenarse en campos de clase)

Limitaciones:

• No puede usarse en métodos async o iteradores (async, yield return)  
• No puede almacenarse en campos de clase o como parte de objetos del heap
• Si necesitás algo similar pero heap-safe, podés usar Memory<T>

Veamos un ejemplo de string: 

ReadOnlySpan<char> span = "Hola Mundo".AsSpan(5);

Console.WriteLine(span.ToString()); // Mundo

Esto es ideal para parsear strings sin crear substrings intermedias.

Span<T> es una herramienta fundamental si querés escribir código de alto rendimiento en .NET. Es ideal para manipular datos binarios, strings o buffers, con el mínimo impacto en el garbage collector. Aunque tiene limitaciones (no se puede escapar del stack), su potencia compensa con creces en escenarios críticos de performance.

¿Qué significa Nullable en el archivo .csproj de C#?

Desde C# 8, el lenguaje introdujo el análisis de nulabilidad (nullable reference types), una herramienta poderosa para ayudarte a detectar posibles null en tiempo de compilación. Esta funcionalidad se activa o desactiva con la propiedad <Nullable> en el archivo .csproj.

Cuando está activado, el compilador trata los tipos de referencia como no anulables por defecto, a menos que explícitamente los marques con ?.

Veamos un ejemplo: 

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>

    <TargetFramework>net8.0</TargetFramework>

    <Nullable>enable</Nullable>

  </PropertyGroup>

</Project>

Y en el projecto: 

string name = null; // Warning: posible asignación nula

string? nickname = null; // Permitido

con Nullable deshabilitado:

string name = null; // No hay advertencias, aunque puede fallar en runtime

Activar Nullable te permite:

• Recibir advertencias si estás usando variables que podrían ser null.
• Hacer que tus APIs sean más expresivas (string? vs string).
• Reducir errores en tiempo de ejecución por NullReferenceException.
• Trabajar mejor con herramientas de análisis estático.

Usar <Nullable>enable</Nullable> en tus proyectos de C# modernos es una excelente práctica. Aumenta la robustez del código y te da más control sobre los errores relacionados con null, una de las fuentes más comunes de fallos en producción.

unsafe acceso directo a la memoria en C#

C# es un lenguaje seguro por defecto, lo que significa que evita errores comunes como accesos ilegales a memoria. Sin embargo, hay ocasiones en las que necesitamos un control más bajo nivel, como en interoperabilidad con código nativo o para optimizaciones de rendimiento. Para eso existe la palabra clave unsafe

La palabra clave unsafe en C# habilita el uso de punteros, acceso directo a memoria y operaciones que normalmente están fuera del alcance del entorno de ejecución administrado del .NET runtime. En otras palabras, permite usar características similares a C/C++, con sus pros y contras.

Para usarlo, debés marcar bloques, métodos o estructuras con la palabra clave unsafe. También tenés que habilitarlo en el proyecto.

En el `.csproj`:

<PropertyGroup>

  <AllowUnsafeBlocks>true</AllowUnsafeBlocks>

</PropertyGroup>

Veamos un ejemplo: 

unsafe

{

    int valor = 42;

    int* puntero = &valor;

    Console.WriteLine(*puntero); // Imprime 42

}

Cuando queremos apuntar a arrays o strings, que son gestionados por el Garbage Collector, necesitamos usar fixed para evitar que el objeto se mueva en memoria:

unsafe

{

    int[] numeros = { 10, 20, 30 };

    fixed (int* p = numeros)

    {

        Console.WriteLine(p[1]); // Imprime 20

    }

}

Que podemos hacer con unsafe?

• Declaración y uso de punteros (`*`, `&`)
• Indexación de punteros (`p[i]`)
• Aritmética de punteros (`p++`, `p + 1`, etc.)
• Conversión entre tipos de punteros
• Uso de `sizeof(T)` para tipos primitivos

Pero ¿Cuándo usamos unsafe?

• Interop con librerías nativas (C, C++, DLLs).
• Manipulación avanzada de memoria.
• Procesamiento de imágenes o buffers donde la performance es crítica.
• Serialización binaria de alto rendimiento.

Como se pueden imaginar esto es tan util como peligroso, que es lo que puede salir mal?

• Podemos introducir errores difíciles de depurar (como corrupción de memoria).
• Desactiva algunas protecciones del CLR.
• El código unsafe no se ejecuta en entornos con restricciones de seguridad (como ciertos sandboxes).
• No es portable entre arquitecturas de forma garantizada.

Dentro de unsafe, podemos usar sizeof` para obtener el tamaño de tipos primitivos:

unsafe

{

    Console.WriteLine(sizeof(int));   // 4

    Console.WriteLine(sizeof(byte));  // 1

}

También podés usarlo con nint, nuint, float, double, etc.

Si queremos evitar unsafe pero aún así trabajar con memoria de forma eficiente:

• Span<T>` y `Memory<T>
• System.Runtime.InteropServices.MemoryMarshal
• stackalloc para asignaciones rápidas en la pila (sin punteros).

El modo unsafe en C# te da acceso a un poder inmenso, pero con gran responsabilidad. Es una herramienta útil para situaciones específicas donde el rendimiento o la interoperabilidad lo justifican, pero debe usarse con precaución y conocimiento.

¿Qué es ImplicitUsings en C# y por qué es útil?

Con la llegada de .NET 6 y la idea de simplificar el código, Microsoft introdujo una nueva funcionalidad que puede ahorrarte varias líneas repetitivas en los archivos .cs: los usings implícitos, habilitados con la propiedad <ImplicitUsings>.

Cuando activás esta propiedad en el archivo .csproj, el compilador de C# agrega automáticamente un conjunto de using comunes a todos los archivos del proyecto, sin que tengas que escribirlos vos mismo.

Por ejemplo: 

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>

    <TargetFramework>net8.0</TargetFramework>

    <ImplicitUsings>enable</ImplicitUsings>

  </PropertyGroup>

</Project>

Gracias a esto, podés usar tipos como List<string>, Task, HttpClient, etc., directamente, sin declarar explícitamente:

using System.Collections.Generic;

using System.Threading.Tasks;

using System.Net.Http;

¿Qué usings incluye? Depende del tipo de proyecto (console, ASP.NET, etc.), pero algunos de los más comunes son:

• System
• System.Collections.Generic
• System.IO
• System.Linq
• System.Net.Http
• System.Threading.Tasks
• Y muchos más según el SDK usado

Si querés ver la lista exacta, podés mirar el archivo generado: obj/YourProject.GlobalUsings.g.cs

<ImplicitUsings> es una pequeña gran herramienta que simplifica la escritura de código en C#, especialmente útil en proyectos nuevos. Al eliminar la necesidad de repetir los mismos using una y otra vez, te permite concentrarte en lo que realmente importa: la lógica de tu aplicación.

Clases, Métodos, Propiedades e Indexadores Parciales en C#

En C#, el modificador partial no se limita solo a clases. También puede aplicarse a métodos, propiedades y hasta indexadores.  

Esta característica permite dividir y extender la definición de estos elementos, haciendo que el código sea más limpio, modular y mantenible.

Una clase parcial es aquella que puede ser dividida en múltiples archivos.  

Cada fragmento de la clase debe usar el modificador partial.

Veamos un ejemplo:

// Archivo Persona_Datos.cs

public partial class Persona

{

    public string Nombre { get; set; }

}

// Archivo Persona_Operaciones.cs

public partial class Persona

{

    public string ObtenerNombreCompleto() => Nombre;

}

Al compilar, el compilador junta todas las partes como si estuvieran en un único archivo.

Un método parcial (partial void) permite declarar un método que puede (o no) ser implementado en otra parte de la clase.  

Si no se implementa, el compilador simplemente lo ignora, como si nunca hubiera existido.

Vamos con el ejemplo: 

// Declaración

public partial class Persona

{

    partial void ValidarNombre();

}

// Implementación opcional

public partial class Persona

{

    partial void ValidarNombre()

    {

        if (string.IsNullOrEmpty(Nombre))

        {

            Console.WriteLine("Nombre inválido");

        }

    }

}

• Los métodos parciales siempre deben ser void.
• No pueden tener modificadores de acceso (`public`, `private`, etc.).
• No pueden ser virtuales ni static ni async.

Propiedades Parciales (desde C# 12)

Desde C# 12, se pueden crear propiedades parciales, permitiendo que la lógica de getters y setters sea definida en distintas partes del código.

public partial class Persona

{

    public partial string Nombre { get; set; }

}

// En otro archivo:

public partial class Persona

{

    public partial string Nombre

    {

        get => _nombre;

        set => _nombre = value.Trim();

    }

    private string _nombre;

}

Con esta característica se puede separar la definición de una propiedad de su comportamiento, facilitando la generación automática de propiedades o su personalización.

Un indexador parcial permite dividir la definición de un indexador (this[...]) en varias partes.

Por ejemplo:

public partial class MiColeccion

{

    public partial string this[int index] { get; set; }

}

// En otro archivo:

public partial class MiColeccion

{

    private string[] _datos = new string[10];

    public partial string this[int index]

    {

        get => _datos[index];

        set => _datos[index] = value;

    }

}

Partial es muy importante porque: 

• Separar código generado automáticamente del código personalizado.
• Mejorar la legibilidad y mantenimiento en proyectos grandes.
• Permitir que distintos desarrolladores trabajen simultáneamente en distintas partes de una clase.
• Facilitar extensiones futuras sin modificar directamente el código base.

El soporte de C# para clases, métodos, propiedades e indexadores parciales te da un gran poder para modularizar tu código de forma clara y ordenada.  

Esta es una característica que, bien aprovechada, puede hacer una gran diferencia en proyectos de cualquier tamaño.

Parámetros por Referencia en C#: ref, out, in y Punteros (unsafe)

Cuando programás en C#, tenés varias formas de pasar argumentos a un método: por valor (el comportamiento predeterminado) o por referencia. Esta última opción es muy útil cuando necesitás que el método pueda modificar directamente la variable original, sin copiarla.

En este post te cuento las distintas formas de hacerlo: ref, out, in, y punteros (unsafe). Además, te muestro cómo declararlos, cuándo conviene usarlos, y qué diferencias tienen entre sí.

ref: Lectura y escritura

Con ref, el método puede leer y modificar la variable pasada. Pero el valor debe estar inicializado antes de pasarla.

void SumarUno(ref int numero)
{
    numero += 1;
}

int x = 5;
SumarUno(ref x);  // x ahora vale 6




out: Solo escritura

Con out, el método debe asignar un valor. La variable no necesita estar inicializada previamente.

void ObtenerDoble(out int resultado)
{
    resultado = 84;
}

int r;
ObtenerDoble(out r);  // r ahora vale 84

Ideal cuando querés devolver más de un valor desde un método.




in: Solo lectura

Con in, pasás una variable por referencia, pero solo para lectura. Sirve especialmente con structs grandes, para evitar la copia de memoria.

void Mostrar(in int numero)
{
    Console.WriteLine(numero);
}

int y = 10;
Mostrar(in y);  // y no se puede modificar dentro del método

Punteros (unsafe): Bajo nivel

Si necesitás controlar la memoria directamente, podés usar punteros en código unsafe.

unsafe void Incrementar(int* ptr)
{
    *ptr += 1;
}

unsafe
{
    int z = 7;
    Incrementar(&z);  // z ahora vale 8
}

Declaración rápida

// ref
void Modificar(ref int x)

// out
void Inicializar(out int x)

// in
void SoloLeer(in int x)

// unsafe pointer
unsafe void Modificar(int* x)

Comparativa rápida

Keyword	¿Inicialización previa?	¿Se puede leer?	¿Se puede escribir?	Uso típico
ref	✅	✅	✅	Modificar valor
out	❌	❌	✅	Devolver datos
in	✅	✅	❌	Structs grandes
*	✅	✅	✅	Bajo nivel

Ejemplos útiles

// struct con ref
struct Punto { public int X, Y; }

void Mover(ref Punto p) => p.X += 10;

// out con TryParse
bool TryParseNumero(string s, out int resultado)
{
    return int.TryParse(s, out resultado);
}

// in con cálculo
void MostrarDistancia(in Punto p)
{
    Console.WriteLine($"Distancia: {Math.Sqrt(p.X * p.X + p.Y * p.Y)}");
}

// unsafe con array
unsafe void Duplicar(int* arr, int n)
{
    for (int i = 0; i < n; i++) arr[i] *= 2;
}

C# te da muchas formas de pasar datos, y conocer ref, out, in y los punteros te permite optimizar tu código, mejorar la performance, y diseñar APIs más expresivas. Cada palabra clave tiene su contexto ideal, y entenderlas bien te va a dar más poder sobre lo que tu código realmente hace.

Nuevas características de C# 13

C# 13, junto con .NET 9, trae una serie de mejoras que buscan simplificar la escritura de código, mejorar el rendimiento y ofrecer mayor flexibilidad a los desarrolladores. Veamos que trajo:

Colecciones params mejoradas

Ahora, el modificador params se puede aplicar a tipos que admiten inicialización mediante expresiones de colección, no solo a arreglos. Esto permite una mayor flexibilidad al definir métodos que aceptan un número variable de argumentos.

public void EscribirNombres(params List<string> nombres)

    => Console.WriteLine(string.Join(", ", nombres));

Nuevo tipo de bloqueo: System.Threading.Lock

Se introduce un nuevo tipo de bloqueo que mejora la sincronización de subprocesos. A diferencia del uso tradicional de lock con objetos, System.Threading.Lock proporciona una API más clara y segura para manejar exclusiones mutuas.

var myLock = new Lock();

using (myLock.EnterScope())

{

    // Código protegido

}

Nueva secuencia de escape: \e

Se añade la secuencia de escape \e para representar el carácter de escape ASCII (U+001B). Anteriormente, se utilizaban \u001b o \x1b, pero esta nueva notación es más clara y evita ambigüedades.

Tipos naturales de grupo de métodos

Se mejora la inferencia de tipos al trabajar con grupos de métodos, permitiendo que el compilador determine de manera más precisa el tipo adecuado en contextos donde se utilizan delegados o expresiones lambda.

Propiedades e indexadores parciales

Al igual que los métodos parciales, ahora es posible declarar propiedades e indexadores parciales. Esto facilita la separación de la declaración y la implementación, especialmente útil al trabajar con generadores de código.

partial class MiClase

{

    public partial int MiPropiedad { get; set; }

}

Acceso implícito a indexadores en inicializadores de objetos

Se permite el uso de índices implícitos, como [^1], dentro de inicializadores de objetos, lo que simplifica la inicialización de colecciones y estructuras de datos complejas.

var miArreglo = new int[5] { [^1] = 10 };

Soporte para ref struct en interfaces y genéricos

Los tipos ref struct ahora pueden implementar interfaces y ser utilizados como argumentos de tipo en genéricos, ampliando su aplicabilidad en escenarios de alto rendimiento y manipulación de memoria.

Variables ref y contextos unsafe en iteradores y métodos asincrónicos

Se habilita el uso de variables ref locales y contextos unsafe dentro de métodos asincrónicos y iteradores, siempre que se cumplan ciertas restricciones para garantizar la seguridad del código.

Atributo OverloadResolutionPriority

Se introduce el atributo OverloadResolutionPriority que permite a los desarrolladores especificar la prioridad de resolución de sobrecargas, facilitando la evolución de las API sin romper compatibilidad con versiones anteriores.

Estas mejoras reflejan el compromiso continuo de la comunidad de C# por evolucionar el lenguaje, haciéndolo más potente y expresivo. 

Dejo link: https://developers.redhat.com/articles/2025/04/16/c-13-new-features#

Número variable de argumentos en C#

En C#, la palabra clave params se usa para permitir que un método acepte un número variable de argumentos del mismo tipo sin necesidad de definir múltiples sobrecargas.  

¿Cómo funciona?  

• Solo puede haber un parámetro params por método, y debe ser el último parámetro en la lista.  
• El argumento pasado puede ser una lista de valores separados por comas o un array del tipo especificado.  

Veamos un ejemplo: 

using System;

class Program

{

    static void Main()

    {

        ImprimirNumeros(1, 2, 3, 4, 5);

        ImprimirNumeros(10, 20);

        ImprimirNumeros(); // No pasa nada, la lista puede estar vacía

    }

    static void ImprimirNumeros(params int[] numeros)

    {

        foreach (var num in numeros)

        {

            Console.Write(num + " ");

        }

        Console.WriteLine();

    }

}

La salida va a ser:

1 2 3 4 5  

10 20  

También puedes pasar un array en lugar de valores separados por comas:  

int[] valores = { 100, 200, 300 };

ImprimirNumeros(valores);

Puedes mezclar params con otros parámetros, pero debe estar al final:  

static void Saludar(string mensaje, params string[] nombres)

{

    foreach (var nombre in nombres)

    {

        Console.WriteLine($"{mensaje}, {nombre}!");

    }

}

// Llamadas válidas:

Saludar("Hola", "Juan", "Ana", "Luis");  

Saludar("Bienvenido", "Carlos");  

Y la salida va a ser: 

Hola, Juan!  

Hola, Ana!  

Hola, Luis!  

Bienvenido, Carlos!  

¿Cuándo usar params?  

• Cuando quieres un método flexible sin definir múltiples sobrecargas.  
• Para métodos como Console.WriteLine(), que pueden recibir cualquier cantidad de argumentos.  
• Para situaciones en las que puede haber 0 o más parámetros opcionales sin usar List<T> o IEnumerable<T>.  

Interceptores en C#

Con la llegada de C# 12, una de las características más interesantes introducidas es la capacidad de interceptar llamadas a métodos mediante Interceptores. Esta funcionalidad permite modificar o analizar la ejecución de un método antes o después de su invocación, lo que resulta útil para aspectos como logging, validación, caching y manejo de excepciones.

Los interceptores son una característica que permite redirigir llamadas a métodos a una lógica personalizada en tiempo de compilación. Esto brinda un alto nivel de control sin necesidad de modificar el código fuente original.

Para implementar interceptores en C#, se usa el atributo [InterceptsLocation], que indica que un método debe reemplazar otro en una ubicación específica del código.

Supongamos que tenemos un método que realiza una operación matemática simple:

public static class MathOperations

{

    public static int Add(int a, int b) => a + b;

}

Podemos definir un interceptor que intercepte esta llamada y agregue una funcionalidad adicional, como logging:

using System.Runtime.CompilerServices;

public static class MathInterceptor

{

    [InterceptsLocation("MathOperations.cs", line: 5, column: 5)]

    public static int Add(int a, int b)

    {

        Console.WriteLine($"Interceptando llamada a Add({a}, {b})");

        return a + b;

    }

}

Para tener en cuenta: 

• Los interceptores funcionan en tiempo de compilación y no en ejecución.
• Solo pueden ser usados en métodos con ubicaciones explícitas dentro del código fuente.
• Requieren compatibilidad con la infraestructura de compilación adecuada.

En mi opinión es una forma de programación por aspecto o se podria implementar con esta nueva feature. 

El Operador |> de Elixir y sus equivalentes en otros lenguajes

En Elixir, el operador |> pasa el resultado de una expresión como el primer argumento de la siguiente función. Ya lo explicamos en el post anterior. 

" hello "

|> String.trim()

|> String.upcase()

Resultado: "HELLO"

Este diseño promueve una lectura fluida del código, eliminando la necesidad de paréntesis anidados.

F#, un lenguaje funcional inspirado en ML, también tiene un operador pipe |> con un propósito similar al de Elixir.

" hello "

|> String.trim

|> String.uppercase

El operador en F# permite que el flujo de datos sea explícito, facilitando la composición de funciones.

Python no tiene un operador pipe nativo, pero existen bibliotecas que lo emulan, como `pipe` o `toolz`. Sin embargo, sin bibliotecas adicionales, puedes lograr algo similar con reduce:

from functools import reduce

data = " hello "

result = reduce(lambda acc, fn: fn(acc), [str.strip, str.upper], data)

print(result)  # HELLO

Con una biblioteca como pipe:

from pipe import Pipe

result = " hello " | Pipe(str.strip) | Pipe(str.upper)

print(result)  # HELLO

JavaScript aún no tiene un operador pipe oficial, pero hay una propuesta en desarrollo en el comité TC39 (etapa 2 al momento de escribir). Con esta propuesta, el pipe se usa de la siguiente manera:

" hello "

  |> (x => x.trim())

  |> (x => x.toUpperCase());

Por ahora, puedes emularlo con funciones:

const pipeline = (...fns) => x => fns.reduce((v, f) => f(v), x);

const result = pipeline(

  x => x.trim(),

  x => x.toUpperCase()

)(" hello ");

console.log(result); // HELLO

Scala no tiene un operador pipe nativo, pero es posible definir uno:

implicit class PipeOps[T](val value: T) extends AnyVal {

  def |>[R](f: T => R): R = f(value)

}

val result = " hello "

  |> (_.trim)

  |> (_.toUpperCase)

println(result) // HELLO

En C#, aunque no existe un operador pipe, los métodos de extensión de LINQ se comportan de manera similar:

string result = " hello "

    .Trim()

    .ToUpper();

Console.WriteLine(result); // HELLO

El concepto detrás del operador pipe (`|>`) es universal: facilita la composición de funciones y mejora la legibilidad. Aunque su implementación varía entre lenguajes, su propósito sigue siendo el mismo: transformar datos paso a paso de manera clara y concisa.

El Operador ?? y ??= en C#

En C#, el manejo de valores nulos es crucial para escribir código robusto y limpio. Dos herramientas poderosas que el lenguaje nos ofrece son los operadores ?? y ??=. Estos operadores no solo mejoran la legibilidad, sino que también reducen el código repetitivo.

El operador de coalescencia nula ?? se utiliza para proporcionar un valor alternativo en caso de que una expresión sea null.

var result = value ?? defaultValue;

• Si value no es null, result será igual a value.
• Si value es null, result tomará el valor de defaultValue.

Veamos un ejemplo: 

string? name = null;

string displayName = name ?? "Usuario por defecto";

Console.WriteLine(displayName); // Salida: Usuario por defecto

El operador ??= fue introducido en C# 8.0, el operador de asignación de coalescencia nula simplifica el proceso de asignar un valor a una variable solo si esta es null.

variable ??= value;

Seria como : 

variable = (variable == null) ? value : variable

• Si variable es null, se le asignará value.
• Si variable ya tiene un valor, no se realiza ninguna acción.

Veamos un ejemplo: 

List<int>? numbers = null;

numbers ??= new List<int>();

numbers.Add(42);

Console.WriteLine(string.Join(", ", numbers)); // Salida: 42

Los operadores `??` y `??=` son herramientas esenciales para trabajar con valores nulos de manera elegante y eficiente en C#. Su uso adecuado no solo mejora la legibilidad del código, sino que también ayuda a prevenir errores comunes relacionados con referencias nulas.

Implementación Explícita de Interfaces en C#

La implementación explícita de interfaces en C# es una característica poderosa que permite definir miembros de una interfaz de manera que solo sean accesibles a través de la referencia de la interfaz, no directamente desde una instancia de la clase que la implementa. Esto resulta útil para resolver conflictos de nombres y mejorar la encapsulación. 

Cuando una clase implementa una interfaz, normalmente los miembros de esta interfaz se definen como públicos en la clase. Sin embargo, en algunos casos puede ser deseable que los miembros de la interfaz solo estén disponibles cuando se utiliza una referencia a la interfaz, y no desde la clase directamente. Esto es lo que permite la implementación explícita.

La sintaxis consiste en especificar el nombre de la interfaz antes del nombre del método o propiedad que se está implementando:

void NombreInterfaz.Metodo()

Veamos un ejemplo simple:

interface IA

{

    void B();

}

class MiClase : IA

{

    // Implementación explícita

    void IA.B()

    {

        Console.WriteLine("Método IA.B implementado explícitamente.");

    }

}

class Program

{

    static void Main()

    {

        MiClase obj = new MiClase();

        // No puedes llamar directamente a obj.B()

        // obj.B(); // Esto generaría un error de compilación

        // Debes convertir a la interfaz

        IA interfaz = obj;

        interfaz.B(); // Ahora funciona

    }

}

Un uso común de la implementación explícita es cuando una clase implementa varias interfaces que contienen miembros con el mismo nombre.

interface IA { void B(); }

interface IB { void B(); }

class MiClase : IA, IB

{

    void IA.B()

    {

        Console.WriteLine("IA.B llamado");

    }

    void IB.B()

    {

        Console.WriteLine("IB.B llamado");

    }

}

class Program

{

    static void Main()

    {

        MiClase obj = new MiClase();

        // Acceso explícito a través de cada interfaz

        ((IA)obj).B(); // IA.B llamado

        ((IB)obj).B(); // IB.B llamado

    }

}

Las ventajas de usar esto tenemos:

1. Evitar conflictos de nombres: Permite implementar métodos con el mismo nombre en diferentes interfaces sin ambigüedades.
2. Encapsulación: Los miembros de la interfaz solo son accesibles cuando la instancia de la clase se trata como una referencia a la interfaz.
3. Separación de responsabilidades: Permite mantener lógicas separadas y claras cuando se implementan varias interfaces.

La implementación explícita de interfaces es una herramienta valiosa en C#, especialmente en escenarios donde se requiere mayor encapsulación o resolución de conflictos de nombres. Si bien puede parecer menos intuitiva al principio, ofrece flexibilidad y control sobre cómo se exponen los miembros de una interfaz.

ca1860: Evite utilizar el método de extensión 'Enumerable.Any()'

Me llamo la atención un warnning en mi código C# que decia: "CA1860: Avoid using 'Enumerable.Any()' extension method" y yo dije why? y así nacio este post. 

Para determinar si un tipo de colección tiene algún elemento, es más eficiente y claro usar las propiedades Length, Count o IsEmpty (si es posible) que llamar al método Enumerable.Any.

Any(), que es un método de extensión, usa consultas integradas en lenguaje (LINQ). Es más eficiente confiar en las propiedades propias de la colección y también aclara la intención.

Otro tema es que esta regla es similar a CA1827: No use Count()/LongCount() cuando se pueda usar Any(). Sin embargo, esa regla se aplica al método Count() de Linq, mientras que esta regla sugiere usar la propiedad Count.

Veamos un poco de código: 

bool HasElements(string[] strings)

{

    return strings.Any(); // esto esta mal. 

}

bool HasElements(string[] strings)

{

    return strings.Length > 0; // esto esta bien. 

}

Lo que me dejo pensando es: entiendo que sea más performante no utilizar Any() siempre si tenemos propiedades como Count, Length o IsEmpty. Pero esto no es una desventaja a la hora de cambiar el tipo de colección? 

Podemos concluir que no esta bueno que un lenguaje nos ofrezca 2 o 3 formas de hacer lo mismo y luego nos este retando porque elegimos una. 

Dejo link:

https://learn.microsoft.com/en-us/dotnet/fundamentals/code-analysis/quality-rules/ca1860

Evolución de Pattern Matching en C#

El Pattern Matching es una poderosa característica de C# que permite realizar operaciones basadas en coincidencias de patrones. A medida que han pasado las versiones, esta funcionalidad se ha enriquecido significativamente. A continuación, se explica cómo ha evolucionado:

Type Pattern (C# 7.0)

Permite verificar y hacer un cast de un tipo directamente.

if (obj is int i)

{

    Console.WriteLine(i); // Desde C# 7.0

}

Switch con Pattern Matching (C# 7.0)

El switch puede realizar comparaciones de tipos.

switch (obj)

{

    case int i:

        Console.WriteLine(i);  // Desde C# 7.0

        break;

}

Property Pattern (C# 8.0)

Verifica propiedades de un objeto en un switch.

var person = new Person("John", 30);

var result = person switch

{

    { Name: "John", Age: 30 } => "Matched!", // Desde C# 8.0

    _ => "No Match"

};

Positional Pattern (C# 8.0)

Permite trabajar con tipos que tienen métodos `Deconstruct`.

public record Point(int X, int Y);

var point = new Point(1, 2);

string description = point switch

{

    (1, 2) => "Point at (1,2)",  // Desde C# 8.0

    _ => "Other point"

};

Logical Patterns (and, or, not) (C# 9.0)

Se pueden combinar patrones usando operadores lógicos.

int x = 5;

string result = x switch

{

    > 0 and < 10 => "Between 1 and 9",   // Desde C# 9.0

    _ => "Other"

};

Relational Pattern (C# 9.0)

Se usa para comparar valores numéricos directamente en los patrones.

int x = 20;

string result = x switch

{

    > 10 => "Greater than 10",  // Desde C# 9.0

    _ => "10 or less"

};

List Patterns (C# 11.0)

Trabaja con colecciones de una manera más directa.

int[] numbers = { 1, 2, 3 };

var result = numbers switch

{

    [1, 2, ..] => "Starts with 1, 2",  // Desde C# 11.0

    _ => "Other"

};

 Slice Patterns (C# 11.0)

Captura sublistas utilizando `..`.

int[] numbers = { 1, 2, 3, 4 };

var result = numbers switch

{

    [_, _, .. int[] rest] => $"Rest: {string.Join(", ", rest)}",  // Desde C# 11.0

    _ => "No Match"

};

Y falto hablar de las Guards. Un guard es una condición adicional que puedes usar dentro de un patrón de coincidencia para hacer una verificación más específica. Se utiliza con la palabra clave when. Veamos un ejemplo:

int number = 5;

string result = number switch

{

    int n when n > 0 => "Positive number",

    int n when n < 0 => "Negative number",

    _ => "Zero"

};

Console.WriteLine(result);  // Output: Positive number

El Pattern Matching ha evolucionado desde su introducción en C# 7.0, permitiendo escribir código más expresivo, con patrones que facilitan el trabajo con tipos, propiedades, listas y operadores lógicos. Las versiones más recientes, como C# 11.0, añaden aún más flexibilidad, como los List y Slice Patterns. ¡Con cada nueva versión, el Pattern Matching sigue siendo una de las características más poderosas del lenguaje!

Comprendiendo `ref`, `out` e `in` en C#

ref, out, e in permiten controlar cómo se pasan los parámetros a los métodos, pero no es fácil recordar las diferencias de cada uno. Bueno, vamos a ver si este post puede dar luz a este asunto. 

Cuando llamamos a un método en C#, los parámetros se pueden pasar de diferentes maneras: por valor o por referencia. Entender la diferencia es crucial para controlar cómo los métodos interactúan con las variables que reciben.

• Por Valor: El método recibe una copia del valor, por lo que los cambios dentro del método no afectan la variable original.
• Por Referencia: El método recibe una referencia a la variable original, permitiendo modificar su valor.

ref: Pasar Parámetros por Referencia para Modificar

La palabra clave `ref` se utiliza cuando se quiere que un método tenga la capacidad de modificar la variable que se le pasa como parámetro. El parámetro debe estar inicializado antes de pasar al método.

void Incrementar(ref int numero) {

    numero++;

}

int valor = 5;

Incrementar(ref valor);

// valor ahora es 6

`ref` en C# es similar a pasar un parámetro por referencia utilizando `&` en C++, lo que permite la modificación del valor original dentro del método.

`out` se usa cuando un método necesita devolver un valor a través de un parámetro. A diferencia de `ref`, el parámetro no necesita estar inicializado antes de pasarse al método.

Por ejemplo: 

void AsignarValor(out int resultado) {

    resultado = 10;

}

int valor;

AsignarValor(out valor);

// valor ahora es 10

in: Pasar Parámetros por Referencia para Solo Lectura

La palabra clave `in` se usa para pasar un parámetro por referencia de manera que el método pueda leer el valor, pero no modificarlo. Esto es útil para evitar copias innecesarias de grandes estructuras de datos, mientras se asegura que no se alterarán.

void MostrarValor(in int valor) {

    Console.WriteLine(valor);

}

int numero = 5;

MostrarValor(in numero);

// Imprime 5

`in` se puede comparar con el uso de referencias constantes en C++ (`const int&`), donde la función puede leer el valor, pero no modificarlo.

ref` y out permiten que un método modifique el valor de un parámetro, pero `ref` requiere que la variable esté inicializada antes de ser pasada, mientras que `out` no.

in permite la pasada por referencia para mejorar la eficiencia (especialmente con grandes estructuras), pero no permite la modificación del valor, mientras que `ref` sí.

Debemos usar ref` cuando necesites que el método pueda leer y modificar el valor original.  Y out cuando quieras devolver un valor a través de un parámetro que no necesita estar inicializado.

Y  in, cuando se quiere pasar grandes estructuras de datos por referencia para evitar copias, pero asegurándote de que el método no pueda modificar el valor.

Este conocimiento permite a los desarrolladores de C# escribir métodos más flexibles y eficientes, optimizando el rendimiento y controlando cómo se manipulan los datos.

Primary constructors in C# 12 very similar to Scala constructors

With the arrival of C# 12, the language has introduced several new features that make programming more concise and expressive. Among them, Primary Constructors stand out for simplifying the way classes initialize their members. This feature is similar to what Scala has long offered with its primary constructors.

Primary Constructors allow a constructor to be defined directly in the class declaration, which reduces the need for repetitive code and simplifies the definition of immutable classes.

public class Person(string name, int age)

{

    public string Name { get; } = name;

    public int Age { get; } = age;

}

In this example, the `Person` class has a primary constructor that takes two parameters: name and age. And the Name and Age properties are initialized directly from the constructor parameters, making it cleaner and more concise.

Scala has offered a similar concept since its earliest versions. In Scala, the main constructor parameters are defined along with the class and can be used to initialize the class members directly.

class Person(val name: String, val age: Int)

Both C# 12 and Scala eliminate the need to define a separate constructor and assign the parameters to the class properties manually.

But in C#, properties are assigned inside the class body using an explicit assignment (= name;), while in Scala, this assignment is implicit. And in Scala, you can control the visibility of constructor parameters (val or var) more directly. In C#, the default pattern is to create immutable properties with get; only.

Scala, being a more functional programming oriented language, offers features such as eliminating the need for {} braces for simple class bodies, while C# remains more verbose in its syntax.

In conclusion, the addition of Primary Constructors in C# 12 is a step in the right direction, making the language more expressive and less verbose, approaching the simplicity that Scala has offered for years. This parallel not only demonstrates the influence of functional languages on more traditional languages like C#, but also highlights the trend toward more concise, declarative programming.

And with each passing day I see C# becoming more like Scala ...