Microsoft .NET
| Image manquante Symbole-ordinateur.png | Cet article est une ébauche concernant l'informatique, vous pouvez partager vos connaissances en le modifiant. |
.NET correspond à un ensemble Microsoft qui comporte un framework, des langages de développement, des spécifications techniques et des systèmes (Systèmes d'exploitation, Logiciels serveurs...)
Les langages disponibles sont le C# (mélange de C++ et de Java), le J# (équivalent du Java), le Vb.Net (Visual Basic .Net). Mais chacun est libre, grâce aux spécifications techniques, d'ajouter son propre langage, ou un langage ancien (Cobol, Pascal, Fortran....)
Microsoft a aussi développé une version allégée du framework pour faciliter le développement d'application pour son système d'exploitation pour assitants personnels : le .NET compact framework.
Il existe aussi une implémentation libre:Mono.
| Sommaire |
Le Framework .NET
Le framework .NET est un composant installable sur les systèmes d'exploitation Microsoft Windows. Il sert de base au nouveau système Windows Longhorn dont la sortie est prévue au cours de l'année 2006. Il a pour but de faciliter la tâche des développeurs en proposant une approche unifiée à la conception d'applications Windows ou Web, tout en introduisant des facilités pour le développement, le déploiement et la maintenance d'applications. Le framework gère tous les aspects de l'exécution de l'application: il alloue la mémoire pour le stockage des données et des instructions du programme, il autorise ou interdit les droits de l'application, il démarre et gère l'exécution, et il gère la ré-allocation de la mémoire pour les ressources qui ne sont plus utilisées. C'est pour cela que le framework .NET est qualifié d'environnement « managé ». Il est composé de deux blocs principaux: le CLR et la librairie de classes .NET.
CLR - Common Language Runtime
Le CLR est à .NET ce que la JVM est à Java, c’est-à-dire une machine virtuelle, sans laquelle l'exécution de code .NET ne serait pas possible. À l'inverse de son concurrent, le framework .NET a été conçu pour permettre l'interopérabilité entre différents langages.
Quel que soit le langage utilisé pour écrire une application .NET, le code doit être transformé en MSIL (Microsoft Intermediate Language). Ce code intermédiaire ne comporte aucune instruction relative au hardware ou au système d'exploitation. Il ne peut donc pas être exécuté directement. Malgré cela, on pourrait tout à fait imaginer écrire directement une application en IL, langage qui ressemble à l'assembleur, sans passer par un langage de dernière génération comme le C#.
Le CLR est nécessaire pour exécuter le code intermédiare. Il est basé sur le CTS (Common Type System) et CLS (Common Language Specification) et apporte de nombreuses fonctionnalités comme le Garbage Collector (la mémoire utilisée par l'application lors de l'exécution est optimisée), la BLC (Base Class Library), et le système de sécurité. Une fois le code présent dans le CLR, il va enfin pouvoir être compilé par le JIT Compiler (Just in Time) en langage natif de la machine. Il existe trois types de JIT:
- Pre-JIT: le code entier est directement compilé.
- Econo-JIT: le code est compilé par parties, et la mémoire libérée si nécessaire.
- Normal-JIT: le code n'est compilé que quand c'est nécessaire, mais est ensuite placé en cache pour pouvoir être réutilisé.
Quelque soit le type de JIT, le but est d'accélèrer l'exécution du code en réutilisant dès que possible le cache. Pour voir ceci visuellement, c'est très simple, il suffit d'écrire une simple application ASP.NET (Hello World par exemple). À la première exécution, le code est compilé, mais après, tant qu'il ne subit pas de modifications c'est le cache qui est utilisé, d'où une vitesse d'exécution bien plus rapide que la première fois.
Le JIT fourni par Microsoft ne produit évidemment que du code natif Windows, mais les spécifications étant disponibles, il s'est trouvé un groupe de personnes très motivées ayant décidé de porter .NET sur Linux: le projet Mono.
Librairie de classes .NET
Il y a trois couches au dessus du CLR, chacune comportant des classes apportant des fonctionnalités de plus en plus évoluées.
Base Class Library
Dans la première couche se trouve la BCL, rassemblant des classes permettant les manipulations de chaînes de texte, la gestion des entrées/sorties, des communications réseaux, des threads et le design des interfaces utilisateur. Ces classes sont similaires à celles présentes dans l'API Java développée par Sun. Par exemple, la manipulation des chaînes est disponible dans la classe String, dans les deux langages; la différence étant qu'en Java il n'existe pas de type de base pour manipuler les chaînes (on manipule des objets 'String'), alors qu'en .NET, le type string (avec un 's' minuscule) a spécifiquement été défini.
Data and XML Classes
La deuxième couche est composée de deux librairies de classes d'accès aux données. Tout d'abord, ADO.NET, s'élevant sur les bases de l'ancien ADO (ActiveX Data Objects) utilisé par les développeurs ASP, et permettant l'accès sous format XML aux interfaces de bases de données SQL Server, ODBC, OLE DB, Oracle et Sybase, et bien sûr aux fichiers XML. Les XML Classes permettent de manipuler les données XML. On y trouve par exemple les classes XSLT permettant la transformation d'un document XML vers n'importe quel type d'autre document. Un autre exemple, il est très facile de charger un document XML dans une table, et vice versa, grâce au XML sous-jacent.
XML Web Services, Web Forms, Windows Forms
La dernière couche, la plus élevée, est utilisée pour la création de Web Services, de pages Web, et d'applications Windows. Les deux premiers forment ASP.NET, là aussi une référence à l'ancien langage de programmation Web. Lorsque vous visitez des sites Internet, vous pouvez remarquer les pages se terminant par .aspx qui sont des pages Web écrites en .NET, tandis que les pages écrites en ASP se terminent en .asp (pour s'amuser on peut très bien modifier les configurations du serveur IIS de Microsoft pour modifier l'extension des fichiers ASP.NET alors ce n'est pas une généralité).
Structure d'une application .NET
L'unité de base d'une application .NET est appelée une assemblée (assembly). Il s'agit d'un ensemble de code, de ressources et de metadata. Une assemblée est toujours accompagnée par un manifeste (assembly manifest) qui décrit ce qu'elle contient: nom, version, types de données exposées, autres assemblées utilisées, instructions de sécurité. Une assemblée est composée de un ou plusieurs modules qui contiennent le code.
Compilation et exécution d'une application .NET
Quand une application .NET est compilée, elle n'est pas compilée en code binaire machine, mais en MSIL. Une application consiste donc en un ensemble d'assemblées contenus dans un ou plusieurs fichiers exécutables ou fichiers DLL en MSIL. Au moins une de ces assemblées doit contenir un point d'entrée afin de démarrer l'application.
Quand l'exécution d'un programme démarre, la première assemblée est chargée en mémoire. Le CLR commence par examiner les permissions demandées par cette assemblée et les compare à la politique de sécurité (security policy) du système. Puis, si l'assemblée est autorisée à s'exécuter, un processus est créé pour exécuter l'application. Le premier morceau de code nécessaire à l'exécution est chargé en mémoire et est compilé en code binaire natif par le compilateur JIT. Une fois compilé, le code est exécuté et stocké en mémoire sous forme de code natif, garantissant ainsi que chaque portion de code n'est compilée qu'une seule fois lors de l'exécution de l'application.
Outils de développement pour .NET
De nombreux outils de développement et bibliothèques existent pour .NET (En)
| Image manquante Symbole-ordinateur.png | Portail Informatique - Accédez d'un seul coup d’œil à toute la série des articles de Wikipédia concernant l'informatique. |