Analyse et programmation 2

Référentiel

Référentiel AP2

Table des matières

[TOC]

Avant-propos

Ce cours est une mise à jour du cours d’Analyse et Programmation 2 initialement écrit par M. Maire puis repris par M. Bel. Il reprend les mêmes concepts mais les met à jour avec les dernières technologies et les dernières spécificités du langage C#.

Compilation en ligne de commande

Souvent, lorsqu’on utilise des outils de développement tels que Visual Studio, on ne se rend pas compte de tout ce qui se passe en arrière-plan. On clique sur un bouton et hop, le programme se lance. Mais qu’est-ce qui se passe réellement ? Comment est-ce que Visual Studio sait comment compiler notre programme ? Comment sait-il où trouver les fichiers nécessaires à la compilation ? Comment sait-il où trouver les fichiers nécessaires à l’exécution de notre programme ?

Mais aussi, qu’est-ce qu’il a créé comme fichiers exécutable ? Est-ce que l’exécutable est autonome ou a-t-il besoin d’autres fichiers pour fonctionner ? Est-ce que l’exécutable est portable ? Peut-on le distribuer à quelqu’un d’autre et être sûr qu’il fonctionnera ?

Pour répondre à ces questions, nous allons voir comment compiler un programme en ligne de commande. Nous allons voir comment compiler un programme C pour commencer car il permet facilement de mettre en évidence le concept de librairie partagée. Puis nous compilerons un programme C# en ligne de commande. Nous allons voir comment compiler un programme C# pour qu’il soit autonome et portable et distribuable.

C

Commençons par du C. Le langage C est réputé pour être bas niveau. C’est-à-dire que c’est au développeur de savoir exactement ce qu’il fait. Le langage C est compilé à l’aide d’un compilateur tel que gcc.

En partant du traditionnel Hello, World!, on va voir comment compiler un programme C en ligne de commande sur Linux.

hello.c

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char** argv)
{
    puts("Hello World!\n");
    exit(0);
}

Compilation

# build-essential est un meta paquet contenant entre autre gcc
$ sudo apt install build-essential
# compilation
$ gcc hello.c -o hello
# exécution
$ ./hello
Hello World!
# voir sa taille
$ ls -lh hello

Si on jette un œil à la taille du programme, on trouve ~16kB. C’est déjà beaucoup pour un simple Hello, World!. Si on regarde le code présent dans le fichier ELF, on peut voir que le programme est lié à la librairie libc et qu’il utilise la fonction puts pour afficher le message et exit pour quitter le programme. Ces deux fonctions, même si elles sont écrites dans notre code, ne se trouvent pas dans notre fichier ELF mais dans une librairie partagée par tous les programmes, la libc.so.6.

$ readelf -d hello

Dynamic section at offset 0x2dc0 contains 27 entries:
  Tag        Type                         Name/Value
 0x0000000000000001 (NEEDED)             Shared library: [libc.so.6]

$ readelf -s hello

Symbol table '.dynsym' contains 8 entries:
   Num:    Value          Size Type    Bind   Vis      Ndx Name
     2: 0000000000000000     0 FUNC    GLOBAL DEFAULT  UND puts@GLIBC_2.2.5 (2)
     ...
     5: 0000000000000000     0 FUNC    GLOBAL DEFAULT  UND exit@GLIBC_2.2.5 (2)

$ ldd ./hello
    linux-vdso.so.1 (0x00007fff555a8000)
    libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007efc0018e000)
    /lib64/ld-linux-x86-64.so.2 (0x00007efc0038c000)

$ ls -lh /lib/x86_64-linux-gnu/libc.so.6
-rwxr-xr-x 1 root root 1.9M 23 jui 19:09 /lib/x86_64-linux-gnu/libc.so.6

La libc.so.6 contient à son tour ~1.9M de code. En résumé, pour un simple Hello, World!, on a besoin de 16K de code et 1.9M de librairie partagée.

Si on compile le programme en plaçant dans le fichier ELF tout le code nécessaire à son fonctionnement, cela donne

$ gcc -static -O3 hello.c -o hello

$ ls -lh
total 462K
-rwxrwxr-x 1 ubuntu ubuntu  17K aoû 23 14:33 hello          # 17K shared library
-rw-rw-r-- 1 ubuntu ubuntu  206 aoû 23 14:20 hello.c        # 206 source code
-rwxrwxr-x 1 ubuntu ubuntu 724K aoû 21 18:19 hello_static   # 724K static library

$ ldd ./hello_static
    not a dynamic executable

On voit que le fichier hello_static est plus gros que le fichier hello mais il contient tout le code nécessaire à son fonctionnement. Il est autonome et portable. On peut le distribuer à quelqu’un d’autre et être sûr qu’il fonctionnera.

💬 Comment le prouver, le tester ?

$ incus launch images:busybox/1.36.1 busy
$ incus list                        
+---------------+---------+------+-----------------------------------------------+-----------+-----------+
|     NAME      |  STATE  | IPV4 |                     IPV6                      |   TYPE    | SNAPSHOTS |
+---------------+---------+------+-----------------------------------------------+-----------+-----------+
| busy          | RUNNING |      | fd42:e9e4:82af:ce86:216:3eff:fea3:4784 (eth0) | CONTAINER | 0         |
+---------------+---------+------+-----------------------------------------------+-----------+-----------+
$ incus exec busy sh
~ # pwd
/root

/ # ls -l /
total 10
drwxr-xr-x    2 0        0               95 Aug 21 06:01 bin
drwxr-xr-x    7 0        0              440 Aug 21 07:55 dev
drwxr-xr-x    2 0        0                4 Aug 21 06:01 etc
lrwxrwxrwx    1 0        0               12 Aug 21 06:01 linuxrc -> /bin/busybox
drwxr-xr-x    2 0        0                2 Aug 21 06:01 mnt
dr-xr-xr-x  586 65534    65534            0 Aug 21 07:55 proc
drwxr-xr-x    2 0        0                3 Aug 21 07:57 root
drwxr-xr-x    2 0        0                2 Aug 21 06:01 run
drwxr-xr-x    2 0        0               74 Aug 21 06:01 sbin
dr-xr-xr-x   13 65534    65534            0 Aug 21 07:55 sys
drwxr-xr-x    2 0        0                2 Aug 21 06:01 tmp
drwxr-xr-x    4 0        0                4 Aug 21 06:01 usr

~ # find / -name "libc*" 2> /dev/null
/sys/kernel/btf/libcrc32c
/sys/module/libcrc32c

~ # ls -l
total 441
-rwxrwxr-x    1 1000     1000         16000 Aug 21 07:58 hello
-rwxrwxr-x    1 1000     1000        740568 Aug 21 07:59 hello_static

~ # ./hello 
sh: ./hello: not found

~ # ./hello_static
Hello World!

C# dotnet

La plupart des développeurs utilisent des IDE Integrated Development Environment pour développer en C#. Lors de l’installation d’un IDE, tel que Visual Studio, un ensemble d’outils de développement est installé pour nous. Ces outils, qui font partie de l’IDE nous permettent d’éditer facilement nos fichiers C#, de compiler notre projet, de faire du débogage et de démarrer notre exécutable grâce au compilateur, au linker, au .NET SDK et au .Net Runtime. Les .Net SDK / Runtime sont installés automatiquement lors de l’installation de Visual Studio. Dès lors, on peut facilement oublier que ces outils sont nécessaires pour faire fonctionner notre programme.

Afin de bien comprendre ce qui se passe dans Visual Studio lorsqu’on édite notre code et qu’on clique ensuite sur « Démarrer », essayons de le faire sans Visual Studio !

Nous allons créer une application Console en ligne de commande à l’aide de la commande dotnet et ainsi, mieux comprendre ce qui se passe automatiquement dans Visual Studio.

Pré-requis

Je vous propose de réaliser cette application dans un système Linux. Vous pourrez ainsi constater que le langage C# est multiplateforme. Pour faire cela, plusieurs choix s’offre à vous:

• Installer une distribution telle qu’Ubuntu ou Debian, et donc Linux, dans une machine virtuelle VMWare ou VirtualBox
• Démarre une distribution Linux présente sur un disque externe bootable
• Installer une distribution telle qu’Ubuntu ou Debian, et donc Linux, dans WSL2 (Windows Subsystem for Linux)

Pour la version WSL2, vous trouverez les indications fournies par Microsoft sur la page Install Linux on Windows with WSL ainsi qu’une distribution Ubuntu 22.04.3 LTS dans le store Windows.

Remarque: si vous avez une ancienne version de Windows ou une version managée par le service informatique, vous devrez procéder à l’installation manuel

Installation dotnet

On commence par installer le SDK. On peut le trouver à cette adresse Installation manuel.

## Téléchargement du SDK
tux@makina:~$ curl https://download.visualstudio.microsoft.com/download/pr/db901b0a-3144-4d07-b8ab-6e7a43e7a791/4d9d1b39b879ad969c6c0ceb6d052381/dotnet-sdk-8.0.401-linux-x64.tar.gz --output dotnet-sdk-8.0.401-linux-x64.tar.gz
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
 42  174M   42 74.9M    0     0  5225k      0  0:00:34  0:00:14  0:00:20 5303k

## Vérification de sa présence
tux@makina:~$ ls
dotnet-sdk-8.0.401-linux-x64.tar.gz

## Création d'une variable d'environnement (elles sont toutes temporaires à cette session)
tux@makina:~$ DOTNET_FILE=dotnet-sdk-8.0.401-linux-x64.tar.gz

## Vérification de la variable
tux@makina:~$ echo $DOTNET_FILE
dotnet-sdk-8.0.401-linux-x64.tar.gz

## Export de la variable
tux@makina:~$ export DOTNET_ROOT="$HOME/.dotnet"

## Création du dossier caché .dotnet dans HOME et décompression de l'archive à l'intérieur
tux@makina:~$ mkdir -p "$DOTNET_ROOT" && tar zxf "$DOTNET_FILE" -C "$DOTNET_ROOT"

## Mise à jour de la variable PATH
tux@makina:~$ export PATH=$PATH:$DOTNET_ROOT

## Essai
tux@makina:~$ dotnet --version
8.0.401

On a maintenant un SDK fonctionnel. On peut voir toutes les options de cette commande en utilisant le paramètre d’aide -h

tux@makina:~$ dotnet -h
Utilisation: dotnet [runtime-options] [path-to-application] [arguments]

Exécutez une application .NET.

runtime-options:
  --additionalprobingpath <path>   Chemin contenant la stratégie de collecte et les assemblys à collecter.
  --additional-deps <path>         Chemin du fichier deps.json supplémentaire.
  --depsfile                       Chemin du fichier <application>.deps.json.
  --fx-version <version>           Version du framework partagé installé à utiliser pour exécuter l'application.
  --roll-forward <setting>         Restaurer par progression la version du framework (LatestPatch, Minor, LatestMinor, Major, LatestMajor, Disable).
  --runtimeconfig                  Chemin du fichier <application>.runtimeconfig.json.

path-to-application:
  Chemin d'un fichier .dll d'application à exécuter.

Utilisation: dotnet [sdk-options] [command] [command-options] [arguments]

Exécutez une commande du kit SDK .NET.

sdk-options:
  -d|--diagnostics  Activez la sortie des diagnostics.
  -h|--help         Affichez l'aide de la ligne de commande.
  --info            Affichez les informations sur .NET.
  --list-runtimes   Affichez les runtimes installés.
  --list-sdks       Affichez les SDK installés.
  --version         Affichez la version utilisée du kit SDK .NET.

Commandes du SDK:
  add               Ajoutez un package ou une référence à un projet .NET.
  build             Générez un projet .NET.
  build-server      Interagissez avec les serveurs démarrés par une build.
  clean             Nettoyez les sorties de build d'un projet .NET.
  format            Appliquez les préférences de style à un projet ou une solution.
  help              Affichez l'aide de la ligne de commande.
  list              Listez les références de projet d'un projet .NET.
  msbuild           Exécutez des commandes MSBuild (Microsoft Build Engine).
  new               Créez un fichier ou projet .NET.
  nuget             Fournit des commandes NuGet supplémentaires.
  pack              Créez un package NuGet.
  publish           Publiez un projet .NET à des fins de déploiement.
  remove            Supprimez un package ou une référence d'un projet .NET.
  restore           Restaurez les dépendances spécifiées dans un projet .NET.
  run               Générez et exécutez une sortie de projet .NET.
  sdk               Gérer l'installation du kit SDK .NET.
  sln               Modifiez les fichiers solution Visual Studio.
  store             Stockez les assemblys spécifiés dans le magasin de packages de runtime.
  test              Exécutez des tests unitaires à l'aide du programme Test Runner spécifié dans un projet .NET.
  tool              Installez ou gérez les outils qui étendent l'expérience .NET.
  vstest            Exécutez des commandes VSTest (Microsoft Test Engine).
  workload          Gérez les charges de travail facultatives.

