Publié le 22/03/2018 Par Nicolas Latrille

.Net Core est un framework open source développé et maintenu par Microsoft qui permet de créer des applications multi plateformes. Nous reviendrons de manière détaillée dans de futurs articles sur ses spécificités. D’un point de vue pratique, il est souvent utilisé avec Visual Studio, l’IDE de Microsoft, pour profiter d’un confort de développement et de fonctionnalités avancées (autocomplétion, debug…). Malheureusement Visual Studio n’est pas multiplateforme…au contraire de son “petit frère” Visual Studio Code, gratuit, modulaire et installable quelle que soit votre machine. Si vous aimez les challenges, un simple éditeur de texte comme notepad peut suffire mais nous vous recommandons chaudement VSCode avec par exemple l’extension C#.

Voyons maintenant ensemble comment mettre en place un environnement de développement .Net Core sur Windows et Linux.

Installation sur Windows

Avant de développer en Dotnet core il faut installer le SDK Dotnet Core. Le plus simple est d’aller sur la page dédiée de microsoft. Si le lien n’est plus disponible, il suffit de demander à votre meilleur ami avec la recherche suivante « dotnet core sdk », il se fera un plaisir de vous donner l’adresse où vous pourrez télécharger et installer le SDK.

L’installation du SDK est assez simple, il suffit de suivre les étapes d’installation et de valider chaque étape.

Sur le dernier écran de l’installation veuillez remarquer les liens qui pourront vous être utiles pour commencer à développer et comprendre Dotnet Core.

.Net Core // Fenêtre d'installation du SDK .Net Core sous Windows
Fenêtre d’installation du SDK .Net Core sous Windows

Les liens en question :

Une fois l’installation terminée, ouvrez une fenêtre de commande et lancez l’instruction :

dotnet --version qui vous donnera la version de Dotnet Core installée

dotnet -h vous donnera une aide sur la commande

C:UsersuserDocumentsVisual Studio 2017 > dotnet -h
Outils en ligne de commande .NET (2.1.4)
Utilisation: dotnet [runtime-options] [path-to-application]                                                             
Utilisation: dotnet [sdk-options] [command] [arguments] [command-options]

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

Commandes du SDK:
  new              Initialisez les projets .NET.                                                                          
  restore          Restaurez les dépendances spécifiées dans le projet .NET.
  run              Compile et exécute immédiatement un projet .NET.                                                       
  build            Génère un projet .NET.
  publish          Publie un projet .NET à des fins de déploiement (runtime inclus).                                      
  test             Exécute des tests unitaires à l'aide du programme Test Runner spécifié dans le projet.
  pack             Crée un package NuGet.                                                                                 
  migrate          Effectue la migration d'un projet basé sur project.json vers un projet basé sur msbuild.
  clean            Nettoyez les sorties de build.
  sln              Modifiez les fichiers solution (SLN).
  add              Ajoutez une référence au projet.
  remove           Supprimez une référence du projet.
  list             Listez une référence dans le projet.
  nuget            Fournit des commandes NuGet supplémentaires.
  msbuild          Exécute Microsoft Build Engine (MSBuild).
  vstest           Exécute l'outil en ligne de commande d'exécution de tests Microsoft.

Options communes:
  -v|--verbosity        Définissez le niveau de détail de la commande. Les valeurs autorisées sont q[uiet], m[inimal], n[ormal], d[etailed] et diag[nostic].
  -h|--help             Affichez l'aide.

Exécutez 'dotnet COMMAND --help' pour plus d'informations sur une commande.

sdk-options:
  --version        Affichez la version du SDK .NET Core.
  --info           Affichez les informations sur .NET Core.
  -d|--diagnostics Activez la sortie des diagnostics.

runtime-options:
  --additionalprobingpath <path>    Chemin contenant la stratégie de collecte et les assemblys à collecter.
  --fx-version <version>            Version du framework partagé installé à utiliser pour exécuter l'application.
  --roll-forward-on-no-candidate-fx Effectuez une restauration par progression si aucun framework partagé candidat n'est activé.
  --additional-deps <path>          Chemin du fichier deps.json supplémentaire.

Exemple de création de « Hello world » en application Console

Tapez la commande :

dotnet new console -o PremiereApplicationConsole

C:UsersuserDocuments>dotnet new console -o PremiereApplicationConsole
Le modèle 'Console Application' a été créé.

