Cette semaine, nous publions une nouvelle version de notre librairie C# qui apporte quelques nouveautés intéressantes: la librairie est désormais disponible par l'intermédiaire du gestionnaire de package NuGet, .NET Core 2 est supporté et pour finir nous avons réussi à nous passer des entrées dllmap qu'il fallait ajouter lors de l'utilisation de notre librairie avec Mono.
Commençons par le dernier point: Plus besoin d'ajouter des entrées dllmap dans le fichier app.config.
Comme nous l'avions expliqué il y a trois semaines, la librairie C# est composée de code C# mais aussi d'une librairie dynamique "yapi" qui est compilée pour chaque OS. Sous Windows, la machine virtuelle .NET est capable de retrouver automatiquement la bonne version de cette librairie, mais avec Mono il fallait ajouter des entrées dans le fichier de configuration de l'application pour que la librairie fonctionne. Ce n'est désormais plus nécessaire.
Il faut simplement copier dans le répertoire de l’exécutable les différentes versions de la librairie "yapi" qui se trouvent dans le sous-répertoire Sources/dll. Concrètement pour que votre application fonctionne avec Mono, vous devez avoir dans le répertoire de votre exécutable les fichiers suivants:
- yapi.dll : la librairie "yapi" pour Windows 32 bits
- amd64/yapi.dll : la librairie "yapi" pour Windows 64 bits
- libyapi-i386.so : la librairie "yapi" pour Linux 32 bits
- libyapi-amd64.so : la librairie "yapi" pour Linux 64 bits
- libyapi-armhf.so : la librairie "yapi" pour Linux ARM
- libyapi.dylib : la librairie "yapi" pour macOS (64 bits)
- libyapi32.dylib : la librairie "yapi" pour macOS (32 bits)
A l’exécution, notre librairie détecte automatiquement l'OS et charge la bonne version de la librairie.
.NET Core 2.x
La suppression des entrées dllmap nous a permis d'ajouter le support pour .NET Core 2.x. .NET Core est une nouvelle implémentation du standard .NET fait par Microsoft.
Cette implémentation a les avantages suivants:
- Les systèmes d’exploitation Windows, macOS et Linux sont supportés
- Les processeurs Intel 32 ou 64 bits sont supportés pour tous les OS ainsi que les processeurs ARM mais uniquement pour Linux
- Le projet est Open Source (https://github.com/dotnet/core)
- Microsoft contribue activement au développement
Pour plus d'informations sur ce qu'est .NET Core, nous vous laissons consulter la documentation faite par Microsoft.
Pour utiliser la librairie C# dans un projet .NET Core, la procédure est identique: il faut ajouter les fichiers .cs et copier les fichiers du sous-répertoire Sources/dll dans le répertoire de l’exécutable. Mais comme nous allons le voir plus bas, il est possible d'utiliser NuGet pour automatiser cette tâche.
Le package NuGet
Nous avons profité de ces modifications pour publier notre librairie sous NuGet: https://www.nuget.org/packages/Yoctopuce.YoctoLib/
NuGet est un gestionnaire de packages développé par Microsoft pour les projets .NET. Il a pour but de simplifier la vie des développeur en s'occupant du téléchargement et de l'installation des librairies qui sont utilisées par un projet.
Le problème avec NuGet est qu'entre les différents types de projets Visual Studio, les différentes versions du client NuGet et maintenant des nouveaux projets .Net Core, il est difficile d'avoir une librairie qui fonctionne chez tout le monde.
Afin d'avoir un package facilement utilisable, nous avons limité son usage aux cas suivants:
- Un projet .Net "traditionnel" dès le Framework 4.5
- Un projet .Net Core dès version 2.0
Dans les autres cas, vous pouvez toujours utiliser notre librairie, mais il faudra ajouter manuellement les fichiers source et copier la librairie dynamique "yapi", comme expliqué dans notre article d'introduction.
Un exemple vaut mieux que de longs discours
Pour illustrer l'utilisation du package NuGet, nous allons écrire un petit programme en ligne de commande qui liste les modules Yoctopuce connectés aux ports USB.
Le code source est celui de l'exemple "Doc-Inventory" qui est inclus avec les sources de la librairie:
{
static void Main(string[] args)
{
YModule m;
string errmsg = "";
if (YAPI.RegisterHub("usb", ref errmsg) != YAPI.SUCCESS) {
Console.WriteLine("RegisterHub error: " + errmsg);
Environment.Exit(0);
}
Console.WriteLine("Device list");
m = YModule.FirstModule();
while (m != null) {
Console.WriteLine(m.get_serialNumber()
+ " (" + m.get_productName() + ")");
m = m.nextModule();
}
YAPI.FreeAPI();
}
}
Nous allons voir comment réaliser ce petit programme dans un projet .NET Framework ainsi que dans un projet .NET Core.
.NET Framework 4.5 et suivant
Il faut commencer par créer un nouveau projet de type "Console App (.NET Framework)" dans Visual Studio.
Il faut créer un nouveau projet de type 'Console App (.NET Framework)' dans Visual Studio
Ensuite il faut accéder au "NuGet package manager". Cela peut se faire en utilisant la barre de menu ("Tools"->"NuGet Package Manage"->"Manage NuGet Package for Solutions...") ou avec un clic droit sur le projet en sélectionnant l'option "Manage NuGet Package...".
L'onglet NuGet est accessible par le menu dans Visual Studio
L'onglet NuGet permet de rechercher le package Yoctopuce et de l'ajouter au projet directement depuis NuGet.org à l'aide du bouton "Install".
L'onglet NuGet permet de rechercher le package Yoctopuce et de l'ajouter au projet
Une fois installé, le package NuGet Yoctopuce.YoctoLib est affiché dans les Reference du projet.
Le package Yoctopuce.YoctoLib est listé dans les references du projet
Et voilà. Il n'y a pas d'autre manipulation à faire. Lors de la compilation, les librairies dynamiques sont automatiquement copiées avec l’exécutable dans le répertoire de sortie.
Notez que toutes les versions de la librairie dynamique "yapi" sont copiées, y compris les versions Linux et macOS. Cela veux dire que l'application est directement utilisable sous Linux ou macOS avec Mono. Il suffit de copier tout le répertoire et de lancer l’exécutable à l'aide de Mono.
.NET Core 2.x
Nous allons voir comment faire la même application mais cette fois sous Linux en utilisant .NET Core 2.2.
Sous Linux, il n'y a pas d'IDE mais simplement l'utilitaire dotnet qui permet de compiler et exécuter un projet .NET Core.
On commence par créer un nouveau projet de type "console" à l'aide de la commande new avec l'option "console":
yocto@linux-laptop:~/demo$ dotnet new console
Il faut ensuite éditer le fichier Program.cs pour ajouter le code de notre exemple dans la fonction Main().
Avant de pouvoir compiler le projet, il faut encore le package Yoctopuce.YoctoLib. Pour cela, on utilise la commande add package avec le nom du package Yoctopuce.
yocto@linux-laptop:~/demo$ dotnet add package Yoctopuce.YoctoLib
Il est ensuite possible de lancer l’exécutable directement à l'aide de la commande run:
yocto@linux-laptop:~/demo$ dotnet run Device list LIGHTMK3-A10AB (Yocto-Light-V3) yocto@linux-laptop:~/demo$
Conclusion
Le fait de se passer des entrées dllmap rend caduc une bonne partie de ce que nous vous avons dit il y a 3 semaines, mais cela nous a permis d'ajouter le support de .NET Core et un package NuGet.
.Net Core est encore peu utilisé, mais est prometteur. En effet, il est possible de créer des applications "complètement autonomes" en créant une application qui contient directement la machine virtuelle .NET. Cela permet par exemple de compiler une application qui soit utilisable directement sur un Raspberry Pi sans avoir rien à installer. Mais ça, c'est un sujet pour un prochain article...