Commandes supplémentaires d'outils groupés :
  dev-certs         Créez et gérez des certificats de développement.
  fsi               Démarrer F# Interactive / exécuter les scripts F#.
  user-jwts         Gérer les jetons Web JSON en développement.
  user-secrets      Gérez les secrets d'utilisateur de développement.
  watch             Démarrez un observateur de fichier qui exécute une commande quand les fichiers changent.

Pour plus d'informations sur une commande, exécutez 'dotnet [commande] --help'.

C’est parti pour la création de l’application Console. Pour ce faire, on suit partiellement le tutoriel présent à cette adresse Get started with .NET.

Quelques précisions:

La liste des applications que l’on peut créer s’obtient ainsi

tux@makina:~$ dotnet new list
These templates matched your input:

Template Name                                 Short Name      Language    Tags
--------------------------------------------  --------------  ----------  --------------------------
...
Console App                                   console         [C#],F#,VB  Common/Console

Si vous travaillé sur Windows et que dotnet est installé, ce qui est normalement le cas avec Visual Studio, vous pouvez réaliser les mêmes commandes dans un terminal PowerShell

PS C:\Moi> dotnet --list-sdks
8.0.401 [C:\Program Files\dotnet\sdk]

Publication

Ce que nous avons fait jusqu’ici c’est

• Créer un projet C#
• Compiler ce projet
• Démarrer et donc exécuter le programme

On est loin de la publication de notre application sur Internet pour la distribuer au plus grand nombre… Pour y parvenir nous devons

• Créer une application en version finale, c’est-à-dire, une application qui est prévue pour aller vite et pas une application qui est prévue pour faire du débogage
• S’assurer que notre application pourra être exécutée sur la machine du client et donc, connaître les dépendances nécessaires au fonctionnement de l’application
• Être sûr que notre application est crée dans le bon format. ELF pour Linux, PE plus connu sous le nom d’EXE pour Windows

Exercice

Le but de cet exercice est très simple. On vous demande de créer un programme console simple tel qu’un Hello, World! dans une machine Linux. Une fois le programme crée, on vous demande de faire le nécessaire pour pouvoir utiliser ce programme sur une autre machine Linux. Un peu comme si une autre personne dans le monde possédant une machine Linux téléchargeait votre programme et l’exécutait sur sa machine. Vous ne savez rien de sa machine et surtout, vous ne savez pas si cette machine possède le runtime C# mais vous partez du principe qu’il aura téléchargé la bonne version du programme, c’est-à-dire, la version prévue pour sa machine.

Lorsque vous avez fait le travail, échangé votre programme avec un autre élève et tester le programme de l’autre élève sur une machine Linux vierge fraichement installée sans ajout d’un quelconque programme.

Pour aller un peu plus loin, compilez votre programme pour Windows et testez-le sur une machine Windows là aussi, fraichement installée.

tux@makina:~$ dotnet new console -n Hello

$ tree
.
├── Hello
│   ├── Hello.csproj
│   ├── Program.cs
│   └── obj
│       ├── Hello.csproj.nuget.dgspec.json
│       ├── Hello.csproj.nuget.g.props
│       ├── Hello.csproj.nuget.g.targets
│       ├── project.assets.json
│       └── project.nuget.cache

$ ls bin/Debug/net6.0/
Hello.deps.json  Hello.dll  Hello.exe  Hello.pdb  Hello.runtimeconfig.json

tux@makina:~/Hello$ bin/Release/net6.0/Hello
Hello, World!

Vous êtes un peu perdu, répondez aux questions ci-dessous.

💬 Quel sorte de fichier est-ce que ce fichier Hello généré par la commande de build ? Un fichier texte de type script bash ? Un fichier exécutable ? Un ELF à oreilles pointues ou un PE ?

💬 Maintenant que je sais ce que c’est, est-ce que je peux simplement distribuer ce fichier via Internet pour que tout le monde puisse l’exécuter et obtenir ce fameux Hello, World! ? Vous ne pouvez pas simplement répondre oui/non mais vous devez prouvez votre réponse !

Dans l’image ci-dessous on peut voir deux machines Linux WSL.

Celle du haut est une machine Ubuntu 22.04 alors que celle du bas est une machine Ubuntu 20.04.

En lisant la suite de commandes on peut voir que dans la machine du haut on voit que le framework dotnet est installé mais pas dans celle du bas.

Dans les deux machines, on a placer les même fichiers ELF/DLL. Ces fichiers ont étés générés par la commande build en mode Release

Dans la machine qui ne contient pas le framework, sans surprise, ça ne fonctionne pas

💬 Comment faire pour pouvoir fournir ce programme Hello a une personne qui possède une machine Linux x86_64 et lui permettre de l’utiliser sans installer le framework .NET ?

On doit publier le programme en précisant qu’on souhaite obtenir un dossier contenant tout le nécessaire pour faire fonctionner le Hello. On peut encore préciser le format du programme en sortie.

tux@makina:~/Hello$ dotnet publish -c Release -r linux-x64 --self-contained true

.NET RID Catalog

Ce qui fournit un dossier contenant toutes les librairies nécessaires au fonctionnement de ce simple Hello 😲

bin/Release/net8.0/linux-x64/publish/
├── createdump
├── Hello
├── Hello.deps.json
├── Hello.dll
├── Hello.pdb
├── Hello.runtimeconfig.json
├── libclrjit.so
├── libcoreclr.so
├── libcoreclrtraceptprovider.so
├── libdbgshim.so
├── libhostfxr.so
├── libhostpolicy.so
├── libmscordaccore.so
├── libmscordbi.so
├── libSystem.Globalization.Native.so
├── libSystem.IO.Compression.Native.so
├── libSystem.Native.so
├── libSystem.Net.Security.Native.so
├── libSystem.Security.Cryptography.Native.OpenSsl.so
├── Microsoft.CSharp.dll
├── Microsoft.VisualBasic.Core.dll
├── Microsoft.VisualBasic.dll
├── Microsoft.Win32.Primitives.dll
├── Microsoft.Win32.Registry.dll
├── mscorlib.dll
├── netstandard.dll
├── System.AppContext.dll
├── System.Buffers.dll
├── System.Collections.Concurrent.dll
├── System.Collections.dll
├── System.Collections.Immutable.dll
├── System.Collections.NonGeneric.dll
├── System.Collections.Specialized.dll
├── System.ComponentModel.Annotations.dll
├── System.ComponentModel.DataAnnotations.dll
├── System.ComponentModel.dll
├── System.ComponentModel.EventBasedAsync.dll
├── System.ComponentModel.Primitives.dll
├── System.ComponentModel.TypeConverter.dll
├── System.Configuration.dll
├── System.Console.dll
├── System.Core.dll
├── System.Data.Common.dll
├── System.Data.DataSetExtensions.dll
├── System.Data.dll
├── System.Diagnostics.Contracts.dll
├── System.Diagnostics.Debug.dll
├── System.Diagnostics.DiagnosticSource.dll
├── System.Diagnostics.FileVersionInfo.dll
├── System.Diagnostics.Process.dll
├── System.Diagnostics.StackTrace.dll
├── System.Diagnostics.TextWriterTraceListener.dll
├── System.Diagnostics.Tools.dll
├── System.Diagnostics.TraceSource.dll
├── System.Diagnostics.Tracing.dll
├── System.dll
├── System.Drawing.dll
├── System.Drawing.Primitives.dll
├── System.Dynamic.Runtime.dll
├── System.Formats.Asn1.dll
├── System.Globalization.Calendars.dll
├── System.Globalization.dll
├── System.Globalization.Extensions.dll
├── System.IO.Compression.Brotli.dll
├── System.IO.Compression.dll
├── System.IO.Compression.FileSystem.dll
├── System.IO.Compression.ZipFile.dll
├── System.IO.dll
├── System.IO.FileSystem.AccessControl.dll
├── System.IO.FileSystem.dll
├── System.IO.FileSystem.DriveInfo.dll
├── System.IO.FileSystem.Primitives.dll
├── System.IO.FileSystem.Watcher.dll
├── System.IO.IsolatedStorage.dll
├── System.IO.MemoryMappedFiles.dll
├── System.IO.Pipes.AccessControl.dll
├── System.IO.Pipes.dll
├── System.IO.UnmanagedMemoryStream.dll
├── System.Linq.dll
├── System.Linq.Expressions.dll
├── System.Linq.Parallel.dll
├── System.Linq.Queryable.dll
├── System.Memory.dll
├── System.Net.dll
├── System.Net.Http.dll
├── System.Net.Http.Json.dll
├── System.Net.HttpListener.dll
├── System.Net.Mail.dll
├── System.Net.NameResolution.dll
├── System.Net.NetworkInformation.dll
├── System.Net.Ping.dll
├── System.Net.Primitives.dll
├── System.Net.Quic.dll
├── System.Net.Requests.dll
├── System.Net.Security.dll
├── System.Net.ServicePoint.dll
├── System.Net.Sockets.dll
├── System.Net.WebClient.dll
├── System.Net.WebHeaderCollection.dll
├── System.Net.WebProxy.dll
├── System.Net.WebSockets.Client.dll
├── System.Net.WebSockets.dll
├── System.Numerics.dll
├── System.Numerics.Vectors.dll
├── System.ObjectModel.dll
├── System.Private.CoreLib.dll
├── System.Private.DataContractSerialization.dll
├── System.Private.Uri.dll
├── System.Private.Xml.dll
├── System.Private.Xml.Linq.dll
├── System.Reflection.DispatchProxy.dll
├── System.Reflection.dll
├── System.Reflection.Emit.dll
├── System.Reflection.Emit.ILGeneration.dll
├── System.Reflection.Emit.Lightweight.dll
├── System.Reflection.Extensions.dll
├── System.Reflection.Metadata.dll
├── System.Reflection.Primitives.dll
├── System.Reflection.TypeExtensions.dll
├── System.Resources.Reader.dll
├── System.Resources.ResourceManager.dll
├── System.Resources.Writer.dll
├── System.Runtime.CompilerServices.Unsafe.dll
├── System.Runtime.CompilerServices.VisualC.dll
├── System.Runtime.dll
├── System.Runtime.Extensions.dll
├── System.Runtime.Handles.dll
├── System.Runtime.InteropServices.dll
├── System.Runtime.InteropServices.RuntimeInformation.dll
├── System.Runtime.Intrinsics.dll
├── System.Runtime.Loader.dll
├── System.Runtime.Numerics.dll
├── System.Runtime.Serialization.dll
├── System.Runtime.Serialization.Formatters.dll
├── System.Runtime.Serialization.Json.dll
├── System.Runtime.Serialization.Primitives.dll
├── System.Runtime.Serialization.Xml.dll
├── System.Security.AccessControl.dll
├── System.Security.Claims.dll
├── System.Security.Cryptography.Algorithms.dll
├── System.Security.Cryptography.Cng.dll
├── System.Security.Cryptography.Csp.dll
├── System.Security.Cryptography.Encoding.dll
├── System.Security.Cryptography.OpenSsl.dll
├── System.Security.Cryptography.Primitives.dll
├── System.Security.Cryptography.X509Certificates.dll
├── System.Security.dll
├── System.Security.Principal.dll
├── System.Security.Principal.Windows.dll
├── System.Security.SecureString.dll
├── System.ServiceModel.Web.dll
├── System.ServiceProcess.dll
├── System.Text.Encoding.CodePages.dll
├── System.Text.Encoding.dll
├── System.Text.Encoding.Extensions.dll
├── System.Text.Encodings.Web.dll
├── System.Text.Json.dll
├── System.Text.RegularExpressions.dll
├── System.Threading.Channels.dll
├── System.Threading.dll
├── System.Threading.Overlapped.dll
├── System.Threading.Tasks.Dataflow.dll
├── System.Threading.Tasks.dll
├── System.Threading.Tasks.Extensions.dll
├── System.Threading.Tasks.Parallel.dll
├── System.Threading.Thread.dll
├── System.Threading.ThreadPool.dll
├── System.Threading.Timer.dll
├── System.Transactions.dll
├── System.Transactions.Local.dll
├── System.ValueTuple.dll
├── System.Web.dll
├── System.Web.HttpUtility.dll
├── System.Windows.dll
├── System.Xml.dll
├── System.Xml.Linq.dll
├── System.Xml.ReaderWriter.dll
├── System.Xml.Serialization.dll
├── System.Xml.XDocument.dll
├── System.Xml.XmlDocument.dll
├── System.Xml.XmlSerializer.dll
├── System.Xml.XPath.dll
├── System.Xml.XPath.XDocument.dll
└── WindowsBase.dll

Maintenant, on peut fournir le dossier à quelqu’un qui possède une machine Linux et il pourra faire fonctionner le programme comme on peut le voir ci-dessous avec les deux mêmes machines Linux WSL. Celle du haut possède le framework mais pas celle du bas. Par contre celle du bas possède le dossier avec toutes les dépendances.

💬 Peut-on créer un exécutable PE depuis cette machine Linux ?

Oui c’est tout à fait possible, il suffit de changer le RID

$ dotnet publish -c Release -r win-x64  --self-contained true
$ file bin/Release/net8.0/win-x64/publish/Hello.exe 
bin/Release/net8.0/win-x64/publish/Hello.exe: PE32+ executable (console) x86-64, for MS Windows, 6 sections

À quoi ça sert

Voilà une question légitime. Pourquoi faire en ligne de commande quelque chose qu’on peut faire graphiquement ?

Vous avez peut-être remarqué le lien en début de tutoriel .NET In-Browser Tutorial.

Quand on clique sur le bouton Run Code que se passe-t-il ?

1. Le texte que vous avez écrit dans le navigateur est transmit au serveur web via une simple requête HTTP de type POST
2. Le serveur web crée un projet avec la commande dotnet new console -n UUID_Unique
3. Il remplace le code présent dans le fichier Program.cs par le votre, celui qu’il vient de recevoir
4. Il démarre ensuite un conteneur en faisant une copie d’un conteneur de base contenant également la commande dotnet, par exemple celui-ci microsoft-dotnet-framework si le système de conteneur utilisé est docker
5. Il pousse le projet dans le conteneur et il donne l’ordre au conteneur de lancer une suite de commande dont la commande dotnet build et dotnet run
6. Il interprète le résultat reçu en retour, détruit le conteneur et génère une page html qui sera affichée dans votre navigateur en retour

Tout se passe dans un serveur web et dans un conteneur. Aucune de ces machines ne possède une interface graphique beaucoup trop gourmande en ressources. Il est donc impossible, d’utiliser Visual Studio.

On trouve même des sites qui utilisent la commande dotnet test pour démarrer des tests unitaires et ainsi faire de la validation de challenges de programmation. Par exemple le site Edabit. Les premiers challenges sont gratuits puis le site devient payant.

Le site Gitlab utilise le même principe pour faire l’intégration continue (CI/CD). Il travail avec des conteneurs LXC.

Pour finir, la documentation officielle de Microsoft regorge de ce type d’utilisation, par exemple ici conditional operator

Exercice

Nous allons réaliser un exercice qui permettra de mieux comprendre ce qui se passe sur le site d’edabit et plus précisément, cet exercice Javascript qui fait office de donnée d’exercice. Bien sûr, nous le réaliseront en C# et en mode console avec la commande dotnet.

Pour faire ce travail on pourrait suivre cette marche à suivre mais je vous ai simplifié le travail en vous préparant une archive contenant déjà tout le nécessaire.

Cette archive contient une solution qui elle-même contient deux projets, Challenge et Test :

├── Challenge
│   ├── Challenge
│   │   ├── Challenge.cs
│   │   ├── Challenge.csproj
│   ├── Challenge.sln
│   └── Test
│       ├── Test.csproj
│       ├── UnitTest.cs
│       └── Usings.cs

Le projet Test contient les tests qui doivent être validés

using Challenge;

namespace Test
{
        [TestFixture]
        public class Tests
        {
                private Boomerang boomerang;

                [SetUp]
                public void Setup()
                {
                        boomerang = new Boomerang();
                }

                [Test]
                [TestCase(new int[] {9, 5, 9, 5, 1, 1, 1}, 2, TestName="Test 1" )]
                [TestCase(new int[] {5, 6, 6, 7, 6, 3, 9}, 1, TestName="Test 2" )]
                [TestCase(new int[] {4, 4, 4, 9, 9, 9, 9}, 0, TestName="Test 3" )]
                [TestCase(new int[] {5, 9, 5, 9, 5}, 3, TestName="Test 4" )]
                [TestCase(new int[] {4, 4, 4, 8, 4, 8, 4}, 3, TestName="Test 5" )]
                [TestCase(new int[] {2, 2, 2, 2, 2, 2, 3}, 0, TestName="Test 6" )]
                [TestCase(new int[] {2, 2, 2, 2, 3, 2, 3}, 2, TestName="Test 7" )]
                [TestCase(new int[] {1, 2, 1, 1, 1, 2, 1}, 2, TestName="Test 8" )]
                [TestCase(new int[] {5, 1, 1, 1, 1, 4, 1}, 1, TestName="Test 9" )]
                [TestCase(new int[] {3, 7, 3, 2, 1, 5, 1, 2, 2, -2, 2}, 3, TestName="Test 10" )]
                [TestCase(new int[] {1, 7, 1, 7, 1, 7, 1}, 5, TestName="Test 11" )]
                [TestCase(new int[] {5, 5, 5}, 0, TestName="Test 12" )]
                public void Test(int[] array, int expected)
                {
                        int result = boomerang.HowMany(array);
                        Assert.AreEqual(result, expected);
                }
        }
}

Tandis que le projet Challenge contient le code source à compléter

using System;

namespace Challenge
{
        public class Boomerang
        {
                public int HowMany(int[] array)
                {
                        /*
                         * Votre code ici
                         */
                        return -1;
                }
        }
}

Le principe est similaire à ce qui a été vu au-dessus. Vous devez compléter la méthode HowMany pour qu’elle fasse le travail souhaitez. Si vous y parvenez alors les 12 tests seront ✅ et c’est à ce moment qu’on considère le challenge comme valide.

Pour lancer les tests on utilise la commande dotnet test depuis la racine

.
├── Challenge
├── Challenge.sln
└── Test

À vous de jouer 😁. Réaliser le code qui valide les 12 tests 😉.

Outils C#

Vous avez plusieurs choix pour réaliser un programme en C#.

• ✰✰✰ Travailler en ligne de commande avec la commande dotnet tel que présenté ci-dessus et un éditeur à coloration syntaxique. Cette solution est très légère mais elle n’est pas adaptée à un apprentissage du langage C#.
• ★✰✰ Utiliser un IDE multiplateformes tel que Visual Code. Cet éditeur open source est complètement paramétrable. Il est adapté à beaucoup de langages et il est assez conviviale. Par contre, vous risquez de devoir tout re-paramétrer / re-installer à chaque changement de machine. Il requière une phase d’apprentissage non négligeable. Vous risquez de passer beaucoup de temps à apprendre l’outil plutôt que le langage. Il n’est pas adapté à l’apprentissage d’un langage.
• ★★★ Utiliser un IDE multiplateformes tel que Rider. Similaire à Visual Studio, Rider à beaucoup d’atouts pout lui et notamment le fait d’être multiplateformes, Linux inclus. Éditer par Jetbrains, il a l’avantage de faire partie d’un ensemble d’outils similaires. Ainsi, si vous maitrisez Rider pour C# alors vous maitrisez aussi PHPStorm pour PHP, IntelliJ pour Java ou encore Android Studio. Vous pourrez vous concentrer uniquement sur les spécificités du langage que vous apprenez. Il est parfaitement adapté à un apprentissage. Il est possible d’obtenir une licence étudiant-e gratuite.
• ★★★ Utiliser l’IDE pour Windows Visual Studio. C’est la référence absolue pour ce langage. Il est simplement imbattable et parfaitement adapté à l’apprentissage du langage C#. Il peut également être utilisé pour d’autres langages tels que HTML, Javascript, PHP. Par contre, il n’est pas utilisable sur Linux et il ne l’est plus non plus sur Mac. Visual Studio existe en version gratuite Visual Studio Community. L’inconvénient majeur de Visual Studio est qu’il est très lourd et qu’il nécessite une machine puissante, de plus, il est très souvent mise à jour et les mises à jour sont énormes.

Boxing et unboxing

Lors de vos futures lectures de sites web ou autres ouvrages papier, vous rencontrerez probablement ces deux termes. Le boxing et l’unboxing.

Le boxing consiste généralement à convertir un type valeur en type object.

L’unboxing consiste à faire à démarche inverse, à savoir, convertir l’objet ou la variable de type object en son type d’origine.

La conversion boxing est implicite.

int i = 123;
// The following line boxes i.
object o = i;

La conversion unboxing est explicite (il faut préciser le type d’origine)

object o = 123;
int i = (int)o; // unboxing

Attention, le boxing et l’unboxing sont des opérations coûteuses en temps de calcul et il est préférable de ne pas les utiliser Performances.

Il ne faut pas confondre boxing et unboxing avec la copie de référence. En effet, le boxing et l’unboxing ne copie pas simplement une référence mais il crée une nouvelle référence sur la pile o qui pointe sur une nouvelle variable i boxed sur le tas.

Les deux variables vivent leur vie séparément. Voyez le programme ci-dessous :

int i=123;
object obj = i;
Console.WriteLine($"i   is typeof                     {i.GetType()}");
Console.WriteLine($"obj is typeof                     {obj.GetType()}");
Console.WriteLine($"i   contain                       {i}");
Console.WriteLine($"obj contain                       {obj}");
Console.WriteLine($"Change value of obj to {obj = 456}");
Console.WriteLine($"i   contain                       {i}");
Console.WriteLine($"obj contain                       {obj}");
Console.Write("i.GetType() == typeof(int) ?      ");
if(i.GetType() == typeof(int))
    Console.WriteLine("yes");
else
    Console.WriteLine("no");

Console.Write("i is int ?                        ");
if(i is int)
    Console.WriteLine("yes");
else
    Console.WriteLine("no");

Console.Write("obj.GetType() == typeof(object) ? ");
if(obj.GetType() == typeof(object))
    Console.WriteLine("yes");
else
    Console.WriteLine("no");

Console.Write("obj is object ?                   ");
if(obj is object)
    Console.WriteLine("yes");
else
    Console.WriteLine("no");

Il donne le résultat suivant :

i   is typeof                     System.Int32
obj is typeof                     System.Int32
i   contain                       123
obj contain                       123

Change value of obj to 456
i   contain                       123
obj contain                       456
i.GetType() == typeof(int) ?      yes
i is int ?                        yes
obj.GetType() == typeof(object) ? no
obj is object ?                   yes

Comme on peut le constater, i et obj sont deux variables différentes. obj est une variable de type object qui contient une copie de la valeur de i au moment du boxing.

Quand utiliser le boxing et l’unboxing ?

Un exemple classique est la collection ArrayList. Une ArrayList est une collection dynamique d’object.

Autrement dit c’est une collection dans laquelle on peut mettre tout ce qu’on veut. Chaque élément sera converti implicitement en object.

Voici un exemple :

ArrayList al = new ArrayList();
// Boxing implicite en type object
al.Add(12); // Un int
al.Add("Hello"); // Une string
al.Add(new Point(12, 4)); // un point

// Unboxing:
int i = (int)al[0];
string s = (string)al[1];
Point p = (Point)al[2];

Pour plus de détails :

Boxing et unboxing

Mots clés is et as

Le mot clé is est un opérateur qui permet de tester le type d’une variable ou d’un objet.

Il s’utilise ainsi :

if (o is int)…

ce qui signifie « o, qui est un object, contient-il un int ? »

Le mot clé as est un opérateur nous permettant de faire du transtypage (expression casting). Il s’utilise ainsi:

string s = al[1] as string; // Opérateur as
string s = (string)al[1];   // Expression casting

L’opérateur as ne peut être utilisé que pour les types « nullables » (string , object, etc… mais pas int par exemple) car en cas de conversion impossible, la variable se verra assigner la valeur null contrairement au casting qui lèvera une exception.

Exercice

Soit le code suivant:

 1  class Program
 2  {
 3      static void Main(string[] args)
 4      {
 5          List<object> list = new List<object>();
 6
 7          list.Add(123);
 8          list.Add("C#");
 9          list.Add(null);
10          list.Add(new Person("Onime", "Anne"));
11
12          // Parcours de modification
13          foreach (object item in list)
14          {
15              if (item is Person)
16              {
17                  Person person = (Person)item;
18                  person.Nom = "Nasse";
19                  person.Prenom = "Anna";
20              }
21              else if (item is int)
22              {
23                  int n = (int)item;
24                  n++;
25              }
26              else
27              {
28                  string? chaine = item as string;
29                  chaine = "F" + chaine[1];
30              }
31          }
32
33          // Parcours d'affichage
34          foreach (object item in list)
35          {
36              Console.WriteLine(item);
37          }
38
39          // gestion des Exceptions
40          for (int i = 0; i < list.Count; i++)
41          {
42              try
43              {
44                  int n = (int)list[i];
45                  Console.WriteLine($"Unboxing list at index {i} to int is OK");
46              }
47              catch (InvalidCastException)
48              {
49                  Console.WriteLine($"List at index {i} is not possible");
50              }
51              catch (NullReferenceException)
52              {
53                  Console.WriteLine($"List at index {i} is null");
54              }
55          }
56      }
57  }
58
59  public class Person
60  {
61      public Person(string nom, string prenom)
62      {
63          Nom = nom;
64          Prenom = prenom;
65      }
66      public string Nom { get; set; }
67      public string Prenom { get; set; }
68
69      public override string ToString()
70      {
71          return $"{Prenom} {Nom}";
72      }
73  }

Répondez aux questions suivantes sans coder le programme et sans lire les réponses.

💬 Est-il possible de placer toutes ces valeurs de type différent dans une List typée ainsi (lignes 7 à 10) ? Justifier!

💬 Si tout ce passe bien, quelles seront les valeurs affichées lors de la seconde boucle (lignes 34 à 37) ?

💬 Pourquoi y a-t-il un ? devant la déclaration string? chaine = item as string; (ligne 28) ?

💬 Qu’est-ce qui sera affiché par la dernière boucle (lignes 40 à 55) ?

💬 Quelle(s) correction(s) faudrait-il apporter à ce programme ?

Opérateurs

En programmation informatique, un opérateur est une fonction spéciale dont l’identificateur s’écrit généralement avec des caractères non autorisés pour l’identificateur des fonctions ordinaires tels que +, -, * etc. Il s’agit souvent des équivalents aux opérateurs mathématiques pour un langage de programmation. En C#, les opérateurs peuvent être surchargés au même titre que les méthodes standards.

Mais au fait, comment est-ce possible de créer l’opérateur + pour un entier ? En effet, si on imagine la méthode pour cet opérateur elle se présenterait comme suit :

int operator +(int left, int right)
{
    return left + right; // on ne peut pas utiliser le symbole '+'
}

Oui mais voilà, on ne peut pas utiliser le symbole + puisqu’on est justement entrain de le coder 😖 !

Pour trouver une réponse à cette épineuse question, on peut se tourner vers le CLI qui est capable de fournir des instructions en langage intermédiaire (CIL) qui seront ensuite compilées en code machine. Voici un exemple de code CIL pour l’opérateur + :

.method public static int32 Add(int32, int32) cil managed {
    .maxstack 2
    ldarg.0 // load the first argument, opcode 0x02
    ldarg.1 // load the second argument, opcode 0x03
    add     // add them, opcode 0x58
    ret     // return the result, opcode 0x2A
}

Nous n’allons pas descendre aussi bas dans le détail mais sachez que le compilateur C# est capable traiter ce genre de code.

Opérateurs surchargés

On peut classer les opérateurs selon le nombre d’opérandes qu’ils acceptent.

• Une opération unaire accepte un seul argument

  // operator
  int operator -(int value)
  {
      // code ...
  }
  
  // usage
  int testValue = 12;
  int test = -testValue; // test = -12

• Une opération binaire accepte deux arguments

  // operator
  int operator +(int left, int right)
  {
      // code ...
  }
  
  // usage
  int testValue1 = 12;
  int testValue1 = 21;
  int test = testValue1 + testValue2; // test = 33

• Un opérateur ternaire accepte trois arguments

  int age = 12;
  string condition = (age >= 18) ? "Majeur" : "Mineur";

Opérateurs standards +, -, *, /

À titre d’exemple, vous trouvez ci-dessous une classe partielle Vector2 (la classe complète se trouve ici) qui permet la manipulation de vecteur en 2 dimensions. Cette exemple contient trois opérateurs. L’opérateur d’addition + et deux opérateurs de multiplications surchargés *. À l’intérieur de ces méthodes, on retrouve l’utilisation des opérateurs internes (built-in) au type double.

public class Vector2
{
    double x, y;
    public Vector2(double x, double y)
    {
        this.x = x;
        this.y = y;
    }
    public static Vector2 operator +(Vector2 vec1, Vector2 vec2)
    {
        // usage of double '+' built-in operator
        return new Vector2(vec1.x + vec2.x, vec1.y + vec2.y);
    }
    public static Vector2 operator *(Vector2 vec1, Vector2 vec2)
    {
        // usage of double '*' built-in operator
        return new Vector2(vec1.x * vec2.x, vec1.y * vec2.y);
    }
    public static Vector2 operator *(Vector2 vec, float scaleFactor)
    {
        vec.x *= scaleFactor; // usage of double '*' built-in operator
        vec.y *= scaleFactor; // and double '=' built-in operator
        return vec;
    }
}

On peut utiliser cette classe ainsi

Vector2 vec1 = new Vector2(10.0, 3.0);
Vector2 vec2 = new Vector2(27.0, 4.0);

Vector2 res1 = vec1 + vec2;
Vector2 res2 = vec1 * vec2;
Vector3 res3 = vec1 * 34.5;

On peut encore remarquer l’utilisation de l’opérateur built-in = d’affectation de référence. On se rend compte que l’utilisation des opérateurs est omniprésente en programmation.

Exercice opérateur

On vous demande de réaliser la structure PointF dont le début est fournit ci-dessous (différence entre struct et classe hors cours). Les opérateurs ne sont pas forcement utiles et concrets mais ils servent d’exercice 😉.

public struct PointF
{
    float x;
    float y;

    public PointF(float x, float y)
    {
        this.x = x;
        this.y = y;
    }
    public bool IsEmpty
    {
        get { return x == 0f && y == 0f; }
    }
    public float X
    {
        get { return x; }
        set { x = value; }
    }
    public float Y
    {
        get { return y; }
        set { y = value; }
    }
    /// <summary>
    /// Opérateur unaire de soustraction
    /// Symbol: --
    /// Job: soustrait 1 aux deux composantes x et y
    /// Exemple:
    /// PointF pt(12f, 24f);
    /// pt--;
    /// </summary>
    /// <param name="pt"></param>
    /// <returns></returns>


    // VOTRE CODE ICI


    /// <summary>
    /// Opérateur binaire de soustraction:
    /// Symbol: -
    /// Job: Soustrait les composantes x et y de pt2 à pt1
    /// Exemple:
    /// PointF pt1(12f, 24f);
    /// PointF pt2(35f, 56f);
    /// PointF pt = pt2 - pt1;
    /// </summary>
    /// <param name="pt1"></param>
    /// <param name="pt2"></param>
    /// <returns></returns>


    // VOTRE CODE ICI


    /// <summary>
    /// Opérateur binaire de division
    /// Symbole: /
    /// Job: Divise les composantes x et y de pt1 par les composantes de pt2
    /// Exemple:
    /// PointF pt1(12f, 24f);
    /// PointF pt2(35f, 56f);
    /// PointF pt = pt2 / pt1;
    /// </summary>
    /// <param name="pt1"></param>
    /// <param name="pt2"></param>
    /// <returns></returns>


    // VOTRE CODE ICI


    /// <summary>
    /// Opérateur binaire de division
    /// Symbole: /
    /// Job: Divise les composantes x et y de pt par la valeur scale
    /// Exemple:
    /// PointF pt(12f, 24f);
    /// float scale = 2.0f;
    /// pt = pt / scale;
    /// </summary>
    /// <param name="pt"></param>
    /// <param name="scaleFactor"></param>
    /// <returns></returns>


    // VOTRE CODE ICI


}

Le code de test est le suivant

PointF pt = new PointF(11f, 86f);
PointF pt2 = new PointF(2f, 3f);

pt--;                               // pt.x = 10 et pt.y = 85
pt = pt / 5f;                       // pt.x = 2 et pt.y = 17
pt = pt / pt2;                      // pt.x = 1 et pt.y = 5.666
pt = pt - pt2;                      // pt.x = -1 et pt.y = 2.666

Corrigé

Quelques opérateurs

Il existe un grand nombre d’opérateurs en C#. Certains s’utilisent quotidiennement, comme l’opérateur +, d’autres sont plus rarement utilisés. Voici deux opérateurs qui ne s’utilise que rarement 😯.

Index depuis la fin ^

Disponible en C# 8.0 et versions ultérieures, l’opérateur indique la position de l’élément ^ à partir de la fin d’une séquence. Pour une séquence de longueur length, ^n pointe vers l’élément avec un décalage length - n à partir du début d’une séquence. Par exemple, ^1 pointe vers le dernier élément d’une séquence et ^length pointe vers le premier élément d’une séquence.

int[] xs = new[] { 0, 10, 20, 30, 40 };
int last = xs[^1];
Console.WriteLine(last);     // output: 40

string lines = new List<string> { "one", "two", "three", "four", "five" };
string prelast = lines[^2];  // lines.Length = 5 and 5 - 2 = 3 -> lines[3] = "four"
Console.WriteLine(prelast);  // output: four

string word = "Hello";
Index toFirst = ^word.Length;
char first = word[toFirst];
Console.WriteLine(first);    // output: H

Opérateur de plage ..

Disponible en C# 8.0 et versions ultérieures, l’opérateur .. spécifie le début et la fin d’une plage d’index en tant qu’opérandes. L’opérande de gauche est un début inclusif d’une plage. L’opérande de droite est une fin exclusive d’une plage. L’un des opérandes peut être un index à partir du début ou de la fin d’une séquence, comme l’illustre l’exemple suivant :

int[] numbers = new[] { 0, 10, 20, 30, 40, 50 };
int start = 1;
int amountToTake = 3;
int[] subset = numbers[start..(start + amountToTake)]; // subset: 10 20 30

int margin = 1;
int[] inner = numbers[margin..ᶺmargin];                // inner: 10 20 30 40

Vous pouvez omettre l’un des opérandes de l’opérateur .. pour obtenir une plage ouverte :

• a.. équivaut à a..ᶺ0
• ..b équivaut à 0..b
• .. équivaut à 0..ᶺ0

Warning

On peut vite se faire avoir avec les opérateurs qui n’en sont pas.

Exemple 1 :

int[][] numbers = new[]
{
    new[] {1,2,3},
    new[] {4,5,6},
    new[] {7,8,9}
};

List<int> values = numbers.SelectMany(_ => _.Where(_ => _ % 2 == 0)).ToList();

Dans cet exemple, le caractère _ n’est rien d’autre qu’un nom de variable autorisé 😟 au même titre que

int _ = 12;

Ou encore le code ci-dessous qui prête à confusion quand au type d’opérateur

Exemple 2 :

int n = 1234ᶺ1

Ou dans ce cas, à gauche de l’opérateur on ne trouve pas un tableau mais une variable entière et dans ce cas, on a affaire à l’opérateur XOR 😩.

Au fait, quels sont les résultats de ces deux exemples ?

L’exemple 1 fournit dans values …

L’exemple 2 fournit dans n…

Le cas du ?

Le point d’interrogation revient régulièrement en programmation. Il peut signifier plusieurs choses mais il est intimement lié au fait qu’une référence peut être null. Hors, un référence null peut lever une exception de type NullReferenceException mais elle peut aussi être impliquée dans des attaques informatiques de type null pointer dereference. Même si l’exemple fournit avec ce lien est très vieux, cette attaque est toujours d’actualité car les programmeurs oublient de tester leurs références aux objets.

Exemple

Imaginez un code complet de plusieurs milliers de lignes parmi lesquelles se trouvent ces lignes là :

const int MAX_CLIENTS = 100;
const int MAX_CAR_TO_PRINT = 20;
string[] noms = new string[MAX_CLIENTS];

try
{
    noms = File.ReadAllLines("clients.txt");
}
catch (FileNotFoundException ex)
{
    Console.WriteLine("Le fichier n'existe pas...");
}

for (int i = 0; i < MAX_CLIENTS; i++)
{
    if (noms[i].Length > MAX_CAR_TO_PRINT)
    {
        Console.WriteLine($"Bonjour {noms[i].Substring(0, MAX_CAR_TO_PRINT - 3)}...");
    }
    else
    {
        Console.WriteLine($"Bonjour Monsieur {noms[i]}");
    }
}

Le programmeur possède bien entendu le fichier clients.txt sur son poste car il est justement entrain de régler des problèmes d’affichage sur la longueur des noms. Mais que ce passe-t-il si ce fichier n’existe pas ?

Type non-nullable

En C# il existe des types non-nullable. Ce sont les types de base :

• int
• double
• char
• bool

Cependant, dans certaines applications, une valeur de variable peut être indéfinie ou manquante. Par exemple, un champ de base de données contenant un booléen peut contenir true ou false , mais il peut aussi contenir aucune valeur, autrement dit, NULL . Vous pouvez alors, grâce à l’opérateur ? utiliser le type bool? dans ce scénario.

Vous utilisez donc un type valeur Nullable lorsque vous devez représenter la valeur indéfinie d’un type valeur non nullable.

Imaginons l’exemple où vous faites un accès à une base de données pour obtenir l’âge lié à un profil d’utilisateur. Lorsque l’utilisateur à rempli son profil, la date de naissance était facultative.

Vous ne pouvez donc pas faire ceci

int age = DBProfilGetAge();

car les valeurs possibles sont une valeur entière mais aussi null si l’utilisateur n’a pas donné sa date de naissance. Par contre vous pouvez faire ceci:

int? age = DBProfilGetAge();

Ou ceci, qui revient au même:

Nullable<int> age = DBProfilGetAge();

Dans ce cas, la variable age pourra prendre comme valeur un entier ou la valeur null malgré qu’un type int n’est pas nullable.

Opérateurs de condition null ?. et ?[]

Cet opérateur s’applique au accès de type membre de ou index. Cet opérateur retourne la valeur correspondante seulement pour des valeurs non-null autrement, il retourne null.

Exemple

L’exemple ci-dessous déclenche une exception de type

System.NullReferenceException : ‘Object reference not set to an instance of an object.’

car la référence person est null

public static class NullProject
{
    public static void Main()
    {
        Person person = null;
        Console.WriteLine(person.Name);
    }
}

public class Person
{
    public string Name { get; set; }
}

Si on écrit le même programme avec l’opérateur ? alors l’accès au membre Name sera protégé dans le sens où il ne déclenchera pas d’exception mais il renverra la valeur null et Console.WriteLine(null) revient à afficher une chaîne de caractère null, dans ce cas, la méthode WriteLine affiche simplement un retour à la ligne.

public static void Main()
{
    Person person = null;
    Console.WriteLine(person?.Name);
}

Exemple 2

Imaginons qu’on souhaite créer une méthode ayant la signature suivante

int FirstOrDefault(string search, string[] strings)

Cette méthode retourne l’index de la première valeur search présente dans le tableau strings. Si la méthode ne trouve pas la valeur search elle retourne la valeur -1. Une approche simple serait

int FirstOrDefault(string search, string[] strings)
{
    int i = 0;

    do
    {
        if (strings[i] == search)
            return i;
    }
    while(i++ < strings.Length);

    return -1;
}

Et les tests seraient

int foundAt = -1;
foundAt = FirstOrDefault("C", null));                         // foundAt: -1
foundAt = FirstOrDefault("C", new string[0]));                // foundAt: -1
foundAt = FirstOrDefault("C", new string[] { null }));        // foundAt: -1
foundAt = FirstOrDefault("C", new string[] {"A", "B", "C"})); // foundAt:  2

