Commandes courantes de la CLI .NET Core

Cet article regroupe quelques commandes courantes à utiliser avec la CLI .NET Core (i.e. Command Line Interface).

Avant de commencer, quelques brèves remarques au sujet de .NET Core:

  • .NET Core est une implémentation de Microsoft qui a pour but de rendre la technologie .NET disponible sur plusieurs plateformes.
  • .NET Core est open-source et les sources sont disponibles sur GitHub.
  • Un gros inconvénient du développement d’applications pour le framework .NET est qu’il nécessite l’installation du SDK du framework .NET et surtout l’installation de Visual Studio. Pour éviter l’installation de ces composants dans le cadre de .NET Core, Microsoft a mis à disposition une CLI .NET Core (i.e. Command Line Interface).
  • La CLI .NET Core permet d’effectuer la plupart des opérations effectuées par Visual Studio:
    • Créer un projet,
    • Ajouter une dépendance à un projet,
    • Builder une solution,
    • Générer un package NuGet,
    • etc…
  • Le gros avantage de la CLI .NET est d’être facile à installer et d’être disponible sur toutes les plateformes (Linux, macOS et Windows).
  • Avec .NET Core, il est possible de compiler des sources pour que les assemblies soient exécutées sur une machine où le SDK .NET Core est déjà installé. Les assemblies déployées ne contiendront que le code implémenté et non les assemblies du framework .NET Core (ce type de déploiement se rapproche du déploiement d’assemblies du framework .NET sur des machines Windows).
    On peut aussi compiler le code .NET Core pour que les assemblies soient autonomes et qu’elles ne nécessitent aucune installation préalable du SDK .NET Core. Avec ce type de déploiement, les assemblies livrées contiennent le code compilé et les assemblies du framework .NET Core.
  • Il ne faut pas confondre .NET Core et .NET Standard. .NET Standard est une abstraction introduite par Microsoft pour permettre de livrer des assemblies en étant basé sur un standard plutôt que directement sur un framework. Etre basé sur un standard permet d’éviter d’avoir des dépendances vers une plateforme spécifique comme l’imposent les frameworks.
    Il existe des compatibilités entre les versions de .NET Standard et les versions des frameworks, ce qui permet de savoir comment consommer les assemblies .NET Standard à partir d’assemblies basées sur des frameworks.
    Une autre spécificité de .NET Standard est qu’il n’est possible de créer des livrables .NET Standard que pour des assemblies de type bibliothèque de classes (i.e. Class Library) car il ne doit pas y avoir de dépendances vers une plateforme particulière. Pour créer des assemblies sous forme d’exécutables, il faut utiliser des frameworks comme .NET ou .NET Core (pour davantage de détails sur .NET Standard: Comprendre .NET Standard en 5 min).

Les commandes siuvantes sont présentées pour Linux toutefois la syntaxe est la même pour les autres plateformes.

Pour afficher l’aide général de la commande dotnet:

user@debian:~% dotnet –h

Créer un nouveau projet (dotnet new)

Afficher la liste des modèles de projets disponibles:

user@debian:~% dotnet new -l 

Créer un projet de type spécifique

Avec cette syntaxe, on peut créer un projet de type console. Le projet sera créé dans le répertoire courant avec le nom du répertoire courant:

user@debian:~% dotnet new console 

Pour créer un projet avec un nom particulier (le projet sera créé dans un répertoire avec le nom du projet):

user@debian:~% dotnet new console –n <nom du projet>

Pour créer un projet avec un nom particulier en précisant le répertoire de sortie:

user@debian:~% dotnet new console –n <nom du projet> -o <chemin du répertoire de sortie>

Quelques autres types de projet:

Projet de test MS Test mstest
Projet de test xUnit xunit
Projet ASP.NET Core vide web
Web application ASP.NET Core MVC mvc
Web application ASP.NET Core avec Angular angular
Projet Web API webapi
Créer un fichier Solution sln

Créer un projet pour une architecture déterminée

Par défaut, un projet est créé pour .NET Core 2.0. Pour indiquer une architecture spécifique, il faut utiliser l’option suivante:

user@debian:~% dotnet new <type du projet> –n <nom du projet> -f <nom du framework>

Les frameworks courants sont:

.NET Core netcoreapp2.0
.NET Framework net20
net45, net452
net46, net462
net47, net471
.NET Standard netstandard2.0

Gérer une dépendance d’un projet vers un autre projet (dotnet add/remove)

Pour ajouter une dépendance dans le fichier .csproj d’un projet:

user@debian:~% dotnet add <chemin .csproj où ajouter la dépendance> reference 
	<chemin .csproj à rajouter> 

Pour supprimer une dépendance dans le fichier .csproj d’un projet

user@debian:~% dotnet remove <chemin .csproj où supprimer la dépendance> reference 
	<chemin .csproj à supprimer>   

Lister les dépendances:

user@debian:~% dotnet list <chemin .csproj> reference 

Gérer le contenu d’un fichier .sln (solution)

Ajouter un projet à une solution:

user@debian:~% dotnet sln <fichier .sln à modifier> add <chemin .csproj à ajouter> 

Pour supprimer un projet d’une solution

user@debian:~% dotnet sln <fichier .sln à modifier> remove <chemin .csproj à supprimer> 

Effectuer une “build” (dotnet build)

Pour builder un projet ou une solution:

user@debian:~% dotnet build 

Par défaut, la build est effectuée pour le framework .Net Core 2.0 et pour la configuration “Debug”.

Pour préciser le framework:

