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

Article
10/15/2024

Cet article montre comment publier votre application .NET à partir de la ligne de commande. .NET fournit trois façons 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 exécutable spécifique à la plateforme qui utilise le runtime .NET installé localement. L’exécutable autonome produit un exécutable spécifique à la plateforme et inclut une copie locale du runtime .NET.

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

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	Commande
Déploiement dépendant du framework	`dotnet publish -c Release -p:UseAppHost=false`
Exécutable dépendant du framework	`dotnet publish -c Release -r <RID> --self-contained false` `dotnet publish -c Release`
Déploiement autonome	`dotnet publish -c Release -r <RID> --self-contained true`

Remarque

Le paramètre -c Release n’est pas obligatoire. Il est fourni en guise de rappel pour publier le build Release de votre application.
Dans le kit de développement logiciel (SDK) .NET version 3.1 ou ultérieure, l’exécutable dépendant de l’infrastructure est le mode de publication par défaut lors de l’exécution de la commande dotnet publish de base.

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>net8.0</TargetFramework>, un binaire qui cible .NET 8 est créé. Le TFM spécifié dans ce paramètre est la cible par défaut utilisée par la commande dotnet publish.

Si vous souhaitez cibler plusieurs infrastructures, vous pouvez affecter plusieurs valeurs de TFM séparées par un point-virgule au paramètre <TargetFrameworks>. Lorsque vous générez votre application, une build est générée pour chaque infrastructure cible. Toutefois, lorsque vous publiez votre application, vous devez spécifier l’infrastructure cible avec la commande dotnet publish -f <TFM>.

Le mode BUILD-CONFIGURATION par défaut est Debug, sauf si vous le modifiez avec le paramètre -c.

Le répertoire de sortie par défaut de la commande dotnet publish est ./bin/<BUILD-CONFIGURATION>/<TFM>/publish/. Par exemple, dotnet publish -c Release -f net8.0 publie dans ./bin/Release/net8.0/publish/. Toutefois, vous pouvez choisir un chemin de sortie et une structure de dossiers simplifiés pour toutes les sorties de génération. Pour plus d’informations, consultez Disposition de sortie des artefacts.

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

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

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

Déploiement dépendant du framework

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 runtime .NET ciblé doit se trouver sur n’importe quel ordinateur sur lequel votre application s’exécute. Par exemple, si votre application cible .NET Core 8, le runtime .NET Core 8 doit être installé sur tout ordinateur sur lequel votre application s’exécute. 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 FDD crée une application qui est automatiquement transférée vers le dernier correctif de sécurité .NET 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 Core à utiliser.

Mode de publication	Commande
Déploiement dépendant du framework	`dotnet publish -c Release -p:UseAppHost=false`

Exécutable dépendant du framework

L’exécutable dépendant du framework (FDE) est le mode par défaut pour la commande dotnet publish de base. 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 semblable au déploiement dépendant de l’infrastructure, étant donné que celui-ci nécessite un ordinateur hôte sous la forme de la commande dotnet. Le nom de fichier de l’exécutable hôte varie en fonction de la plateforme, et ressemble à <PROJECT-FILE>.exe. Vous pouvez exécuter cet exécutable directement au lieu d’appeler dotnet <PROJECT-FILE>.dll, qui constitue tout de même une manière acceptable d’exécuter l’application.

Votre application est configurée pour cibler une version spécifique de .NET. Ce runtime .NET ciblé doit se trouver sur n’importe quel ordinateur sur lequel votre application s’exécute. Par exemple, si votre application cible .NET 8, le runtime .NET 8 doit être installé sur tout ordinateur sur lequel votre application s’exécute. 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 est automatiquement transférée vers le dernier correctif de sécurité .NET 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 Core à utiliser.

Mode de publication	Commande
Exécutable dépendant du framework	`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 net6.0 -r win-x64 --self-contained false. Cette commande crée l’exécutable suivant : ./bin/Debug/net6.0/win-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 invariant de globalisation et sur la façon de l’activer, consultez Mode invariant de globalisation .NET.

Configurer le comportement de recherche de l'installation .NET

Dans .NET 9 et les versions ultérieures, vous pouvez configurer les chemins de recherche de l'installation .NET de l'exécutable publié via les propriétés AppHostDotNetSearch et AppHostRelativeDotNet.

AppHostDotNetSearch permet de spécifier un ou plusieurs emplacements où l'exécutable recherchera une installation .NET :

AppLocal : dossier de l'exécutable de l'application
AppRelative : chemin relatif à l'exécutable de l'application
EnvironmentVariables : valeur des variables d'environnement DOTNET_ROOT[_<arch>]
Global : emplacements enregistrés et par défaut de l'installation globale

AppHostRelativeDotNet spécifie le chemin relatif à l'exécutable qui sera recherché lorsque AppHostDotNetSearch contient AppRelative.

Pour plus d'informations, voir AppHostDotNetSearch, AppHostRelativeDotNet et options d'emplacement d'installation dans apphost.

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’un déploiement autonome inclut tous les fichiers .NET nécessaires à l’exécution de votre application, mais pas les dépendances natives de .NET (par exemple, pour .NET 6 sur Linux ou .NET 8 sur Linux). Ces dépendances doivent être présentes sur le système avant l’exécution de l’application.

La publication d’un SCD crée une application qui n’est pas transférée à la dernière version du 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 Core à 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 de développement logiciel (SDK) .NET qu’il doit créer un exécutable sous forme de déploiement autonome.

Mode de publication	Commande
Déploiement autonome	`dotnet publish -c Release -r <RID> --self-contained true`

Conseil

Dans .NET 6 et versions ultérieures, vous pouvez réduire la taille totale des applications autonomes compatibles en publiant rogné. Cela permet au découpage de supprimer des parties de l’infrastructure et des assemblys référencés qui ne se trouvent pas sur un chemin de code ou potentiellement référencés dans la réflexion de l’exécution. Consultez les incompatibilités de découpage pour déterminer si le découpage est judicieux pour votre application.
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 invariant de globalisation et sur la façon de l’activer, consultez Mode invariant de globalisation .NET Core.

Partage via