Versiones de C#: qué se esconde detrás de los números y cómo funciona

Versiones de C#: qué se esconde detrás de los números y cómo funciona bajo el capó

Si alguna vez ha mirado las discusiones en Stack Overflow, seguramente habrá visto la pregunta que ha acumulado miles de visitas: "What are the correct version numbers for C#?". Parecería sencillo: abres la documentación y listo. Pero en realidad, todo resulta más confuso. Especialmente cuando descubres que C# 7.0 sale con .NET Framework 4.7, y C# 8.0 ya con .NET Core 3.0. ¿Y por qué C# 5.0 no está vinculado a ninguna versión específica de .NET? Bienvenido al mundo donde los números engañan.

En este artículo no solo enumeraremos las versiones. Echaremos un vistazo bajo el capó del compilador Roslyn, entenderemos cómo los números de versión se relacionan con las plataformas y mostraremos con ejemplos de código real qué características aparecieron en cada versión. ¡Allá vamos!

¿Por qué es tan popular la pregunta sobre las versiones de C#?

La respuesta es simple: confusión entre las versiones del lenguaje C# y las versiones de .NET. Muchos desarrolladores piensan que C# 7.0 es lo mismo que .NET Framework 4.7. Pero no es así. El lenguaje C# vive su propia vida, y la plataforma .NET, la suya. El compilador Roslyn (también conocido como csc.exe) es el puente entre ambos. Toma el código en C# y lo convierte en código IL (Intermediate Language), que luego ejecuta el CLR (Common Language Runtime).

Aquí está el punto clave: una misma versión del compilador puede soportar diferentes versiones del lenguaje. Por ejemplo, el compilador de Visual Studio 2019 puede compilar código C# 7.0, 7.1, 7.2, 7.3, 8.0 — dependiendo de la configuración del proyecto. Es por eso que hay tanta confusión en Stack Overflow.

Breve historia de las versiones de C#

Repasemos los hitos principales. No enumeraré las 12 versiones una por una; mejor destacaré aquellas que realmente cambiaron el juego.

C# 1.0 (2002) — El comienzo

La primera versión del lenguaje salió junto con .NET Framework 1.0. Era un lenguaje administrado con sintaxis similar a Java, pero con características únicas como propiedades (properties) e indexadores. Nada de LINQ, async/await ni generics. Simple, confiable, aburrido.

C# 2.0 (2005) — Los generics lo cambian todo

Con esta versión llegaron los genéricos (generics), métodos anónimos, iteradores (yield return) y clases parciales. Fue un gran avance: en lugar de escribir ArrayList con boxing/unboxing, podías usar List<T>. El rendimiento se disparó.

// C# 2.0 — generics\nList<int> numbers = new List<int> { 1, 2, 3 };\nnumbers.ForEach(n => Console.WriteLine(n * 2)); // Método anónimo\n

C# 3.0 (2007) — LINQ y lambdas

La versión más revolucionaria. LINQ (Language Integrated Query) cambió el enfoque para trabajar con datos. Expresiones lambda, métodos de extensión, tipos anónimos, inicializadores de objetos — todo apareció aquí. El compilador Roslyn aún no había nacido, pero fue en C# 3.0 donde se sentaron las bases para el futuro.

// C# 3.0 — LINQ y lambdas\nvar evenNumbers = Enumerable.Range(1, 10)\n    .Where(x => x % 2 == 0)\n    .Select(x => x * x);\nConsole.WriteLine(string.Join(", ", evenNumbers)); // 4, 16, 36, 64, 100\n

C# 5.0 (2012) — Async/await

La programación asíncrona se volvió más simple que nunca. async y await no son solo azúcar sintáctico. El compilador genera una compleja máquina de estados que gestiona los hilos. Si escribes en C# 5.0 o superior, puedes olvidarte de la gestión manual de BeginInvoke y EndInvoke.

// C# 5.0 — async/await\nasync Task<string> FetchDataAsync(string url)\n{\n    using (var client = new HttpClient())\n    {\n        return await client.GetStringAsync(url);\n    }\n}\n

C# 6.0 (2015) — Azúcar para el día a día

Esta versión no trajo nuevos paradigmas, pero hizo el código más limpio: string interpolation