Publier des applications .NET avec l’interface CLI .NET

Cet article explique comment vous pouvez publier votre application .NET à partir de la ligne de commande. .NET propose trois manières de publier vos applications. Le déploiement dépendant du Framework produit un fichier. dll multiplateforme qui utilise le Runtime .NET installé localement. L’exécutable dépendant du Framework produit un fichier exécutable propre à la plateforme qui utilise le Runtime .NET installé localement. Un exécutable autonome produit un exécutable spécifique à la plateforme et comprend une copie locale du Runtime .NET.

Pour obtenir une vue d’ensemble de ces modes de publication, consultez déploiement d’applications .net.

Vous recherchez une aide rapide sur l’utilisation de l’interface CLI ? Le tableau suivant présente quelques exemples illustrant comment publier votre application. Vous pouvez spécifier le framework cible avec le paramètre -f <TFM> ou en modifiant le fichier projet. Pour plus d’informations, consultez Principes de base de la publication.

Mode de publication Version du SDK Commande
Déploiement dépendant du framework 2.1 dotnet publish -c Release
3.1 dotnet publish -c Release -p:UseAppHost=false
5.0 dotnet publish -c Release -p:UseAppHost=false
Exécutable dépendant du framework 3.1 dotnet publish -c Release -r <RID> --self-contained false
dotnet publish -c Release
5.0 dotnet publish -c Release -r <RID> --self-contained false
dotnet publish -c Release
Déploiement autonome 2.1 dotnet publish -c Release -r <RID> --self-contained true
3.1 dotnet publish -c Release -r <RID> --self-contained true
5.0 dotnet publish -c Release -r <RID> --self-contained true

* Lors de l’utilisation du Kit de développement logiciel (SDK) version 3,1 ou ultérieure, un fichier exécutable dépendant du Framework est le mode de publication par défaut lors de l’exécution de la commande de base dotnet publish .

Notes

Le -c Release paramètre n’est pas obligatoire. Il est fourni en tant que rappel pour publier la version Release de votre application.

Principes de base de la publication

Le paramètre <TargetFramework> du fichier projet spécifie le framework cible par défaut quand vous publiez votre application. Vous pouvez choisir comme framework cible n’importe quel TFM (Target Framework Moniker) valide. Par exemple, si votre projet utilise <TargetFramework>netcoreapp2.1</TargetFramework> , un binaire qui cible .net Core 2,1 est créé. Le TFM spécifié dans ce paramètre est la cible par défaut utilisée par la dotnet publish commande.

Si vous souhaitez cibler plusieurs infrastructures, vous pouvez définir le <TargetFrameworks> paramètre sur plusieurs valeurs TFM, séparées par un point-virgule. Quand vous générez votre application, une build est générée pour chaque Framework cible. Toutefois, lorsque vous publiez votre application, vous devez spécifier la version cible de .NET Framework à l’aide de la dotnet publish -f <TFM> commande.

Sauf indication contraire, le répertoire de sortie de la dotnet publish commande est ./bin/<BUILD-CONFIGURATION>/<TFM>/publish/ . Le mode BUILD-CONFIGURATION par défaut est Debug, sauf si vous le modifiez avec le paramètre -c. Par exemple, dotnet publish -c Release -f netcoreapp2.1 publie dans ./bin/Release/netcoreapp2.1/publish/.

Si vous utilisez kit SDK .NET Core 3,1 ou une version ultérieure, le mode de publication par défaut est un exécutable dépendant du Framework.

Si vous utilisez kit SDK .NET Core 2,1, le mode de publication par défaut est le déploiement dépendant du Framework.

Dépendances natives

Si votre application a des dépendances natives, elle risque de ne pas fonctionner sur un autre système d’exploitation. Par exemple, si votre application utilise l’API Windows native, elle ne s’exécutera pas sur macOS ou Linux. Vous devrez fournir du code propre à la plateforme et compiler un exécutable pour chaque plateforme.

Sachez également que si une bibliothèque que vous avez référencée a une dépendance native, votre application risque de ne pas fonctionner sur toutes les plateformes. Toutefois, il est possible qu’un package NuGet que vous référencez ait inclus des versions propres à la plateforme afin de gérer pour vous les dépendances natives requises.