Malheureusement, avec la première ligne de test on obtiendra

System.NullReferenceException : ‘Object reference not set to an instance of an object.’

lors de l’accès à l’index strings[i] car strings est null. On peut alors placer l’opérateur ? pour protéger l’accès comme ceci strings?[i]. Cette fois, la valeur retournée sera null et le test null == search est tout à fait possible 😎.

On peut aussi se dire qu’on peut tester la taille du tableau avant d’accéder à une cellule

if (strings.Length == 0)
    return -1;

Malheureusement, le programme plantera lors de l’accès au membre strings.Length toujours parce que strings est null. À nouveau, on peut protéger l’accès au membre avec l’opérateur ? de cette manière strings?.Length. Le programme devient alors

int FirstOrDefault(string search, string[] strings)
{
    int i = 0;

    if (strings?.Length == 0)
        return -1;

    do
    {
        if (strings?[i] == search)
            return i;
        i++;
    }
    while(i < strings?.Length);

    return -1;
}

Attention: comme il est stipulé dans la documentation officielle, l’opérateur ? ne vous protège pas contre les autres exceptions. Ainsi la seconde ligne du test déclenchera une exception

System.IndexOutOfRangeException : ‘Index was outside the bounds of the array.’

car l’index 0 n’existe pas dans le tableau string[0]