Traitement des actions postcréation...
Exécution de 'dotnet restore' sur PremiereApplicationConsolePremiereApplicationConsole.csproj...
  Restoring packages for C:UsersuserDocumentsPremiereApplicationConsolePremiereApplicationConsole.csproj...
  Generating MSBuild file C:UsersuserDocumentsPremiereApplicationConsoleobjPremiereApplicationConsole.csproj.nuget.g.props.
  Generating MSBuild file C:UsersuserDocumentsPremiereApplicationConsoleobjPremiereApplicationConsole.csproj.nuget.g.targets.
  Restore completed in 242,04 ms for C:UsersuserDocumentsPremiereApplicationConsolePremiereApplicationConsole.csproj.

Restauration réussie.

Félicitations, vous venez de créer votre première application.

Le répertoire « PremiereApplicationConsole » a été créé et contient votre application.

Pour lancer l’application, allez dans le répertoire et tapez la commande : dotnet run

Création de votre première application MVC

Tapez la commande : dotnet new razor -o MonAppWeb

C:UsersuserDocuments>dotnet new razor -o MonAppWeb
Le modèle 'ASP.NET Core Web App' a été créé.
Ce modèle contient des technologies d'éditeurs autres que Microsoft. Pour plus de détails, consultez https://aka.ms/template-3pn.

Traitement des actions postcréation...
Exécution de 'dotnet restore' sur MonAppWebMonAppWeb.csproj...
  Restoring packages for C:UsersuserDocumentsMonAppWebMonAppWeb.csproj...
  Restore completed in 389,03 ms for C:UsersuserDocumentsMonAppWebMonAppWeb.csproj.
  Generating MSBuild file C:UsersuserDocumentsMonAppWebobjMonAppWeb.csproj.nuget.g.props.
  Generating MSBuild file C:UsersuserDocumentsMonAppWebobjMonAppWeb.csproj.nuget.g.targets.
  Restore completed in 4,38 sec for C:UsersuserDocumentsMonAppWebMonAppWeb.csproj.

Restauration réussie.

Allez dans le répertoire MonAppWeb et tapez dotnet run pour lancer l’application.

IIS express héberge l’application et vous pouvez accéder à votre page sur localhost:{le numéro de port indiqué} (ici le port est 5000).

 C:UsersuserDocumentsMonAppWeb>dotnet run
Hosting environment: Production
Content root path: C:UsersuserDocumentsMonAppWeb
Now listening on: http://localhost:5000
Application started. Press Ctrl+C to shut down.

Vous voilà maintenant fin prêts pour développer en .Net Core sur Windows !

Finalement la documentation de Microsoft est bien réalisée et balise assez facilement l’installation. Le processus ne pose pas de difficultés particulières et aucun bug ou subtilité ne vient entacher l’expérience utilisateur.

Microsoft remporte donc le premier point haut la main sur sa plateforme, passons maintenant à l’installation sur Linux et regardons ensemble si l’expérience d’installation de .Net Core est aussi fluide.

Installation sur Linux

Ubuntu

Le framework

L’installation de .Net Core sour Linux est assez simple. Microsoft détaille la procédure dans cet article : https://docs.microsoft.com/fr-fr/dotnet/core/linux-prerequisites?tabs=netcore2x

L’installation se fait très rapidement.

1ère étape:

Ajout du repos de fichiers Microsoft au système :

$ sudo sh -c 'echo "deb [arch=amd64] https://packages.microsoft.com/repos/microsoft-ubuntu-xenial-prod xenial main" > /etc/apt/sources.list.d/dotnetdev.list'

2ème étape:

Elle était facile à deviner, c’est la mise à jour des listes des fichiers des repos :

$ sudo apt-get update

3ème étape:

Là aussi, pas de grand mystère étant donné les précédentes, on installe le .Net Core :

$ sudo apt-get install dotnet-sdk-2.1.3

Pour l’installation il faut compter quelques minutes selon votre connexion Internet. Nous avons mis environ 4 minutes sur le réseau Wi-Fi invité de notre entreprise.

Pour ceux qui auraient lu l’article de Microsoft avant d’arriver ici, vous devez vous demandez: “quid du prérequis ?”.

Question légitime, s’il en est. Sur Ubuntu 16.0.4 tout le prérequis est là, inutile de s’en soucier.

A la fin de l’installation, pour vérifier qu’elle est fonctionnelle vous pouvez contrôler le numéro de version :

$ dotnet --version
2.1.3

Premier projet