Lors de la distribution d’une application avec des dépendances natives, vous devrez peut-être utiliser le commutateur dotnet publish -r <RID> afin de spécifier la plateforme cible pour laquelle vous souhaitez publier. Pour obtenir une liste des identificateurs de runtime, consultez Catalogue d’identificateurs de runtime (RID).

Vous trouverez davantage d’informations sur les binaires propres à la plateforme dans les sections Exécutable dépendant du framework et Déploiement autonome.

Exemple d'application

Vous pouvez utiliser l’application suivante pour explorer les commandes de publication. L’application est créée en exécutant les commandes suivantes dans votre terminal :

mkdir apptest1
cd apptest1
dotnet new console
dotnet add package Figgle

Le fichier Program.cs ou Program.vb généré par le modèle de console doit être modifié comme suit :

using System;

namespace apptest1
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine(Figgle.FiggleFonts.Standard.Render("Hello, World!"));
        }
    }
}
Module Program
    Sub Main(args As String())
        Console.WriteLine(Figgle.FiggleFonts.Standard.Render("Hello, World!"))
    End Sub
End Module

Lorsque vous exécutez l’application ( dotnet run ), la sortie suivante s’affiche :

  _   _      _ _         __        __         _     _ _
 | | | | ___| | | ___    \ \      / /__  _ __| | __| | |
 | |_| |/ _ \ | |/ _ \    \ \ /\ / / _ \| '__| |/ _` | |
 |  _  |  __/ | | (_) |    \ V  V / (_) | |  | | (_| |_|
 |_| |_|\___|_|_|\___( )    \_/\_/ \___/|_|  |_|\__,_(_)
                     |/

Déploiement dépendant du framework

Pour le kit de développement logiciel (SDK) .NET Core 2,1, le déploiement dépendant du Framework (FDD) est le mode par défaut pour la commande de base dotnet publish . Dans les nouveaux kits de développement logiciel (SDK), un exécutable dépendant du Framework est la valeur par défaut.

Quand vous publiez votre application en tant que déploiement dépendant du framework, un fichier <PROJECT-NAME>.dll est créé dans le dossier ./bin/<BUILD-CONFIGURATION>/<TFM>/publish/. Pour exécuter votre application, accédez au dossier de sortie et utilisez la commande dotnet <PROJECT-NAME>.dll.

Votre application est configurée pour cibler une version spécifique de .NET. Ce .NET Runtime ciblé doit être sur tout ordinateur sur lequel votre application s’exécute. Par exemple, si votre application cible .NET Core 3,1, le Runtime .NET Core 3,1 doit être installé sur tout ordinateur sur lequel s’exécute votre application. Comme indiqué dans la section Principes de base de la publication, vous pouvez modifier votre fichier projet afin de changer le framework cible par défaut ou de cibler plusieurs frameworks.

La publication d’un lecteur de disquette crée une application qui reprend automatiquement le correctif de sécurité .NET le plus récent disponible sur le système qui exécute l’application. Pour plus d’informations sur la liaison de version au moment de la compilation, consultez Sélectionner la version .net à utiliser.

Mode de publication Version du SDK Commande
Déploiement dépendant du framework 2.1 dotnet publish -c Release
3.1 dotnet publish -c Release -p:UseAppHost=false
5.0 dotnet publish -c Release -p:UseAppHost=false

Exécutable dépendant du framework

Pour l’interface CLI du kit de développement logiciel (SDK) .NET 5 (et .NET Core 3,1), le fichier exécutable dépendant du Framework (FDE) est le mode par défaut de la commande de base dotnet publish . Vous n’avez pas besoin de spécifier d’autres paramètres, tant que vous souhaitez cibler le système d’exploitation actuel.

Dans ce mode, un hôte d’exécutable propre à la plateforme est créé pour héberger votre application multiplateforme. Ce mode est similaire à FDD, car FDD requiert un ordinateur hôte sous la forme de la dotnet commande. Le nom de fichier de l’exécutable hôte varie selon la plateforme et porte un nom similaire à <PROJECT-FILE>.exe . Vous pouvez exécuter cet exécutable directement au lieu d’appeler dotnet <PROJECT-FILE>.dll , ce qui est toujours un moyen acceptable d’exécuter l’application.

Votre application est configurée pour cibler une version spécifique de .NET. Ce .NET Runtime ciblé doit être sur tout ordinateur sur lequel votre application s’exécute. Par exemple, si votre application cible .NET Core 3,1, le Runtime .NET Core 3,1 doit être installé sur tout ordinateur sur lequel s’exécute votre application. Comme indiqué dans la section Principes de base de la publication, vous pouvez modifier votre fichier projet afin de changer le framework cible par défaut ou de cibler plusieurs frameworks.

La publication d’un FDE crée une application qui reprend automatiquement le correctif de sécurité .NET le plus récent disponible sur le système qui exécute l’application. Pour plus d’informations sur la liaison de version au moment de la compilation, consultez Sélectionner la version .net à utiliser.

Pour .NET 2,1, vous devez utiliser les commutateurs suivants avec la dotnet publish commande pour publier un FDE :

  • -r <RID> Ce commutateur utilise un identificateur (RID) pour spécifier la plateforme cible. Pour obtenir une liste des identificateurs de runtime, consultez Catalogue d’identificateurs de runtime (RID).

  • --self-contained false Ce commutateur désactive le comportement par défaut du -r commutateur, qui consiste à créer un déploiement autonome (SCD). Ce commutateur crée un FDE.

Mode de publication Version du SDK Commande
Exécutable dépendant du framework 3.1 dotnet publish -c Release -r <RID> --self-contained false
dotnet publish -c Release
5.0 dotnet publish -c Release -r <RID> --self-contained false
dotnet publish -c Release

Quand vous utilisez le commutateur -r, le chemin du dossier de sortie devient : ./bin/<BUILD-CONFIGURATION>/<TFM>/<RID>/publish/

Si vous utilisez l’exemple d’application, exécutez dotnet publish -f net5.0 -r win10-x64 --self-contained false. Cette commande crée l’exécutable suivant : ./bin/Debug/net5.0/win10-x64/publish/apptest1.exe

Notes

Vous pouvez réduire la taille totale de votre déploiement en activant le mode invariant de globalisation. Ce mode est utile pour les applications qui ne sont pas globalement compatibles et qui peuvent utiliser les conventions de mise en forme, les conventions de casse et la comparaison de chaînes, ainsi que l’ordre de tri de la culture invariante. Pour plus d’informations sur le mode de globalisation invariant et sur la façon de l’activer, consultez mode invariant de la globalisation .net.

Déploiement autonome

Lorsque vous publiez un déploiement autonome (SCD), le kit de développement logiciel (SDK) .NET crée un exécutable spécifique à la plateforme. La publication d’une SCD inclut tous les fichiers .NET requis pour exécuter votre application, mais elle n’inclut pas les dépendances natives de .net. Ces dépendances doivent être présentes sur le système avant l’exécution de l’application.

La publication d’une SCD crée une application qui n’est pas reportée vers le dernier correctif de sécurité .NET disponible. Pour plus d’informations sur la liaison de version au moment de la compilation, consultez Sélectionner la version .net à utiliser.

Vous devez utiliser les commutateurs suivants avec la commande dotnet publish pour publier un déploiement autonome :

  • -r <RID> Ce commutateur utilise un identificateur (RID) pour spécifier la plateforme cible. Pour obtenir une liste des identificateurs de runtime, consultez Catalogue d’identificateurs de runtime (RID).

  • --self-contained true Ce commutateur indique au kit SDK .NET Core qu’il doit créer un exécutable sous forme de déploiement autonome.

Mode de publication Version du SDK Commande
Déploiement autonome 2.1 dotnet publish -c Release -r <RID> --self-contained true
3.1 dotnet publish -c Release -r <RID> --self-contained true
5.0 dotnet publish -c Release -r <RID> --self-contained true

Notes

Vous pouvez réduire la taille totale de votre déploiement en activant le mode invariant de globalisation. Ce mode est utile pour les applications qui ne sont pas globalement compatibles et qui peuvent utiliser les conventions de mise en forme, les conventions de casse et la comparaison de chaînes, ainsi que l’ordre de tri de la culture invariante. Pour plus d’informations sur le mode de globalisation invariant et sur la façon de l’activer, consultez mode de globalisation de la globalisation .net Core.

Voir aussi