Pourquoi .NET Core ?

Les différents composants de .NET Core

Afin de bien comprendre pourquoi .NET Core a été créé, il est important d’analyser et de comprendre chaque morceau dans ce framework. En effet, chacun a une place bien précise dans l’architecture de ce dernier : runtime, librairie de classe, outils... Comprendre les dépendances entre eux permet de comprendre en quoi ce framework est si modulable et puissant.

La modularité prend une place prépondérante avec .NET Core, car ce doit être un framework qui fonctionne sur un très grand nombre de plateformes : mobile, desktop et tablette avec UWP, Web et cloud avec ASP.NET, IoT avec Windows 10 IoT Core. Selon le runtime, le framework doit d’adapter afin d’utiliser uniquement les librairies qui l’intéressent, c’est pourquoi la grande majorité de ces dernières sont déployées via des paquets NuGet, optimisant la gestion des versions, la centralisation des paquets et la diffusion du code.

Ce chapitre est l’occasion de faire le tour des différentes briques logicielles de .NET Core : le runtime, les librairies, les outils... et voir comment ces composants font de .NET Core un framework aussi puissant et multiplateforme.

1. Les librairies de CoreFX

L’appellation de CoreFX fait principalement référence à l’ensemble des classes de base disponibles sous le namespace System.* et certaines extensions de Microsoft.*. Nous les connaissons plutôt sous le nom de Base Class Library, ainsi nous pouvons dire que CoreFX est la BCL de .NET Core. L’ensemble de ces classes sert de socle solidaire et bas niveau afin que d’autres composants, tels que ASP.NET, puissent construire le framework par-dessus. La caractéristique importante de CoreFX est que la majorité des API disponibles sous .NET Core le sont également avec le framework .NET classique. On peut facilement rapprocher les deux en déclarant que CoreFX est un fork de la BCL du framework .NET.

Le rôle principal de cette BCL est de faire en sorte que les API disponibles soient exécutables...

Les points marquants du framework

Chaque technologie a le droit à ses comparaisons et ses références. Il en va de même pour .NET Core, que l’on compare souvent à d’autres technologies comme NodeJS ou PHP. La concurrence n’est pas forcément une mauvaise chose. Cela permet tout d’abord de satisfaire chaque tendance chez les développeurs, mais aussi de challenger les équipes afin d’offrir les meilleurs outils possible.

Les performances ont souvent été citées dans les comparatifs et les tests, notamment parce que Microsoft a beaucoup communiqué dessus, mettant en avant les gains significatifs par rapport à l’ancienne version et les concurrents. Ainsi, de nombreux grands acteurs de l’informatique ont adopté .NET Core pour la robustesse et la maturité affichées ces dernières années, reconnaissant ainsi un vrai travail de fond opéré sur le framework.

1. Les tests de performances

La performance est réellement une caractéristique que Microsoft a voulu mettre au cœur du framework. Pour le prouver, il est possible d’écrire des tests de performances très simplement, car les équipes ont conçu un mini framework de benchmark basé sur xUnit. Ce dernier permet de cibler le code à vérifier via un système d’itération que le framework va exécuter et contrôler pendant toute la durée du test. Le projet est open source : https://github.com/Microsoft/xunit-performance/

Le minimum de code requis pour faire un test de performance est le suivant :

[Benchmark]  
void TestMethod()  
{  
    // Chaque cas de test ira dans cette itération  
    foreach (var iteration in Benchmark.Iterations)  
    {  
        // Début de l'itération  
        using...

Les nouveautés de C#

Le langage C# est en constante évolution, offrant ainsi des améliorations de syntaxe tous les ans au profit des développeurs. Une syntaxe simple et efficace permet une meilleure lisibilité du code, et de facto une meilleure maintenance des logiciels. Les équipes de Microsoft travaillent constamment sur le compilateur Roslyn afin de le rendre le plus performant possible, et chaque nouvelle demande de fonctionnalité est scrupuleusement analysée pour s’assurer qu’elle correspond bien à la philosophie du langage.

Le projet Roslyn est open source (https://github.com/dotnet/roslyn) et chaque discussion sur l’amélioration du langage se trouve ici : https://github.com/dotnet/csharplang. Ainsi, la communauté fait partie intégralement du processus d’amélioration du langage, et chacun peut apporter sa contribution.

La dernière version stable et la plus répandue de C# est la 7.3. Cette partie a pour but de présenter les principales fonctionnalités du langage C# en partant de la dernière version majeure, la 7.0, jusqu’à la dernière, 7.3.

1. La version 7.0

Qui n’a jamais rêvé de renvoyer plusieurs valeurs pour une méthode sans forcément créer une classe spécifique ? Avec C# 7.0, c’est possible grâce aux tuples. Ces derniers permettent de créer des objets de type ValueTuple très facilement.

// Tuples non nommés. Les propriétés s'appellent Item1 et Item2 
var letters = ("a", "b");  
 
// Tuples nommés  
(string Alpha, string Beta) namedLetters = ("a", "b");  
var alphabetStart = (Alpha: "a", Beta: "b");

Le gain se trouve au niveau des méthodes. Il est facile de renvoyer plusieurs valeurs avec une méthode sans créer des classes particulières. La syntaxe reste très limpide et améliore la lisibilité.

private static (int Max, int Min) Range(IEnumerable<int> numbers) 
{  
    int min = int.MaxValue;  
    int max = int.MinValue;  
    foreach(var n in numbers)  
    {  
        min = (n < min) ? n : min;  
     ...