Pour contrôler que tout fonctionne, le mieux reste encore de créer et exécuter un premier projet.

Projet console:

Pour initier un projet console il suffit de taper en ligne de commande :

$ dotnet new console
Le modèle 'Console Application' a été créé.

Traitement des actions postcréation...
Exécution de 'dotnet restore' sur /home/test/dotnetcore_blog/install/prj/prj.csproj...
  Restoring packages for /home/test/dotnetcore_blog/install/prj/prj.csproj...
  Generating MSBuild file /home/test/dotnetcore_blog/install/prj/obj/prj.csproj.nuget.g.props.
  Generating MSBuild file /home/test/dotnetcore_blog/install/prj/obj/prj.csproj.nuget.g.targets.
  Restore completed in 146,8 ms for /home/test/dotnetcore_blog/install/prj/prj.csproj.

Attention : sans préciser de nom le projet prendra le nom du répertoire où vous vous situez.

En regardant dans le répertoire, on voit bien que dotnet a créé toute la structure nécessaire au projet.

$ ll
total 32
drwxrwxr-x 6 test test 4096 janv. 25 14:43 ./
drwxrwxr-x 3 test test 4096 janv. 25 14:33 ../
drwxrwxr-x 3 test test 4096 janv. 25 14:40 bin/
drwxrwxr-x 3 test test 4096 janv. 25 14:40 obj/
-rw-rw-r-- 1 test test  178 janv. 25 14:34 prj.csproj
-rw-rw-r-- 1 test test  185 janv. 25 14:34 Program.cs

Dans le Program.cs vous retrouverez le code du main habituel :

using System;

namespace prj
{
   class Program
   {
       static void Main(string[] args)
       {
           Console.WriteLine("Hello World!");
       }
   }
}

pour le builder il suffit d’un :

$ dotnet build

et pour l’exécuter il suffit d’un :

$ dotnet run
HelloWorld!

 

Projet ASP.Net :

On commence assez logiquement par :

$ dotnet new web
Le modèle 'ASP.NET Core Empty' a été créé.
Ce modèle contient des technologies d'éditeurs autres que Microsoft. Pour plus de détails, consultez https://aka.ms/template-3pn.

Traitement des actions postcréation...
Exécution de 'dotnet restore' sur /home/test/dotnetcore_blog/install/prj_asp/prj_asp.csproj...
  Restoring packages for /home/test/dotnetcore_blog/install/prj_asp/prj_asp.csproj...
  Generating MSBuild file /home/test/dotnetcore_blog/install/prj_asp/obj/prj_asp.csproj.nuget.g.props.
  Generating MSBuild file /home/test/dotnetcore_blog/install/prj_asp/obj/prj_asp.csproj.nuget.g.targets.
  Restore completed in 647,74 ms for /home/test/dotnetcore_blog/install/prj_asp/prj_asp.csproj.


Restauration réussie.

Puis c’est exactement la même chose que pour un projet console :

$ dotnet build
Microsoft (R) Build Engine version 15.5.179.9764 pour .NET Core
Copyright (C) Microsoft Corporation. Tous droits réservés.

  Restore completed in 26,93 ms for /home/test/dotnetcore_blog/install/prj_asp/prj_asp.csproj.
  prj_asp -> /home/test/dotnetcore_blog/install/prj_asp/bin/Debug/netcoreapp2.0/prj_asp.dll

Pour l’exécution, peut-être pensez vous que cela va être plus compliqué dans la mesure où le travail est assuré par IIS sous Windows. Et bien c’est aussi simple sous Linux, Microsoft utilise Kestrel :

$ dotnet run
Hosting environment: Production
Content root path: /home/test/dotnetcore_blog/install/prj_asp
Now listening on: http://localhost:5000
Application started. Press Ctrl+C to shut down.
info: Microsoft.AspNetCore.Hosting.Internal.WebHost[1]
  	Request starting HTTP/1.1 GET http://localhost:5000/  
info: Microsoft.AspNetCore.Hosting.Internal.WebHost[2]
  	Request finished in 12.9595ms 200
info: Microsoft.AspNetCore.Hosting.Internal.WebHost[1]
  	Request starting HTTP/1.1 GET http://localhost:5000/favicon.ico  
info: Microsoft.AspNetCore.Hosting.Internal.WebHost[2]
  	Request finished in 0.2538ms 200
info: Microsoft.AspNetCore.Hosting.Internal.WebHost[1]
  	Request starting HTTP/1.1 GET http://localhost:5000/  
