Introduction à l’environnement .net

Ce chapitre donne les grandes lignes de la Plateforme .net (prononcé dot net).

Plateforme .net

La plateforme .net regroupe deux choses (à l’instar de Java) :

• un environnement d’exécution appelé Common Langage Runtime (CLR);

• le Framework .net : une bibliothèque de classes riches ou Application Programming Interface (API).

.net permet de créer des applications exécutables, des libraires (dll), des applications web (ASP.net), des scripts.

Il existe plusieurs implémentations du framework .net:

• Microsoft .net: l’implémentation officielle et historique, disponible sous Windows (bureau, console xbox, téléphone);

• Mono: implémentation libre initiallement développée par la société Xamarin pour pouvoir développer des applications mobiles multiplateformes (Android, Ios, Windows Phone). Aujourd’hui Mono est également utilisé comme plateforme de scripting, par exemple dans Unity 3D.

• .net Core: récemment proposé par Microsoft afin de cibler les plateformes Unix, en particulier les serveurs.

Attention

Mono et .net Core n’implémentent pas l’intégralité de l’API .net. Par exemple .net Core, qui est destiné au développement de services Web tournant sur des serveurs, ne propose pas d’interface graphique.

Il existe différents langages (C#, VB.net, F#, C++) dans l’environnement .net qui peuvent cohabiter au sein d’un même projet grâce au Common Language Infrastructure (CLI) qui spécifie la base commune pour les langages .net. En particulier, le CLI repose sur un système de types de données communs, le Common Type System (CTS) qui définit des types primitifs et un schéma de construction de nouveaux types. Ainsi un nouveau type de données déclaré, par exemple en C#, sera utilisable dans les autres langages de .net.

Rôles du CLR

Le CLR remplit trois fonctions principales:

• il permet l’exécution des programme .net sur la machine cible;

• il assure la sécurité de la machine cible;

• il gère la mémoire.

Exécution des programmes

Les programmes écrits sous .net sont compilés (traduit en langage bas niveau) dans le langage Common Intermediate Langage (CIL) qui est indépendant du matériel (le CIL est similaire aux Bytecodes de l’environnement Java, et ressemble à de l’assembleur objet).

Le CLR se charge de compiler le code CIL en langage machine au moment de l’exécution : on parle de Just In Time (JIT) compiler.

Schéma de compilation pour le Common Language Infrastructure (source: wikipedia)

Sécurité

Le CLR est responsable de la sécurité: il s’assure que le programme exécuté ne peut pas avoir de comportement dangereux pour lui même, pour la machine, ou pour les données des utilisateurs. Ce contrôle passe par la vérification :

• de l’intégrité des instructions exécutées : l’instruction mène-t-elle à un comportement indéfini ? (par exemple accéder à la 8ème case d’un tableau n’en contenant que 7);

• de règles de sécurité : l’application a-t-elle le droit de réaliser cette action ? (par exemple l’application a-t-elle le droit d’accéder à l’imprimante).

Gestion de la mémoire

Lorsque le CLR exécute du code en mode managé, il s’occupe de la gestion de la mémoire : réservation et libération automatique par le ramasse-miettes (plus de détails ci-après).

Bibliothèque de classes .net

La bibliothèque .net couvre de nombreux domaines : GUI, collections, réseau, sécurité, base de données, LINQ (langage de requêtage), Web, thread…

Les classes de la bibliothèque sont organisées dans des espaces de noms, ou namespace (équivalent des packages java). On peut notamment citer System.IO pour les entrées/sorties, System.Drawing pour le dessin, System.Windows.Form pour la gestion des fenêtres, System.Text pour le traitement des chaines de caractères…

Pour accéder aux ressources d’une librairie, il faut donner le chemin complet dans la hiérarchie des espaces de noms :

System.Console.Write("Hi");

Pour alléger le code, on utilise le mot clef using permettant d’accéder directement à un niveau de la hiérarchie :

using System;
Console.Write("Hi");

Gestion de la mémoire

Le CLR dispose d’un ramasse-miettes (garbage collector) qui se charge de détecter automatiquement la mémoire qui n’est plus utilisée et de la libérer.

.net différencie 2 types de code:

• le code managé dont la mémoire est gérée par le ramasse-miettes : cela concerne probablement tout le code que vous écrirez;

• le code non managé dont la mémoire n’est pas gérée par le ramasse-miettes : vous devrez probablement interagir avec du code non managé.

Le code non managé est constitué des bibliothèques non .net que vous allez utiliser et des ressources systèmes (un handle sur un fichier, une imprimante, un socket…). Les objets qui contiennent des ressources non managées proposent tous une méthode Dispose ou Close qui entraine la libération des ressources. En particulier, toutes les applications de type WinForm s’appuient sur l’API historique Win32 qui n’est pas managée : la plupart des composants WinForm reposent sur du code non managé et il appartient au développeur d’indiquer au CLR qu’il n’a plus besoin des objets créés.

Danger

Si un développeur oublie d’indiquer (ou indique trop tôt) au système qu’un objet non managé n’est plus utilisé, cela entrainera:

• une fuite mémoire (l’espace alloué n’est jamais rendu et la mémoire de la machine peut finir par être saturée); et

• un comportement indéterminé du programme (par exemple le système ne garantit pas les opérations d’écriture dans un fichier si ce dernier n’est pas fermé correctement par le développeur).

Le ramasse miette est un composant quasi autonome du CLR (le développeur n’a presque aucun contrôle dessus). Il peut a tout moment décider de procéder à la détection de la mémoire non utilisée et optimiser son utilisation.

Bien que la technologie des ramasse-miettes ait énormément progressé, ces derniers comportent toujours une phase dite stop the world durant laquelle l’application est complètement arrêtée (en dehors du ramasse-miettes). Cela peut rendre cette technologie incompatible avec les applications temps réelles les plus demandeuses en ressources, comme les jeux vidéos.

L’environnement Visual Studio

Visual Studio est l’Environnement de Développement Intégré (IDE) édité par Microsoft qui offre un support étendu pour les applications .net. Visual Studio est un environnement comprenant, entre autre, un éditeur de code (avec l’outil de complétion de code et de refactoring Intellisens), un débogueur, un profileur (mesure des temps d’exécution, de l’utilsation mémoire), l’interface avec les outils de gestion de source et de cycle de vie logiciel (team foundation server, git, svn), un éditeur de GUI interactif, des outils de modélisation UML et base de données, des outils de déploiement…

L’élément de base dans Visual Studio est la solution (matérialisée par un fichier d’extension .sln). Une solution peut contenir plusieurs projets en interaction et écrits dans des langages différents avec des cibles différentes (exe, dll…). Un projet C# est matérialisé par un fichier d’extension .csproj (descriptions XML du projet) et de fichiers d’extension .cs (fichiers contenant le code source en c#).

Lors de la création d’un projet C# avec GUI on doit choisir le type de GUI:

• console: application s’exécutant en mode texte dans un terminal;

• Windows Form (Win32): application graphique avec GUI type Win XP;

• Windows Presentation Foundation (WPF): application graphique avec GUI type Office 2010;

• Windows Universelle (UWP): application graphique avec GUI type Windows Store.

Le sous ensemble de l’API .net auquel vous avez accès dépend du type d’application choisi.

Exercices

Donnez la signification des acronymes suivants :

Acronymes	Signification
CLI
CLR
CTS
CIL
JIT
API

Pour chacune de ces affirmations, indiquez si elle est vraie ou fausse :

1. La compilation de code C# produit un fichier directement exécutable par la machine.

2. Toutes les applications se conformant au CLI peuvent être exécutées sur l’ensemble des plateformes supportant .net (Microsoft .net, .net Core, Mono).

3. Le CLR exécute du code en langage CIL.

Pour chacune de ces affirmations, indiquez si elle est vraie ou fausse:

1. Le CLR propose un ramasse-miette pour détruire automatiquement les objets qui ne peuvent plus être utilisés.

2. Le CLR élimine le problème des fuites de mémoires.

3. La gestion de la mémoire est à la charge unique du développeur.

4. Le CLR appelle automatiquement la méthode Dispose (si elle existe) lors de la destruction d’un objet.

Nous allons maintenant créer notre premier projet sous Visual Studio et examiner sa structure.

1. Lancez Visual Studio (le premier démarrage peut être un peu long car le système va créer un nouveau profil).

2. Ouvrez le paneau nouveau projet: Menu « Fichier->Nouveau->Projet… »

   

3. Sélectionnez le type de projet Application console (.NET framework) en langage C#

   

4. Donnez le nom HellowWorld à votre projet. Notez l’emplacement de sauvegarde de votre projet.

   

5. Finalement cliquez sur OK. Vous obtenez la fenêtre ci-dessous:

   

   On y retrouve:

   • L’explorateur de solution qui liste tous les projets présents dans la solution, les fichiers de chaque projet et leurs propriétés. On peut remarquer que Visual Studio a automatiquement créé un fichier « Program.cs ».

   • Une fenêtre d’édition de code avec le fichier « Program.cs » ouvert et qui contient déjà quelques lignes de code (à ce stade ce n’est pas grave de ne pas comprendre son contenu).

6. Ajoutez les 2 lignes suivantes dans la méthode Main:

   Console.WriteLine("Hello World !");
   Console.Read();
   

   

7. Exécutez le programme en cliquant simplement sur le bouton Démarrer:

   

8. Une fenêtre console s’ouvre contenant le texte Hello World !. Cette fenêtre se fermera si vous cliquez sur une touche du clavier. Vous pouvez également remarquer le nouveau paneau Sortie dans l’interface de Visual Studio qui permet d’afficher les informations de compilation et de débogage.

9. Maintenant, ouvrez l’explorateur de fichier et allez dans le dossier contenant votre projet (par défaut dans Mes documentsVisual Studio XXXXProjectsHelloWorld). Vous devriez avoir la structure de répertoire suivante:

   

10. Cherchez l’emplacement des fichiers HelloWorld.exe, HelloWorld.sln, HelloWorld.csproj et Program.cs.

11. Ouvrez le fichier HelloWorld.sln dans un éditeur de texte et cherchez y la référence vers le fichier HelloWorlds.csproj.

12. Ouvrez le fichier HelloWorld.csproj dans un éditeur de texte et cherchez y la référence vers le fichier Program.cs.

Note

En mode d’opération normal vous n’avez pas à éditer les fichiers de configuration à la main tout se fait à travers Visual Studio. Néanmoins le fait que ces derniers soient de simple fichier texte permet de les réparer si jamais un problème survient.