Une autre manière de procéder serait de tester la valeur de strings au début du programme ainsi

int FirstOrDefault(string search, string[] strings)
{
    if(strings is null)
        return -1;

En programmation, il y a toujours plusieurs chemin pour atteindre un but 😉. L’important c’est de faire les tests !

Opérateur ternaire ?:

C’est une façon raccourcie d’écrire un if / else. L’opérateur ternaire évalue une condition qui doit retourner un booléen et effectue l’une des deux actions en conséquence.

Écriture générique

condition ? action_si_vrai : action_si_faux

Exemple

int age = Input("Quel est ton âge ?");
string catAge = (age >= 18) ? "Majeur" : "Mineur";

Dans cet exemple, la chaîne de caractères catAge prend la valeur Majeur ou Mineur en fonction du résultat de l’expression booléenne age >= 18. Les parenthèses sont facultatives.

L’opérateur ternaire est associatif à droite, autrement dit, une expression de la forme

a ? b : c ? d : e

est évaluée comme étant

a ? b : (c ? d : e)

Affectation si null, l’opérateur ??=

L’opérateur ??= d’affectation null-coalescing affecte la valeur de son opérande de droite à son opérande de gauche uniquement si l’opérande de gauche est évalué à null.

// numbers est null
List<int> numbers = null;
// Dans ce cas, on lui affecte une nouvelle liste de nombres entiers
// et numbers n'est plus null
numbers ??= new List<int> { 1, 2, 3, 4, 5, 6 };
// comme numbers n'est plus null, la ligne ci dessous ne fera rien
numbers ??= new List<int> { 10, 20, 30, 40, 50, 60 };
// numbers contient 1, 2, 3, 4, 5, 6

Test de valeur null, l’opérateur ??

L’opérateur de test null-coalescing ?? retourne la valeur de l’opérande de gauche si elle n’est pas null sinon, il évalue l’opérande de droite et retourne son résultat.

Reprenons l’exemple du profil plus haut. Si l’utilisateur n’a pas fourni sa date de naissance une valeur NULL est fournie par la base de données. Dans ce cas, on peut utiliser cet opérateur pour remplacer cette valeur null ainsi

int age = DBProfilGetAge() ?? 0;

Si DBProfilGetAge() fourni une valeur non-null c’est cette valeur qui sera placée dans la variable age. Si DBProfilGetAge() retourne une valeur null, elle sera remplacée par la valeur 0.

Exercice ?

Comme on ne possède pas de base de données, on vous demande de réaliser une méthode de test DBProfilGetAge. Cette méthode simulera des valeurs aléatoires comprises entre 50 et 100 ou null. Chaque appel de la méthode retourne une seule valeur. Le résultat escompté est le suivant:

La méthode à retourné: null
La méthode à retourné: 81
La méthode à retourné: 61

Votre apprenti a commencé une ébauche de programme mais il ne sait pas comment faire des opérateurs ternaires et son programme ne se compile pas. Il vous appel à l’aide. Vous arrivez vers lui et avec vos connaissances vous écrivez les deux opérateurs ternaires et à ajouter les ? manquants 😎.

public static void Main(string[] args)
{
    int age = DBProfilGetAge();
    Console.WriteLine("La méthode à retourné: {0}", /* votre opérateur ternaire */)
}

public static int DBProfilGetAge()
{
    Random rand = new Random();
    int randomAge = rand.Next(1, 101);
    return /* votre opérateur ternaire */;
}

Corrigé

L’opérateur =>

On trouve cet opérateur en tant que corps d’expression. Il est lié aux expressions Lambda mais il peut également être utilisé ainsi :

string GetWeatherDisplay(double tempInCelsius) => tempInCelsius < 20.0 ? "Cold." : "Perfect!";

Console.WriteLine(GetWeatherDisplay(15));  // output: Cold.
Console.WriteLine(GetWeatherDisplay(27));  // output: Perfect!

Code testable ici

Dans cet exemple, une méthode GetWeatherDisplay a été définie avec, comme corps d’expression tempInCelsius < 20.0 ? "Cold." : "Perfect!";.

Exemple avec une propriété

Dans certaines classes on trouve des propriétés en lecture seule qui vont simplement nous fournir le contenu d’un attribut. Le code sans l’opérateur sera équivalent à ceci:

public class Person
{
    string firstName;
    string lastName;

    ...

    public string FullName
    {
        get
        {
            return $"{firstName} {lastName}";
        }
    }
}

En utilisant l’opérateur =>, on peut résumer cette syntaxe ainsi

public class Person
{
    string firstName;
    string lastName;

    ...

    public string FullName => $"{firstName} {lastName}";
}

Lambda

Une expression lambda est une syntaxe permettant de créer des fonctions anonymes en ligne.

Une expression lambda est créée à l’aide de l’opérateur =>. On place tous les paramètres sur le côté gauche de l’opérateur et sur le côté droit on place une expression qui peut utiliser ces paramètres. Cette expression résoudra la valeur de retour de la fonction. Si nécessaire, un {code block} complet peut être utilisé à droite. Si le type de retour n’est pas null, le bloc contiendra une déclaration de retour return.

• Expression lambda qui a une expression comme corps :

  (input-parameters) => expression

• Instruction lambda qui a un bloc d’instructions comme corps :

  (input-parameters) => { <sequence-of-statements> }

Expression Lambda en tant que paramètre de méthode

List<int> listSupSix = listEnVrac.FindAll(x => x > 6);

x => x > 6 est une expression lambda agissant comme un prédicat qui garantit que seuls les éléments supérieurs à 6 de listEnVrac sont renvoyés. x est un nom de variable arbitraire et il contiendra tour à tour, toutes les valeurs de la liste.

Expression Lambda en tant que gestionnaire d’événements

Les expressions Lambda peuvent être utilisées pour gérer des événements, ce qui est utile lorsque:

• Le gestionnaire est court.
• Le gestionnaire n’a jamais besoin d’être désabonné.

Ci-dessous, un exemple de gestionnaire d’événements lambda :

smtpClient.SendCompleted += (sender, args) => Console.WriteLine("Email sent");

Sans utiliser les expressions Lambda, on aurait eu le code suivant:

smtpClient.SendCompleted += new EventHandler(smtpClient_SendCompleted);

private void smtpClient_SendCompleted(object sender, EventArgs e)
{
    Console.WriteLine("Email sent");
}

On remarque que c’est bien le nom de la méthode qui disparaît avec l’utilisation des Lambda. Le nom des paramètres est arbitraire là-aussi. On aurait pu écrire

smtpClient.SendCompleted += (s, a) => Console.WriteLine("Email sent");

Exemple réel, les Animations

Dans le framework .NET MAUI il existe des Animation qui permettent, par exemple, de créer un spinner de téléchargement

L’idée est simple. On choisit un caractère de type spinner, par exemple celui fourni par fontawesome que l’on place dans un Label

On crée ensuite une animation linéaire d’une valeur entière allant de 0 à 360 et on affecte une méthode de callback qui, après chaque changement de valeur de l’animation, va affecter la nouvelle valeur à la propriété Rotation du Label. Ainsi, imaginons que l’Animation augmente sa valeur de 0 à 1, et bien la nouvelle valeur 1 sera affectée à la propriété Rotation du Label et le Label tournera de 1°.

private void Animation_Callback(double animationValue)
{
    LabelLoad.Rotation = animationValue;
}

Animation animate0To360 = new Animation(Animation_Callback, 0, 360, Easing.Linear);

Cette syntaxe peut être abrégée ainsi avec les Lambda

Animation animate0To360 = new Animation(
    (deg) => LabelLoad.Rotation = deg, /* expression Lambda "deg" est un nom de variable arbitraire */
    0, 360, Easing.Linear);

Selon le même principe, la méthode Commit de la classe Animation possède deux méthodes de callback

animate0To360.Commit(
    this,                            //owner
    "rotate",                        //name of your choice
    16,                              //number of milliseconds between each callback
    1000,                            //duration of the animation, in milliseconds
    Easing.Linear,                   //animation type
    (v, c) => LabelLoad.Rotation = 0,//finished callback, what's append at the end of this Animation
    () => true                       //repeat callback, if true, repeat this Animation
);

Le callback finished contient deux paramètres. v est la valeur final au moment où l’animation est arrivée à la fin et c est un booléen permettant d’arrêter l’animation. Dans ce callback, comme on est arrivé au bout de l’animation et donc que notre Label à fait un tour sur lui-même, on le remet dans sa position initiale LabelLoad.Rotation = 0. On n’utilise aucun des deux paramètres.

Le callback repeat n’a pas de paramètre et il retourne une valeur booléenne. true recommence l’animation, false l’arrête.

Remarque

L’aide en ligne de Microsoft ainsi que les tutoriels présents sur Internet vous présenterons tous leurs codes avec des méthodes Lambda. Il est donc impératif de les comprendre.

Code complet .NET MAUI

public partial class MainPage : ContentPage
{
    private Animation animate0To360;
    private bool animate;

    public MainPage()
    {
        InitializeComponent();
    }

    protected override void OnAppearing()
    {
        animate = false;
        ToogleAnim.Text = "Animate please";
        animate0To360 = new Animation((deg) => LabelLoad.Rotation = deg, 0, 360, Easing.CubicInOut);
    }

    public void Toogle_Click(object sender, EventArgs e)
    {
        if (!animate)
        {
            animate0To360.Commit(this, "rotate", 16, 1000, Easing.CubicInOut,
                (v, c) => LabelLoad.Rotation = 0,
                () => animate
            );
        }
        else
        {
            this.AbortAnimation("rotate");
        }

        animate = !animate;
        ToogleAnim.Text = animate ? "Animated" : "Animate please";
    }
}

Exercice Spinner Forms

En C# Forms il n’existe pas d’Animations telles qu’on les trouve dans les Framework basés sur du MVVM tel que WPF. Est-ce que ça signifie qu’il n’est pas possible de faire un spinner ?

Bien sûr que non. À vous de jouer ! Trouvez la solution la plus simple possible. Une fois que vous aurez réalisé votre solution, vous pouvez prendre le code ci-dessous.

Le code de la solution ci-dessus

Vous y trouverez deux gestionnaires d’événements Click, un par bouton.

Spinner.Designer.cs

...
//
// btnVisible
//
this.btnVisible.Location = new System.Drawing.Point(51, 195);
this.btnVisible.Name = "btnVisible";
this.btnVisible.Size = new System.Drawing.Size(75, 23);
this.btnVisible.TabIndex = 2;
this.btnVisible.Text = "Hide";
this.btnVisible.UseVisualStyleBackColor = true;
this.btnVisible.Click += new System.EventHandler(this.btnVisible_Click);
...

Spinner.cs

private void btnVisible_Click(object sender, EventArgs e)
{
    // Bla bla...
}

Transformez ces deux événements en Lambda, c’est-à-dire, en deux méthodes anonymes.

Version Lambda

Exercices Lambda

Vous devez coder chaque exercice. Vous devez créer un projet par exercice et placer tous les projets dans une seule solution.

Exercice 1

Soit le tableau d’entier data ci-dessous. On vous demande de compléter l’expression Lambda permettant d’obtenir un nouveau tableau contenant uniquement les valeurs paires

int[] data = { 1, 2, 4, 5, 6, 10 };
int[] even = data.Where(     /* votre lambda */     ).ToArray();

Exercice 2

Soit la liste de personnes ci-dessous. On vous demande de compléter l’expression Lambda permettant d’obtenir les personnes dont le FullName commence par “A”

public class Person
{
    private string firstName;
    private string lastName;
    public Person(string firstName, string lastName)
    {
        this.firstName = firstName;
        this.lastName = lastName;
    }

    public string FullName => $"{firstName} {lastName}";
}

class Program
{
    static void Main(string[] args)
    {
        List<Person> persons = new List<Person> {
            new Person("Alain", "Proviste"),
            new Person("Anne", "Onime"),
            new Person("Déborah", "Dirouge"),
            new Person("Cécile", "Our")
        };

        //you can use string.StartsWith
        List<Person> filtered = persons.Where(  /* votre lambda */  ).ToList();
    }
}

Exercice 3

Soit le programme suivant

class Program
{
    static void TimerCallback(Object? state)
    {
        Console.WriteLine("Timer tick at : {0}", DateTime.Now.ToString("H:mm:ss.fff", CultureInfo.CurrentCulture));
    }
    static void Main(string[] args)
    {
        int attenteAvantStart = 2000; // 2 secondes
        int interval = 100; // 100 ms

        Timer timer = new Timer(callback: TimerCallback); // <-- ICI ICI ICI ICI

        timer.Change(attenteAvantStart, interval);

        Console.WriteLine("Press any key to quit");
        // "Tant que" aucune touche n'est pressée
        while (!Console.KeyAvailable) ;
        // Supprime le timer
        timer.Dispose();
    }
}

On vous demande d’écrire le même programme en remplaçant la méthode de callback TimerCallback par une fonction Lambda.

Exercice 4

Soit les exemples de méthode ci-dessous

Action line = () => Console.WriteLine();
Func<double, double> cube = x => x * x * x;
Func<int, int, bool> testForEquality = (x, y) => x == y;
Func<int, string, bool> isTooLong = (int x, string s) => s.Length > x;

En vous aidant si besoin de l’aide en ligne de Microsoft sur les Action et les Func<T,TResult>, on vous demande d’utiliser chacune de ces méthodes dans un programme simple. Par exemple:

Func<double, double> carre = (x) => x * x;
double result = carre(3);// result = 9

Exercice 5

On vous demande de réaliser une méthode Lambda permettant de calculer la factorielle d’un nombre x de manière à pouvoir l’utiliser ainsi

int result = f(3); // result = 6
result = f(4); // result = 24

Exercice 6

Pour terminer, réaliser un exercice plus réaliste. Sur le site github vous trouvez un paquet NuGet permettant de parser les paramètres de la ligne de commande. Le paquet se nomme CommandLineParser.

Sur la page d’accueil du site on trouve plusieurs exemple que l’on peut mixer pour obtenir le code ci-dessous

using CommandLine;

public class Options
{
    [Option('v', "verbose", Required = false, HelpText = "Set output to verbose messages.")]
    public bool Verbose { get; set; }

    [Option('m', "message", Required = true, HelpText = "Set output message.")]
    public string? Message { get; set; }
}

class Exercice6
{
    static void Main(string[] args)
    {
        Parser.Default.ParseArguments<Options>(args)
          .WithParsed(RunOptions)
          .WithNotParsed(HandleParseError);
    }
    static void RunOptions(Options opts)
    {
        // opérateur ternaire sur Verbose
    }
    static void HandleParseError(IEnumerable<Error> errs)
    {
        // IEnumerable<Error> -> List.Foreach( votre lambda )
    }
}

Votre travail consiste à remplacer les deux méthodes par des expressions Lambda.

• WithParsed utilisera un opérateur ternaire sur l’option Verbose pour afficher le Message si Verbose est true et le texte "Nothing" la cas échéant.
• WithNotParsed transformera le IEnumerable en List grâce à la méthode ToList pour pouvoir utiliser la méthode ForEach de la List. Dans la méthode ForEach de la liste, vous placerez une expression Lambda qui affichera le message "Le parser à rencontrer une erreur de type: {Erreur.Tag}"

Pour terminer, vous n’utiliserez pas le Parser.Default mais votre propre Parser que vous instancierez ainsi

Parser parser = new Parser(config => config.HelpWriter = null);

Dans mon programme j’ai fait des tests avec les arguments suivants

• Arguments: Aucun ↣ affichage de "Nothing"
• Arguments: -m Mon_message ↣ affichage de "Nothing"
• Arguments: -m Mon_message -v ↣ Affichage de "Mon_message"
• Arguments: -m Mon_message -v -x ↣ Affichage de "Le parser à rencontrer une erreur de type: UnknownOptionError"

La sérialisation

Sérialisation Json

Commençons par un peu de terminologie. JSON signifie « JavaScript Object Notation » et la sérialisation est le procédé qui permet de passer d’un état d’objet vers une forme de données qui peut être persistée, par exemple dans un fichier texte, ou transportée sur l’Internet via HTTP.

Voici un exemple simple de sérialisation d’un objet Cylindre vu plus bas.

public static async Task Main(string[] args)
{
    Cylindre cylindre = new Cylindre(10.0, 2.3);

    FileStream f = File.OpenWrite("temp.dat");                          // sauvegarde dans un fichier
    string jsonString = JsonSerializer.Serialize<Cylindre>(cylindre);   // sérialsation
    await f.WriteAsync(Encoding.UTF8.GetBytes(jsonString));             // écriture asynchrone
    await f.DisposeAsync();                                             // fermeture du fichier

    Console.ReadKey();
}

Le fichier temp.dat contient alors

{"Hauteur":10,"Rayon":2.3}

On peut imaginer transférer ce fichier à une autre personne qui sera en mesure de re-créer un objet Cylindre pour autant qu’elle possède la classe.

public static async Task Main(string[] args)
{
    FileStream openStream = File.OpenRead("temp.dat");
    Cylindre? cylindre = await JsonSerializer.DeserializeAsync<Cylindre>(openStream);
    await openStream.DisposeAsync();

    Console.WriteLine($"Hauteur: {cylindre?.Hauteur}\nRayon: {cylindre?.Rayon}\nSurface: {cylindre?.Surface():F2}");
    Console.ReadKey();
}

Hauteur: 10
Rayon: 2.3
Surface: 177.75

Génération de classes C♯

Imaginons que nous soyons en possession d’un flux JSON tel que celui ci-dessous

{
  "type": "FeatureCollection",
  "features": [
    {
      "type": "Feature",
      "properties": {
        "version": 1.0
      },
      "geometry": {
        "type": "LineString",
        "coordinates": [
          [6.866025924682617, 46.96244775337095],
          [6.86920166015625, 46.96438077654255],
          [6.870081424713135, 46.965230113121564],
          [6.870746612548827, 46.96634301650308]
        ]
      }
    }
  ]
}

Il est possible de générer les classes C# dont nous aurons besoin dans notre application en utilisant des outils. Parmi ces outils, on trouve le site web

Voici ce que le site nous propose comme class pour le flux ci-dessus:

public class Feature
{
    public string type { get; set; }
    public Properties properties { get; set; }
    public Geometry geometry { get; set; }
}

public class Geometry
{
    public string type { get; set; }
    public List<List<double>> coordinates { get; set; }
}

public class Properties
{
    public double version { get; set; }
}

public class Root
{
    public string type { get; set; }
    public List<Feature> features { get; set; }
}

La classe Root devient votre classe de base, par exemple, GeoJSON.

À partir de la version Visual Studio 2022, il est également possible d’utiliser l’outil intégré. Pour cela, il faut copier votre flux JSON dans le presse-papier et ensuite, dans Visual Studio, Menu contextuel du Projet / Ajouter / Classe. Dans le fichier créer, on supprime tout à part le namespace ainsi

namespace MonNamespace;

Ensuite, Edition / Collage spécial / Coller le code JSON en tant que classes

namespace MonNamespace;

public class Rootobject
{
    public string type { get; set; }
    public Feature[] features { get; set; }
}

public class Feature
{
    public string type { get; set; }
    public Properties properties { get; set; }
    public Geometry geometry { get; set; }
}

public class Properties
{
    public float version { get; set; }
}

public class Geometry
{
    public string type { get; set; }
    public float[][] coordinates { get; set; }
}

On peut ensuite désérialiser nos données

On peut remarquer que les classes ne sont pas pareilles. On peut noter que l’outil de Visual Studio préfère les tableaux au List

public List<Feature> features { get; set; } // json2csharp
public Feature[] features { get; set; }     // visual studio

public List<List<double>> coordinates { get; set; }  // json2csharp
public float[][] coordinates { get; set; }           // visual studio

public double version { get; set; } // json2csharp
public float version { get; set; }  // visual studio

{
  "type": "FeatureCollection",
  "features": [
    {
      "type": "Feature",
      "properties": {
          "version": "1.0" <--- Exception
      },

Les classes

Vous avez déjà vu les concepts liés à la programmation orientée objet en Java. À quelques exceptions, notamment les propriétés qui remplacent les méthodes getter et setter du Java, programmer des classes et instancier des objets en C# revient au même.

Le site de Microsoft regorge d’exemples et de tutoriels liés aux classes. Par exemple :

• Objects
• Classes

Le site developpez.com propose aussi des cours complets.

Exercice traqueur

Pour vous remettre en jambe, ou vous remettre dans le bain, je vous propose un exercice basé sur un exemple réel.

Contexte

Pour suivre un vélo, un colis ou une voiture, on peut lui attacher un traqueur GPS. En utilisant le réseau LoRa par intermédiaire des passerelles thethingsnetwork on peut faire du suivit de position gratuitement sans payer de redevance à un opérateur de téléphonie. Le capteur Dragino LGT-92 remplit exactement cette fonction.

Après avoir configurer l’application sur le site thethingsnetwork on peut recevoir sur notre propre site, les informations relayées par une des passerelles du réseau thethingsnetwork. Les informations se présentent ainsi :

{
  "end_device_ids": {
    "device_id": "eui-a8404134e182ff4c",
    "application_ids": {
      "application_id": "pif-bike"
    },
    "dev_eui": "A8404134E182FF4C",
    "join_eui": "A000000000000102",
    "dev_addr": "260BCA94"
  },
  "correlation_ids": [
    "as:up:01GB2N4TJEE8Q26066RY87SXA5",
    "gs:conn:01G9YKB58R24D89HRXSW9T0RQT",
    "gs:up:host:01G9YKB5CXYBDGS8HDYQTYGA72",
    "gs:uplink:01GB2N4TBYJ8D74N34XK19P9P8",
    "ns:uplink:01GB2N4TBZ7FQQDVD7YCVD984C",
    "rpc:/ttn.lorawan.v3.GsNs/HandleUplink:01GB2N4TBZH9B0DRAAQ1Q1ABK9",
    "rpc:/ttn.lorawan.v3.NsAs/HandleUplink:01GB2N4TJDMVQT86W8FBDBYW0M"
  ],
  "received_at": "2022-08-22T11:31:28.974361916Z",
  "uplink_message": {
    "session_key_id": "AYLBMdoVTjlPoGNikaD47g==",
    "f_port": 2,
    "f_cnt": 68,
    "frm_payload": "AsziFABowQgPxmQ=",
    "decoded_payload": {
      "ALARM_status": false,
      "BatV": 4.038,
      "FW": 164,
      "LON": true,
      "MD": "Move",
      "latitude": 46.981652,
      "longitude": 6.86516
    },
    "rx_metadata": [
      {
        "gateway_ids": {
          "gateway_id": "chneuch-fcc23dfffe0ddcf3",
          "eui": "FCC23DFFFE0DDCF3"
        },
        "time": "2022-08-22T11:31:28.753438Z",
        "timestamp": 2772742172,
        "rssi": -111,
        "channel_rssi": -111,
        "snr": -18,
        "location": {
          "latitude": 46.99963179059538,
          "longitude": 6.948739886283875,
          "altitude": 550,
          "source": "SOURCE_REGISTRY"
        },
        "uplink_token": "CiYKJAoYY2huZXVjaC1mY2MyM2RmZmZlMGRkY2YzEgj8wj3//g3c8xCc4JKqChoMCJDSjZgGEKrfxe0CIODav6LZgpQCKgwIkNKNmAYQsJqi5wI=",
        "channel_index": 7,
        "received_at": "2022-08-22T11:31:28.766603178Z"
      },
      {
        "gateway_ids": {
          "gateway_id": "a840411ecc544150",
          "eui": "A840411ECC544150"
        },
        "time": "2022-08-22T11:31:28.786141Z",
        "timestamp": 84387636,
        "rssi": -144,
        "channel_rssi": -144,
        "snr": -20.8,
        "location": {
          "latitude": 46.95884322684129,
          "longitude": 6.833724081516267,
          "altitude": 490,
          "source": "SOURCE_REGISTRY"
        },
        "uplink_token": "Ch4KHAoQYTg0MDQxMWVjYzU0NDE1MBIIqEBBHsxUQVAQtM6eKBoMCJDSjZgGEN7frPkCIKDGlK+6AioMCJDSjZgGEMie7vYC",
        "channel_index": 7,
        "received_at": "2022-08-22T11:31:28.791359454Z"
      }
    ],
    "settings": {
      "data_rate": {
        "lora": {
          "bandwidth": 125000,
          "spreading_factor": 12
        }
      },
      "coding_rate": "4/5",
      "frequency": "867900000",
      "timestamp": 2772742172,
      "time": "2022-08-22T11:31:28.753438Z"
    },
    "received_at": "2022-08-22T11:31:28.767295430Z",
    "consumed_airtime": "1.482752s",
    "locations": {
      "frm-payload": {
        "latitude": 46.981652,
        "longitude": 6.86516,
        "source": "SOURCE_GPS"
      }
    },
    "version_ids": {
      "brand_id": "dragino",
      "model_id": "lgt92",
      "hardware_version": "_unknown_hw_version_",
      "firmware_version": "1.6.6",
      "band_id": "EU_863_870"
    },
    "network_ids": {
      "net_id": "000013",
      "tenant_id": "ttn",
      "cluster_id": "eu1",
      "cluster_address": "eu1.cloud.thethings.network"
    }
  }
}

Travail

Il n’y a pas de notion d’héritage dans ce flux JSON, uniquement des relations de type A UN ou A PLUSIEURS.

Les fichiers se trouvent ici.

On vous demande de mettre en place la(les) classe(s) C# permettant d’accueil le flux JSON. Attention, il y a deux types de fichier et donc deux types de flux JSON :

• uplink_message > ~1500B
• location_solved

Ils ne contiennent pas les mêmes informations. Dans les fichiers uplink_message il y a des informations supplémentaires telles que :

• ALARM_status qui correspond au gros bouton rouge sur l’appareil
• BatV qui renseigne sur l’état de la batterie
• Etc…

Une fois en possession des positions GPS, on vous demande d’afficher le trajet sur une carte telle qu’OpenStreetMap.

Ci-dessous vous pouvez voir un exemple d’application fonctionnelle. On y voit en rouge le trajet d’un vélo qui a fait un aller / retour à Marin-Centre depuis Cormondrèche.

Librairie utilisé : WinFormsMapControl

Suppléments

• Au moins une méthode ou un gestionnaire d’événement doit être codé en version Lambda
• La ou les classes issues de la sérialisation doivent être dans un fichier à part
• La ou les classes issues de la sérialisation doivent permettre l’affichage des informations latitude/longitude à l’aide de la méthode surchargée ToString()
• Implémentez la surcharge de l’opérateur ==. La comparaison se fera sur le champ recevied_at. Pour faire cet opérateur, vous devrez implémenter l’opérateur != et les méthodes GetHashCode et Equals.
• L’application doit centrer la carte sur le trajet. Pour ce faire vous devez apprendre à centrer la carte dans la librairie WinFormsMapControl mais aussi trouver le rectangle qui englobe le trajet.

Pour trouver le rectangle qui engloble le trajet, il faut faire un raisonnement simple.

On cherche les valeurs minimales et maximales de latitude et de longitude. On peut alors créer un rectangle à partir de ces valeurs.

Pour connaître le niveau de zoom à appliquer, c’est un peu plus compliqué. Il faut calculer la distance entre les deux points les plus éloignés, par exemple, le coin haut-gauche et le coin bas-droite du précédent rectangle. On peut alors calculer le niveau de zoom à appliquer en fonction de cette distance.

Pour calculer la distance entre deux points GPS, on peut utiliser le code présent ici.

Pour déterminer le niveau de zoom à appliquer, il faut comprendre comment fonctionne le zoom dans OpenStreetMap. On peut se simplifier la tâche en utilisant uniquement les valeurs à l’équateur.

Source du programme ci-dessus

Exercice analyse spectrale

On vous fournit un programme fonctionnel permettant la capture de son provenant du Système. Par exemple, si vous êtes entrain de visionner une vidéo YouTube et bien ce programme en capture le son.

Source

Dans le code, on trouve deux variables principales. fftFreq et fftPower de type double[]. fftFreq contient les fréquences musicales auxquels les mesures présentent dans fftPower ont étés réalisées. Les mesures peuvent être faite en dB ou en W via la variable booléenne decibel.

Voici par exemple l’écoute d’un son pur à 1000Hz

Plus le trait est haut, plus la musique à cette fréquence était forte que se soit en dBou en W.

Le fonctionnement qui se cache derrière ce programme ce nomme Transformée de Fourier rapide, en anglais Fast Fourier Transformation ou FFT. Comme on peut le voir sur l’image ci-dessous, une FFT décompose un son ♫ ♬ complexe (en rouge à gauche) en son ♩ ♪ de fréquence unique (en bleu à droite). On passe alors d’une représentation temporelle à une représentation fréquentielle (axe des abscisses).

C’est les valeurs de ce graphique bleu qui se trouvent dans le tableau fftPower et l’axe des abscisses dans fftFreq.

Vous pouvez trouver une bonne explication de cette transformée de Fourier dans la vidéo ci-dessous

Le programme fournit utilise plusieurs librairies:

• Raylib pour l’affichage
• NAudio pour la capture du son
• FFTSharp pour divers travaux sur le son comme des filtrages, du windowing et la fameuse FFT

Votre travail

Votre travail consiste à créer un ensemble de class permettant au programmeur d’avoir une représentation graphique de la musique qu’il entend. Par exemple:

Le code du programmeur se résumerai, par exemple, à quelque chose comme :

private Equalizeur equalizeur;

public MainForm()
{
    equalizeur = new Equalizeur(width:600, height:400);
    equalizeur.Location = new Point(0, 0);

    this.Controls.Add(equalizeur);
    this.Paint += (s, e) =>
    {
        spectrum = equalizeur.Spectrum;
        // Code de dessin
    }

    private void Timer_Tick(object sender, EventArgs e)
    {
        Invalidate()
    }

Diagramme de classes

L’enseignant s’est prêté à l’exercice et il a imaginé le diagramme ci-dessous.

L’Equalizeur comporte des Column. Les Column représentent une bande de fréquence, par exemple, de 20Hz (FMin) à 75Hz (FMax). Chaque Column contient des View. Les vues permettent d’afficher la puissance moyenne du signal dans une barre. Ce qui pourrai donner par exemple :

Et en fonctionnement

La bande de fréquence audible par l’oreille humaine va de 20Hz à 20kHz. Si on place 10 colonnes dans la largeur de l’équaliseur, on peut dire que chaque colonne représente une bande de fréquence de :

$$f=\frac{20000-20}{10}=1998Hz$$

Plus il y a de colonne, plus l’équaliseur est précis. En effet, dans cet exemple, chaque colonne montre la valeur moyenne de 1998 fréquences, hors si on imagine que sur ces 1998 fréquences, 1900 ont une puissance de 0 et 98 ont une puissance de 100, il est difficile de représenter cette situation. Si on fait une simple moyenne on obtient

$$Pm=\frac{(1900*0)+(98*100)}{1998}=\frac{9800}{1998}=4.9$$

On aurai donc une colonne avec des vues très basse, pratiquement tout en bas, seul le premier carré vert serait allumé alors qu’il y a quand même 98 fréquences qui étaient au maximum! Au contraire, si on ne prend que la valeur maximale, on aura un colonne au maximum alors qu’il y avait 1900 fréquences à 0.

Avec 64 barres

$$f=\frac{20000-20}{64}=312Hz$$

$$Pm=\frac{(1900*0)+(98*100)}{312}=\frac{9800}{312}=31.4$$

C’est déjà mieux…

Après moult expériences, il s’avère qu’une bande de fréquence comprise entre 20Hz et 3kHz et préférable pour l’affichage. Le reste des fréquences est peut représentatif et peut comporter des fréquences parasites dite de repliement.

MIS⊥∀ʞƎ

Attention, suivant votre modélisation il peut y avoir potentiellement un gros problème. En effet, si votre diagramme de classe est construit autour du Framework .NET Forms, par exemple :

• Votre classe Equalizeur hérite de Control
• Votre modélisation utilise dans une classe, une propriété de type Color qui n’existe que dans le Framework .NET Forms

Et bien cela rendra vos classes inutilisables avec une autre Framework tel que WPF, Unity, Console, Raylib, SDL ou Löve.

Il y a donc deux chemins possibles.

• On choisit à l’avance le comment l’équaliseur va s’afficher et dans ce cas on crée un équaliseur utilisable uniquement dans le Framework choisi
• On ne choisit pas le comment mais uniquement le quoi. Dans ce cas, on créera un équaliseur qui pourra s’afficher dans n’importe quel Framework mais ce sera au programmeur de finaliser le code d’affichage puisque c’est lui qui choisira la librairie graphique

C’est cette dernière version qui vous est demandée.

Une fois votre modélisation terminée, je pourrai vous imposer un Framework pour mettre en œuvre votre équaliseur. Je vous dirai par exemple, faite un POC avec Löve .

Documentation de code

La documentation est une partie importante de la programmation.

Elle est souvent générée avec des outils automatiques tel que doxygen, Sandcastle, Hugo ou encore pandoc. Ces outils sont capables de faire beaucoup de choses tout seul. Par exemple, ils sont capables de voir dans quel assembly se trouve votre classe, quelles sont ses méthodes, ses propriétés et ses attributs, quels sont les types de retour, les types des paramètres, quelle est la version actuelle, la précédente etc. mais ils ne sont pas capables de mettre un texte humain tel que:

Accelerometer data of the acceleration of the device in three dimensional space

C’est là votre job. C’est à vous d’écrire le texte compréhensible sur lequel un humain s’appuiera pour comprendre le fonctionnement de votre code.

// If you're reading this, that means you have been put in charge of my
//  previous project. I am so, so sorry for you. God speed.

Exemple

Prenons comme exemple cette documentation de Microsoft .NET MAUI

Il n’y a pas, chez Microsoft, une personne en charge de coder un site HTML statique correspondant à celui-ci. Si c’était le cas, cette personne devrait dialoguer avec le(s) développeur(s) pour bien comprendre ce que fait son code et ensuite transcrire cela en HTML. Elle devrait également mettre à jour le site à chaque fois que le codeur fait une modification dans son code source. Par exemple, si le codeur ajoute un paramètre à une méthode, ou change un type de retour😢. On pourrait aussi demander au codeur de réaliser ce site web en collaboration avec tous les autres codeurs. Ce n’est pas réaliste, ça coûterai cher et ce serait du travail de 🤡. On va plutôt demander au codeur de faire le nécessaire pour qu’un script réalise automatiquement ce site 😎.

Le codeur placera directement dans les fichiers sources les informations nécessaires à la réalisation du site web. Si on se rend dans le code source de l’Accelerometer sur github, on y trouve plusieurs commentaires.

Accelerometer.shared.cs

/// <summary>
/// Accelerometer data of the acceleration of the device in three dimensional space.
/// </summary>
public static class Accelerometer
{
    ...
}

Documentation généraliste

Un autre type de documentation correspond au passage de fichiers Markdown à un site web d’informations plus généraliste. On ne détail pas telle ou telle méthode avec ses paramètres et son canal de retour mais on explique plus généralement l’utilisation, par exemple, d’un composant graphique. On peut le voir avec cette source AbsolutLayout

---
title: "AbsoluteLayout"
description: "The .NET MAUI AbsoluteLayout is used to position and size elements using explicit values, or values proportional to the size of the layout."
ms.date: 01/09/2023
---

# AbsoluteLayout

[![Browse sample.](~/media/code-sample.png) Browse the sample](/samples/dotnet/maui-samples/userinterface-absolutelayout)

:::image type="content" source="media/absolutelayout/layouts.png" alt-text=".NET MAUI AbsoluteLayout." border="false":::

The .NET Multi-platform App UI (.NET MAUI) <xref:Microsoft.Maui.Controls.AbsoluteLayout> is used to position and size children using explicit values. The position is specified by the upper-left corner of the child relative to the upper-left corner of the <xref:Microsoft.Maui.Controls.AbsoluteLayout>, in device-independent units. <xref:Microsoft.Maui.Controls.AbsoluteLayout> also implements a proportional positioning and sizing feature. In addition, unlike some other layout classes, <xref:Microsoft.Maui.Controls.AbsoluteLayout> is able to position children so that they overlap.

Qui offre le rendu suivant sur le site de Microsoft

Le principe reste le même. Le codeur écrit directement son fichier Markdown dans son dépôt git. Ce fichier est ensuite utiliser pour générer le site web d’informations.

On peut voir au début du fichier Markdown du YAML Front Matter. Ce sont un ensemble de valeur qui seront utilisées par le script de génération du site web pour, par exemple, définir le titre de la page.

Votre documentation

Vos classes de l’équaliseur seront documentées, par exemple en utilisant les balises XML Tags de Microsoft (d’autres styles de balises peuvent être utilisées) de manière à rendre votre code compréhensible par un autre programmeur.

Pour votre documentation, on vous demande d’utiliser l’outil doxygen pour construire une documentation HTML.

Vidéo explicative doxygen

Vous pouvez (devez) utiliser le wizard pour créer votre premier fichier de configuration.

Le wizard vous permettra d’avoir un fichier Doxyfile de base avec tous les paramètres courants correctement définit.

Par la suite, vous devrez être en mesure d’utiliser doxygen en ligne de commande pour pouvoir générer automatiquement votre documentation via un script par exemple.

ferrarip@LMB-101-00 MINGW64 /d/spectrum/doxygen (main)
$ doxygen Doxyfile
D:/spectrum/Program.cs:8: warning: Compound Program is not documented.
D:/spectrum/ColorUtils.cs:8: warning: Compound RaySpectrum::ColorRGB is not documented.
D:/spectrum/ColorUtils.cs:22: warning: Compound RaySpectrum::ColorUtils is not documented.
D:/spectrum/Column.cs:6: warning: Compound RaySpectrum::Column is not documented.
D:/spectrum/View.cs:3: warning: Compound RaySpectrum::View is not documented.
D:/spectrum/ColorUtils.cs:10: warning: Member ColorRGB(byte r=0, byte g=0, byte b=0) (function) of struct RaySpectrum::ColorRGB is not documented.

Cette documentation doit pouvoir être générée depuis un poste Linux, par exemple, une machine Ubuntu WSL (vue en première leçon).

Remarques

Lors du lancement de la commande doxygen depuis un poste Linux, j’ai obtenu des messages d’erreurs supplémentaires. Sans doute parce que le fichier de configuration Doxyfile a été crée par le wizard depuis Windows ou alors parce que les versions installées sur Windows et sur Linux ne sont pas les mêmes.

ferrarip@LMB-101-00:/mnt/d/spectrum$ doxygen doxygen/Doxyfile
warning: ignoring unsupported tag 'CREATE_SUBDIRS_LEVEL' at line 93, file doxygen/Doxyfile
warning: ignoring unsupported tag 'SHOW_HEADERFILE' at line 632, file doxygen/Doxyfile
warning: ignoring unsupported tag 'WARN_IF_INCOMPLETE_DOC' at line 850, file doxygen/Doxyfile

...

Computing class relations...
/mnt/d/spectrum/Program.cs:8: warning: Compound Program is not documented.
/mnt/d/spectrum/ColorUtils.cs:8: warning: Compound RaySpectrum::ColorRGB is not documented.
/mnt/d/spectrum/ColorUtils.cs:22: warning: Compound RaySpectrum::ColorUtils is not documented.

Comme on peut le voir, les warning nous indiquent que certaines parties de code ne sont pas documentées. Il ne devrait pas y avoir de warning dans votre documentation.

Une fois que la documentation se génère correctement, sans erreurs et sans warnings depuis le poste Linux, on peut mettre en place une génération automatique de documentation lors d’un push sur un gestionnaire de version tel que gitlab.

Génération automatique

M. Steeve Droz a réalisé un cours sur le DevOps.

Son cours a été réalisé sur le serveur git de l’école mais il peut évidement être réalisé sur le serveur git de M. Huguenin.

Dans une utilisation standard d’un dépôt de code source, on publie généralement notre code sur une branche dev. Lorsque le code est prêt à être publié, on le fusionne avec la branche main. Quand le code est prêt à être publié en tant que nouvelle version, on ajoute un tag sur la branche main. Par exemple v1.0.0. Pour les numéros de version, on utilise le Semantic Versioning.

En respectant cette méthode de travail, on peut mettre en place un système de génération automatique de la documentation. Par exemple, on peut imaginer que :

• Lorsque je réalise un commit sur la branche main et que ce commit contient un tag, j’aimerais démarrer un conteneur.

Dans ce conteneur:

• Il y aura automatiquement le contenu de mon dépôt qui y sera copié, à savoir mes codes sources et tout ce qui est présent dans le dépôt
• Je serai placer à la racine. Je pourrai donc atteindre un fichier grâce à un chemin relatif. Par exemple, si mon fichier de configuration doxygen se trouve dans le répertoire documentation/Doxyfile je pourrai lancer la commande $ doxygen documentation/Doxyfile
• Je démarrerai la génération de la documentation
• Un fois la documentation générée, je la publierai sur un site web

graph LR;
    A[Poste développement] -->|PUSH| B[Serveur git];
    B[Serveur git] -->|IF 'main' && 'tag'| C[Conteneur LXC ou docker avec copie dépôt];
    C((Conteneur LXC ou docker<br>génération HTML))-->D;
    D[Conteneur LXC ou docker]--> |ftp|E[starks.s2dev.ch];

Si on ne possède pas de serveur distant pour publier le site web, on pourra se contenter de vérifier dans les artifacts que la documentation s’est bien générée.

Sans publication, c’est-à-dire, uniquement pour la génération de la documentation HTML, le fichier YAML se résume à ceci

stages:
  - build-doc

workflow:
  rules:
    - if: "$CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH" # si on travail sur la branche main uniquement

build-job:
  stage: build-doc
  before_script:
    - apt-get update # mise-à-jour des dépôts du conteneur
    - apt-get install -y doxygen # installation de doxygen

  script:
    - doxygen doxygen/Doxyfile # exécute la génération de la documentation

  artifacts:
    expire_in: 10min # les anciens résultats seront disponibles pendant 10 minutes
    untracked: true # prend tout les fichiers mêmes ceux ignorés par .gitignore
    paths:
      - doc # on place dans l'artifact le dossier "doc"

Output

Running with gitlab-runner 15.1.0 (76984217)
...

$ doxygen doxygen/Doxyfile
Doxygen version used: 1.9.1

...

Generating docs for namespace RaySpectrum
Generating docs for compound RaySpectrum::ColorRGB...

...

Uploading artifacts for successful job 00:01
Uploading artifacts...

...

Job succeeded

Bien sûr, cela suppose que le dossier doxygen et son fichier de configuration Doxyfile existe. La commande va générer la documentation dans un dossier doc et c’est ce dossier qui est placer dans l’artifact. Attention, si la génération se fait dans le dossier doc c’est parce que c’est explicitement demandé dans le fichier Doxyfile.

La publication sur le site web

Nous sommes contraints par des règles de sécurité du réseau et des configurations que nous ne maitrisons pas. Seul le service informatique de l’école à la possibilité de modifier, d’ouvrir, de permettre un publication FTP. Jusqu’en décembre 2024, il n’était pas possible de faire une publication FTP depuis le serveur git de l’école. Maintenant, les choses ont changées. Voici comment procéder.

publication FTP

1. L’enseignant vous fournit un compte FTP (username / password) permettant la connection au serveur starks.s2dev.ch
2. Par défaut, lors d’une connexion FTP, vous vous retrouvez dans le dossier /root/. Vous devez créer un dossier à votre nom, par exemple /root/ferrari. C’est dans ce dossier que vous ferez votre publication.
3. Votre dépôt comportera des variables CI/CD FTP_USER et FTP_PASS qui contiendront respectivement votre nom d’utilisateur et votre mot de passe FTP. Votre dépôt ne doit donc pas être public.
4. Vous devrez modifier votre fichier .gitlab-ci.yml pour ajouter une étape de publication FTP.
5. Dans le fichier .gitlab-ci.yml, en utilisant le tag docker, vous pourrez utiliser un conteneur plus rapide que les anciens lxc

Settings de la VM -> Options -> Shared Folders 
  x Always enabled

  Add 
    Name : ftp
    Host path: X:/Chemin/de/votre/choix/ftp
    Attributes 
          x Enabled

$ sudo nano /etc/fuse.conf

# uncomment the line
user_allow_other
 
$ /usr/bin/vmhgfs-fuse .host:/ftp  /home/ubuntu/ftp -o  subtype=vmhgfs-fuse,allow_other
$ mount
...
vmhgfs-fuse on /home/ubuntu/ftp type fuse.vmhgfs-fuse (rw,nosuid,nodev,relatime,user_id=1000,group_id=1000,allow_other)
$ ls -l ftp
total 0