info: Microsoft.AspNetCore.Hosting.Internal.WebHost[2]
  	Request finished in 0.0893ms 200
^CApplication is shutting down...

Vous noterez que la console affiche les logs avec les requêtes que nous avons faites lors de nos tests.

Il n’y a pas que ces deux types de projets disponibles, avec la commande dotnet new vous verrez que Microsoft a prévu des patrons de projet pour Angular, React.js, React.js & Redux, etc…

Installation sur Amazon Linux

Amazon propose une version custom Linux. Cette version utilise le même package manager que Red Hat : yum. Malheureusement la procédure d’installation proposée par RedHat et Microsoft ne fonctionne pas. Nous vous proposons donc notre propre procédure. Évidemment, comme elle n’est pas officielle, nous déclinons toute responsabilité quant aux dégâts qu’elle pourrait faire sur votre système. Et de toute façon, nous déconseillons aux novices de s’y attaquer.

1ère étape : Installation du sdk .Net Core

Il faut télécharger le sdk sur le site de Microsoft. Le décompresser et l’ajouter dans le path.

$ wget https://download.microsoft.com/download/1/1/5/115B762D-2B41-4AF3-9A63-92D9680B9409/dotnet-sdk-2.1.4-linux-x64.tar.gz

$ mkdir -p $HOME/dotnet && tar zxf dotnet-sdk-2.1.4-linux-x64.tar.gz -C $HOME/dotnet

$ export PATH=$PATH:$HOME/dotnet

Quelques conseils pour cette étape :

  • Vérifier le lien vers le téléchargement, car il change au fur et mesure des versions.
  • L‘export devra être fait à chaque connexion, donc il serait intelligent que vous l’ajoutiez dans votre fichier .bashrc

2ème étape : Le prérequis

Sur Amazon Linux, il manque la bibliothèque Libunwind. Il va donc falloir la télécharger, la générer/compiler et l’installer.

Les commandes pour la télécharger et la décompresser sont :

$ wget http://download.savannah.nongnu.org/releases/libunwind/libunwind-1.2.tar.gz

$ tar zxf libunwind-1.2.tar.gz -C $HOME/libunwind

Ici aussi, faites attention au lien de l’archive qui peut changer avec le temps.

Pour la compiler, il faut un compilateur. Gcc fera l’affaire.

$ sudo yum install gcc

Pour la compiler, je vous conseille de faire un sudo -i car la compilation et l’installation auront besoin des droits administrateur plusieurs fois.

$ cd $HOME/libunwind

$ sudo -i

$ ./configure; make; make install

$ exit

Il ne reste qu’une dernière étape, celle de faire les liens symboliques pour que le système sache où sont les résultats de la compilation et puisse les exécuter.

$ sudo ln -s /usr/local/lib/libunwind.so.8.0.1 /lib64/libunwind.so.8

$ sudo ln -s /usr/local/lib/libunwind-x86_64.so.8.0.1 /lib64/libunwind-x86_64.so.8

Maintenant vérifions ensemble que cela fonctionne :

$ dotnet --version
2.1.4

Conclusion

Que cela soit sur Windows ou Linux, le SDK .Net core s’installe facilement. C’est un peu plus ardu sur un Linux exotique mais tout de même faisable sans être expert. Et c’est surtout assez rapide.

Attention quand vous demandez la version du .Net avec la commande: dotnet –version : c’est bien la version du SDK (2.1.4) que vous avez et pas celle du .Net Core (2.0.5). C’est un peu plus visible avec l’installation sur Windows.

Une fois l’installation accomplie, vous avez accès à une ligne de commande assez bien faite qui vous permet de créer un grand nombre de patrons de projets (la liste pouvant être élargie) et de les exécuter simplement. Votre code ne change pas d’un poil entre les différents OS, seules les option de compilation peuvent changer si vous voulez générer un exécutable autonome (pas une dll) spécialisé pour le runtime de l’OS.

Pour poursuivre votre exploration du .Net Core, nous vous invitons à surveiller le blog car d’autres articles vont bientôt arriver.

Le prochain traitera notamment de la migration d’un projet .Net vers .Net Core.

Pas encore de commentaires

Publier un commentaire

Auteur

Nicolas Latrille

Développeur avant tout. Nicolas travaille en finance de marché depuis 2000. Craftman passionné, Nicolas a aussi la réputation d’avoir un œil critique sur tout !