Versions C# : ce qui se cache derrière les chiffres et comment cela fonctionne

Versions C# : ce qui se cache derrière les chiffres et comment cela fonctionne sous le capot

Si vous avez déjà jeté un œil aux discussions sur Stack Overflow, vous avez sûrement vu la question qui a rassemblé des milliers de vues : "What are the correct version numbers for C#?". On pourrait penser que c'est simple : il suffit d'ouvrir la documentation et le tour est joué. Mais en réalité, c'est plus compliqué que cela. Surtout quand on découvre que C# 7.0 sort avec .NET Framework 4.7, et que C# 8.0 sort déjà avec .NET Core 3.0. Et pourquoi C# 5.0 n'est-il lié à aucune version spécifique de .NET ? Bienvenue dans un monde où les chiffres sont trompeurs.

Dans cet article, nous ne nous contenterons pas de lister les versions. Nous allons jeter un coup d'œil sous le capot du compilateur Roslyn, comprendre comment les numéros de version sont liés aux plateformes, et montrer avec des exemples de code réels quelles fonctionnalités sont apparues dans chaque version. C'est parti !

Pourquoi la question sur les versions C# est-elle si populaire ?

La réponse est simple : la confusion entre les versions du langage C# et les versions de .NET. De nombreux développeurs pensent que C# 7.0 est la même chose que .NET Framework 4.7. Mais ce n'est pas le cas. Le langage C# vit sa propre vie, et la plateforme .NET vit la sienne. Le compilateur Roslyn (alias csc.exe) est le pont entre les deux. Il prend le code C# et le transforme en code IL (Intermediate Language), qui est ensuite exécuté par le CLR (Common Language Runtime).

Voici le point clé : une même version du compilateur peut prendre en charge différentes versions du langage. Par exemple, le compilateur de Visual Studio 2019 peut compiler du code C# 7.0, 7.1, 7.2, 7.3, 8.0 — en fonction des paramètres du projet. C'est précisément pour cela qu'il y a tant de confusion sur Stack Overflow.

Bref historique des versions C#

Parcourons rapidement les principales étapes. Je ne vais pas énumérer les 12 versions les unes après les autres — je vais plutôt mettre en avant celles qui ont vraiment changé la donne.

C# 1.0 (2002) — Le début

La première version du langage est sortie avec .NET Framework 1.0. C'était un langage managé avec une syntaxe similaire à Java, mais avec des fonctionnalités uniques comme les propriétés (properties) et les indexeurs. Pas de LINQ, async/await ou generics. Simple, fiable, ennuyeux.

C# 2.0 (2005) — Les generics changent tout

Avec cette version sont arrivés les generics, les méthodes anonymes, les itérateurs (yield return) et les classes partielles. Ce fut une percée : au lieu d'écrire ArrayList avec boxing/unboxing, vous pouviez utiliser List<T>. Les performances ont grimpé en flèche.

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

C# 3.0 (2007) — LINQ et lambdas

La version la plus révolutionnaire. LINQ (Language Integrated Query) a changé l'approche du traitement des données. Les expressions lambda, les méthodes d'extension, les types anonymes, les initialiseurs d'objets — tout cela est apparu ici. Le compilateur Roslyn n'était pas encore né, mais c'est dans C# 3.0 que les bases de l'avenir ont été posées.

// C# 3.0 — LINQ et 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 programmation asynchrone est devenue plus simple que jamais. async et await ne sont pas qu'un sucre syntaxique. Le compilateur génère une machine à états complexe qui gère les threads. Si vous écrivez en C# 5.0 et versions ultérieures, vous pouvez oublier la gestion manuelle de BeginInvoke et 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) — Du sucre pour le quotidien

Cette version n'a pas apporté de nouveaux paradigmes, mais a rendu le code plus propre : string interpolation