Support de cours
Architecture des SI I
Chapitre 1
Introduction
SOMMAIRE
Framework .NET..............................................................................................................................3
Compilation ............................................................................................................................4
Implémentations .....................................................................................................................5
Outil de développement ..................................................................................................................7
SDK ........................................................................................................................................7
VS2022 ...................................................................................................................................8
Modules VS à installer ...........................................................................................................8
Initiation à VS .......................................................................................................................10
Architectures logicielles .................................................................................................................18
Décomposition d’une solution informatique .........................................................................19
Interactions entre parties .....................................................................................................19
Exemples..............................................................................................................................19
Références ....................................................................................................................................21
2
Framework .NET
Un Framework comme son nom l’indique est un cadre travail. C'est un ensemble d’outils : bibliothèques,
logiciels et conventions permettant le développement rapide d’applications. Le but de création d’un
Framework est d’accélérer le développement d’une solution informatique en exploitant les outils de ce
dernier. En plus un Framework permet d’unifier ce développement puisqu’il sera utilisé comme socle
commun. La création d’un Framework nécessite un certain niveau d’expertise. La taille d’un Framework
peut varier selon la problématique pour laquelle il a été créée.
Le Framework .NET est un Framework créé par Microsoft au début des années 2000. Le but de sa
création est d’unifier les méthodes de développement des solutions qui s’exécutent sur le système
d’exploitation MS Windows. Il cible plusieurs types d’applications allant du Web, au Bureau en passant
par les applications Mobile (Windows Phone). Il supporte plusieurs langages de programmation tel que
C#, VB, C++, Java...
Dans ces débuts .NET n’était disponible que pour le système d’exploitation MS Windows. Son code est
fermé. Puis à partir de l’année 2016 une réécriture de ce Framework a permet d’avoir un code Open
Source avec une disponibilité sur d’autres systèmes d’exploitation comme Linux et MacOS. C’est la
naissance du Framework .NET Core. La maintenance de ce projet est assurée principalement par .NET
Foundation (Microsoft est le principal contributeur) et dont le code est hébergé sur GitHub. Aujourd'hui
le terme .NET inclut l’implémentation standard et d’autres implémentations ciblant Android et iOS pour
construire l’écosystème .NET.
3
Compilation
Une des particularités du .NET est la possibilité de choisir son langage de programmation parmi une liste
de langages compatibles. Historiquement les outils de développement utilisés par Microsoft utilisent
plusieurs langages de programmation. Pour ne pas faire une rupture avec l’existant .NET a été proposé
en supportant les langages les plus utilisés à cette époque. Ainsi pour chaque langage populaire il y a
une version compatible .NET. On trouve par exemple [Link], C++.NET, JScript, J#. D’autres langages
très spécialisés ont été proposé comme F# et R#. Cependant un nouveau langage bien conçu a été
proposé et conseillé pour tout nouveau projet .NET, c’est le C# (CSharp). Le point commun entre cette
panoplie de langages est une spécification ouverte appelée Common Language Specification (CLS).
Le but de cette spécification est d’obliger à tout langage compatible de fournir la syntaxe nécessaire
pour implémenter les concepts clés du .NET (comme l’orienté objet, les genres de types...).
Une fois le langage est choisi et le code est implémenté, une compilation doit se faire. Chaque langage a
son propre compilateur qui vérifie la syntaxe de ce code. S’il n’y a pas d’erreurs, ce compilateur
convertit le code en un autre code appelé code Intermédiaire écrit en utilisant un langage proche de
l’assembleur sans dépendance à une plateforme ou un système d’exploitation. Ce langage s’appelle
Intermediate Language (IL). Donc IL est un langage portable par conception. Une fois qu’on a notre
sortie sous forme de code intermédiaire, un autre composant centrale du .NET prend le relais : c’est le
Common Language Runtime (CLR).
Le CLR a pour rôle d’exécuter le code IL dans un environnement cible (par exemple Windows ou Linux).
Chaque environnement d’exécution a sa propre version du CLR. Avec le CLR la portabilité est assurée,
ainsi notre code de sortie sera exécuté de la même façon (ou presque) quel que soit l’environnement
d’exécution (système d’exploitation, architecture matériel ou autre spécifique). Le CLR a d’autres rôles
comme la gestion de la mémoire, la sécurisation de l’exécution, la gestion des erreurs...
4
Il y a un composant du CLR qui s’appelle JIT dont le rôle est de convertir le code IL en code machine. Le
but est d’accélérer l’exécution même si ce dernier n’est plus portable. Le code généré par ce composant
est utilisé localement.
Implémentations
Historiquement la première implémentation du Framework .NET a été faite par Microsoft aux alentours
de 2002. Elle inclut les compilateurs, le Runtime et les bibliothèques de base, permettant de créer des
projets Bureau et Web. Cette implémentation est fonctionnellement très complète mais il y a un
inconvénient majeur si on la compare aux autres technologies ou Framework de développement. Elle
n’est disponible que pour MS Windows.
5
Une entité au nom de Xamarin a été séduit pour le potentiel du .NET et a décidé de combler ce manque.
L’implémentation faite par Microsoft n’est pas ouverte ce qui a rendu cette tache relativement difficile.
Cependant après deux ans (vers 2004), Xamarin a sorti la première version de Mono ciblant le système
d’exploitation Linux, suivit par des versions compatibles Windows et MacOS. Xamarin ne s’est pas
arrêté et a sorti des versions compatibles Android et iOS. Mono est un projet open source et
communautaire.
L’année 2016 a vu la sortie de la première version d’une nouvelle implémentation du Framework .NET,
en re-écriant plusieurs API. Cette implémentation open source et communautaire conduite par
Microsoft a permet de gagner en rapidité et en portabilité. Cette implémentation est compatible avec
les systèmes d’exploitation Windows, Linux et MacOS. Cette implémentation s’appelle .NET Core.
Depuis la version 5, cette implémentation a été nommée .NET sans la partie Core. Actuellement la
version 6 est la plus complète toute implémentation confondue.
Ces implémentations ne sont pas complètement compatibles. Cependant il est possible de coder en
ciblant un standard commun appelé .NET Standard. Donc tout code qui est compilé pour .NET Standard
est fonctionnelle sur trois implémentations.
6
Outil de développement
SDK
Comme tout Framework, .NET est distribué avec un kit de développement standard. Utilisé en général
avec la ligne de commande. Chaque implémentation a son propre SDK. En général un SDK est fourni
avec un ou plusieurs compilateurs, un ensemble de bibliothèques standard accélérant le développement
et d’autres outils de productivité. Il est ainsi possible de fournir des environnements de développement
plus ou au moins complète en se basant sur le SDK (appelés IDE : Integrated Development
Environment). Pour créer des applications .NET on peut se baser sur l’une des environnements suivants :
- VISUAL STUDIO : le plus utilisé en entreprise et la référence pour développer en .NET.
- Visual Studio Code : moins complet qu’un IDE mais plus riche qu’un simple éditeur de texte.
- MonoDevelop : IDE créé pour travailler avec Mono.
- Xamarin Studio : IDE riche créé par la société Xamarin.
- OmniSharp
- JetBrains Rider
7
VS2022
VISUAL STUDIO ou plus simplement VS est l’IDE proposé par Microsoft pour développer des
applications .NET (.NET Classique, .NET Standard ou .NET Core). Il intègre un éditeur de code, plusieurs
compilateurs, un débogueur et différents outils pour faciliter le travail du développeur. C’est
l’environnement le plus complet et il permet de créer tous genres d’applications (applications Bureau,
applications Web, applications Mobiles, Jeux ...). Cependant il n’est disponible que pour le système
d’exploitation Windows. Pour les autres systèmes d’exploitation il existe MonoDevelop, Xamarin Studio
ou VS Code (tous compatibles avec les trois systèmes d’exploitation Windows, Linux et MacOS).
SharpDevelop est un autre IDE mais n’est disponible que pour Windows.
Il existe plusieurs versions de cet environnement la dernière en production est la version de 2022. Le
produit est commercialisé de différentes façons, il y a des versions payantes et d’autres non. La version
communauté est gratuite sous certaines conditions, les autres sont payantes (il faut une licence
d’utilisation). Voici le lien pour les téléchargements. Et pour La version communauté.
Modules VS à installer
Visual Studio est un logiciel modulaire, à l’installation il est possible de choisir les modules et
composants à installer selon les besoins. Pour développer avec le Framework .NET, on a besoin
d’installer les modules :
- Développement Web et [Link]
- Développement .NET Desktop
- Stockage et traitement des données
- Module linguistique Français et selon besoin l’Anglais
8
9
Il est possible d’ajouter ou supprimer des modules ou composants même après l’installation. Il suffit de
relancer l’outil d’installation et de cliquer sur modifier.
Initiation à VS
Dans Visual Studio, la solution est utilisée pour grouper des projets.
Le projet est l’élément central dans VS, il existe plusieurs types. Plusieurs critères tel que le langage, le
genre d’application, fixent le type de projet. Les projets dont l’extension est csproj sont les projets pour
le langage C#, vbproj pour les langages Visual Basic. Une solution peut avoir des projets de types
différents. Voici comment créer un projet et une solution sous VS 2022 :
Etapes de création d’un projet
1- Lancez Visual Studio 2022
10
2- Cliquez sur « Créer un projet » dans la partie « Démarrer »
Notez qu’il est possible de démarrer l’environnement sans la création d’un projet.
3- Choisissez le langage, la plateforme et le type de projet, puis cliquez sur « Suivant »
11
4- Donnez un nom au projet et la nouvelle solution associée
5- Choisissez la version du Framework cible
12
Le projet créé contient le squelette d’une application Console. A droite vous trouvez l’explorateur des
solutions
Un clic droit sur la solution permet de créer d’autres projets. Ces projets seront automatiquement
ajoutés à la solution
Le projet en gras est considéré comme projet de démarrage
13
Lors du lancement de la solution, c’est le projet de démarrage sui sera lancé.
Un clic droit sur un projet permet de consulter ses propriétés
Un projet utilise un ensemble de dépendances pour compiler ses sources. Il est possible d’ajouter des
dépendances de tout genre. La plus simple des dépendances est celle entre projets. Un clic droit sur la
partie « Dépendances » permet d’ajouter ce type de dépendance
14
Pour compiler un projet il est possible de le faire pour le projet en question en faisant un clic droit sur ce
projet ou bien compiler toute la solution
Le raccourci Ctrl+Maj+B permet de lancer cette compilation
La compilation d’un projet sauvegarde automatiquement tous les fichiers non encore sauvegardés.
A la fin de la compilation et au niveau du dossier de sortie une liste de fichier sera créée. L’extension et
le nombre de fichiers générés dépendent du type de projet voici le cas d’un projet Console
15
Le fichier qui porte l’extension dll est appelé dans le jargon .NET un assembly.
Une fois les projets sont compilés, il est possible de lancer le projet de démarrage avec ou sans
débogage
Il existe deux raccourcis F5 ou Ctrl+F5 pour ces deux actions. Le lancement à partir de l’icône au niveau
de la barre des outils permet de lancer plus facilement le projet en mode débogage
Le lancement d’un projet ou de la solution permet de déclencher automatiquement la compilation.
Le lancement d’un projet en mode débogage permet de mieux comprendre son fonctionnement et
surtout comprendre rapidement les sources d’une anomalie s’il y en a. En général avant de déboguer il
16
faut un point d’arrêt, pour la créer il suffit au niveau de l’éditeur du code source faire un clic sur la ligne
concernée
Une fois le projet est lancé et le point d’arrêt est atteint, l’exécution s’arrête et il est possible d’inspecter
les différentes variables
Un survol avec la souris sur une variable permet de l’inspecter plus facilement
Le raccourci F10 permet d’exécuter le code ligne par ligne.
On note que Visual Studio intègre une aide à l’édition très puissante. Cette aide appelée aussi
IntelliSence se déclenche automatiquement lors de l’édition. Il est possible de la forcer avec le raccourci
Ctrl+Space
17
Il est possible de formater un document via le menu Edition >> Avancée >> Mettre le document en
forme.
Architectures logicielles
D’une façon générale l’architecture d’un système est une description schématisée des différentes
parties de ce système et les interactions entre elles. L’architecture d’une solution informatique est par
conséquence une description des différentes parties logiciels et non logiciels (soft et hard) de cette
solution. C’est le squelette de la solution. Le but de cette description est d’avoir une vision globale de la
structure de la solution sans entrer dans les détails. Ainsi il est facile d’estimer la qualité attendue de
cette solution et identifier les risques.
Dans une architecture il y a un travail de partitionnement ou décomposition et un travail d’identification
des interactions entre ces différentes parties. Une architecture peut contenir plusieurs schémas selon
différents objectifs.
18
Décomposition d’une solution informatique
Le premier travail pour définir une architecture est d’identifier les différentes parties. L’opération est
appelée décomposition. Une décomposition peut tenir compte des responsabilités. Elle peut être
logique comme physique. Il est rare d’avoir une décomposition hybride. Parmi les décompositions
physiques on a les architectures n-tiers et parmi les décompositions logiques on a les architectures n-
couches.
Interactions entre parties
Une fois les parties ont été identifiées, une architecture doit schématiser les interactions entre ces
parties. Plus on a de parties plus on a d’interactions et donc plus la solution se complexifie (exactement
n*(n-1)/2 où n est le nombre de parties). Il est important dans une architecture de réduire ce nombre
d’interactions. En général on fixe des contraintes sur ces interactions. On peut par exemple exiger que
seules interactions entre les parties adjacents soient possibles.
Exemples
Ici on a une architecture de type n-tiers ou n est égale à 4. La décomposition est physique et
l’interaction ne se fait qu’entre les tiers adjacents. Ce type d’architecture réduit considérable la
complexité de la solution. Cependant on est limité au niveau des interactions et parfois on aimerait
s’affranchir de cette limitation même partielle.
19
Ici on a une architecture de type n-couches ou n est égale à 3. La décomposition est logique et
l’interaction ne se fait qu’entre les couches adjacentes. Comme l’architecture n-tiers, ce type
d’architecture réduit considérable la complexité de la solution. Cependant on est aussi limité au niveau
des interactions et parfois on aimerait s’affranchir de cette limitation même partielle.
Ici on a une architecture MVC où la décomposition est logique. Vu que le nombre de parties est réduit à
3, les interactions sont limitées. Ce type d’architecture est très limité au niveau du nombre de parties.
On aimerait avec plus de parties.
20
Ici on a une architecture oignon où la décomposition est logique. Le nombre de partie est relativement
plus important. Toute partie sur le périphérique peut interagir avec le les parties du noyau (Core). Les
parties du noyau s’organisent en couches (interaction entre les couches adjacents). Cette architecture
conserve le meilleur des autres architectures (non limités en nombre mais avec des contraintes sur les
interactions).
Références
[Link]
[Link]
[Link]
[Link]
21