user@debian:~% dotnet build -f <nom du framework>

Pour indiquer la configuration “Debug” ou “Release”:

user@debian:~% dotnet build -c <nom de la configuration> 

Pour spécifier un runtime:

user@debian:~% dotnet build -r <identificateur RID du runtime>

Quand on précise le runtime, le résultat de la build sera indépendant de la console .NET Core c’est-à-dire qu’il pourra être exécuté de façon autonome sur la plateforme cible sans que .NET Core ne soit installé.

Quelques exemples de RID (i.e. Runtime IDentifier):

Windows any
win
win-x86
win-x64
MacOS osx-x64
Linux linux-x64
rhel-x64 (Red Hat)
debian-x64
ubuntu-x64

On peut utiliser l’option –o pour préciser un répertoire de sortie.

Supprimer le résultat d’une “build” (dotnet clean)

On peut exécuter la commande:

user@debian:~% dotnet clean 

Les répertoires bin et obj sont présents toutefois leur contenu est supprimé.

Exécuter du code (dotnet run)

On peut exécuter du code .NET Core sans forcément avoir compilé avant. Cette commande est utile si on dispose de la console .NET Core et que les éléments de sortie n’ont pas été buildés pour un runtime particulier.

La commande est:

user@debian:~% dotnet run –p <chemin du répertoire du projet à exécuter>

On peut utiliser les options suivantes:

  • -c pour préciser la configuration (Debug ou Release)
  • -f pour préciser le framework

Publier les résultats de compilation (dotnet publish)

Permet de générer un répertoire contenant les assemblies destinées à être publiées sur d’autres plateformes.

Pour publier, il faut exécuter la commande:

user@debian:~% dotnet publish 

De façon facultative, on peut ajouter le fichier .csproj du projet à publier:

user@debian:~% dotnet publish <chemin .csproj du projet à publier> 

On peut utiliser les options suivantes:

  • -c pour préciser la configuration (Debug ou Release)
  • -f pour préciser le framework
  • -r pour préciser le runtime.

Par défaut le répertoire de sortie est:

<Répertoire du projet>/bin/Debug/<framework>/publish 

Si on précise des éléments comme la configuration, le framework ou le RID (i.e. Runtime IDentifier), le répertoire de sortie sera:

<Répertoire du projet>/bin/<Configuration>/<framework>/<runtime identifier>/publish 

Les assemblies générées seront autonomes et pourront être exécutées sans que le SDK .NET Core ne soit installé.

Exécuter les tests (dotnet test)

Pour exécuter les tests unitaires se trouvant dans un projet de test:

user@debian:~% dotnet test <chemin .csproj contenant les tests unitaires> 

On peut utiliser les options suivantes:

  • -c pour préciser la configuration (par exemple Debug ou Release)
  • -f pour préciser le framework

Gérer les dépendances NuGet

Les sources des packages NuGet peuvent être paramétrées dans le fichier:

<répertoire de l'utilisateur>/.nuget/NuGet/NuGet.config

Par exemple, si l’utilisation est “debianuser” le répertoire sera sous Linux:

/home/debianuser/.nuget/NuGet/NuGet.config

Le contenu de ce fichier contient, par défaut, nuget.org:

<?xml version="1.0" encoding="utf-8"?> 
<configuration> 
  <packageSources> 
    <add key="nuget.org" value="https://api.nuget.org/v3/index.json" protocolVersion="3" /> 
  </packageSources> 
</configuration> 

Restaurer les dépendances (dotnet restore)

Il faut exécuter la commande:

user@debian:~% dotnet restore 

La plupart du temps, il n’est pas nécessaire d’exécuter cette commande car elle est implicitement exécutée pour la plupart des commandes dotnet new, dotnet build, dotnet run etc…

Ajouter un package NuGet à un projet

Il faut exécuter la commande suivante:

user@debian:~% dotnet add <chemin .csproj> package <nom du package NuGet> 

Si on se place dans le répertoire du projet, il n’est pas nécessaire de préciser le fichier .csproj:

user@debian:~/ProjectFolder% dotnet add package <nom du package NuGet> 

On peut aussi ajouter des options liées au package NuGet comme la version:

user@debian:~% dotnet add package <nom du package NuGet> -version <version du package 1.2.3>

Supprimer la référence d’un package NuGet dans un projet

Pour supprimer une référence NuGet d’un projet, on peut exécuter:

user@debian:~% dotnet remove <chemin .csproj> package <nom du package NuGet> 

Si on se place dans le répertoire du projet, il n’est pas nécessaire de préciser le fichier .csproj:

user@debian:~/ProjectFolder% dotnet remove package <nom du package NuGet> 

Générer un package NuGet avec ses résultats de compilation (dotnet pack)

On peut générer un package NuGet avec la commande:

user@debian:~% dotnet pack <chemin .csproj> 

Si on se trouve dans le répertoire d’un projet, il suffit d’exécuter:

user@debian:~% dotnet pack 

On peut utiliser les options suivantes:

  • -c pour préciser la configuration (Debug ou Release)
  • -r pour préciser le runtime
  • -o pour indiquer un répertoire de sortie
  • --include-symbols pour générer un package contenant les fichiers PDB

Par défaut, le package est généré avec la configuration “Debug”.

Pour préciser la version du package, on peut utiliser l’option suivante:

user@debian:~% dotnet pack /p:PackageVersion=1.2.3 
Share on FacebookShare on Google+Tweet about this on TwitterShare on LinkedInEmail this to someonePrint this page

Leave a Reply