Publicar aplicativos .NET com a CLI do .NET

Artigo
11/19/2023

Este artigo demonstra como você pode publicar seu aplicativo .NET a partir da linha de comando. O .NET fornece três maneiras de publicar seus aplicativos. A implantação dependente da estrutura produz um arquivo .dll de plataforma cruzada que usa o tempo de execução do .NET instalado localmente. O executável dependente da estrutura produz um executável específico da plataforma que usa o tempo de execução do .NET instalado localmente. O executável autônomo produz um executável específico da plataforma e inclui uma cópia local do tempo de execução do .NET.

Para obter uma visão geral desses modos de publicação, consulte Implantação de aplicativos .NET.

Procurando ajuda rápida sobre como usar a CLI? A tabela a seguir mostra alguns exemplos de como publicar seu aplicativo. Você pode especificar a estrutura de destino com o -f <TFM> parâmetro ou editando o arquivo de projeto. Para obter mais informações, consulte Noções básicas sobre publicação.

Modo de publicação	Comando
Implantação dependente da estrutura	`dotnet publish -c Release -p:UseAppHost=false`
Executável dependente da estrutura	`dotnet publish -c Release -r <RID> --self-contained false` `dotnet publish -c Release`
Implantação autônoma	`dotnet publish -c Release -r <RID> --self-contained true`

Nota

O -c Release parâmetro não é necessário. Ele é fornecido como um lembrete para publicar a compilação Release do seu aplicativo.
No .NET SDK 3.1 ou superior, o executável dependente da estrutura é o modo de publicação padrão ao executar o comando básico dotnet publish .

Noções básicas de publicação

A <TargetFramework> configuração do arquivo de projeto especifica a estrutura de destino padrão quando você publica seu aplicativo. Você pode alterar a estrutura de destino para qualquer Target Framework Moniker (TFM) válido. Por exemplo, se seu projeto usa <TargetFramework>net8.0</TargetFramework>, um binário destinado ao .NET 8 é criado. O TFM especificado nessa configuração é o destino padrão usado pelo dotnet publish comando.

Se quiser direcionar mais de uma estrutura, você pode definir a <TargetFrameworks> configuração para vários valores de TFM, separados por ponto-e-vírgula. Quando você cria seu aplicativo, uma compilação é produzida para cada estrutura de destino. No entanto, ao publicar seu aplicativo, você deve especificar a estrutura de destino com o dotnet publish -f <TFM> comando.

O modo padrão BUILD-CONFIGURATION é Debug, a menos que seja alterado com o -c parâmetro.

O diretório de saída padrão do dotnet publish comando é ./bin/<BUILD-CONFIGURATION>/<TFM>/publish/. Por exemplo, dotnet publish -c Release -f net8.0 publica em ./bin/Release/net8.0/publish/. No entanto, você pode optar por um caminho de saída simplificado e estrutura de pastas para todas as saídas de compilação. Para obter mais informações, consulte Layout de saída de artefatos.

Dependências nativas

Se o seu aplicativo tiver dependências nativas, ele pode não ser executado em um sistema operacional diferente. Por exemplo, se seu aplicativo usa a API nativa do Windows, ele não será executado no macOS ou Linux. Você precisaria fornecer código específico da plataforma e compilar um executável para cada plataforma.

Considere também que, se uma biblioteca que você mencionou tiver uma dependência nativa, seu aplicativo pode não ser executado em todas as plataformas. No entanto, é possível que um pacote NuGet que você está referenciando tenha incluído versões específicas da plataforma para lidar com as dependências nativas necessárias para você.

Ao distribuir um aplicativo com dependências nativas, talvez seja necessário usar o dotnet publish -r <RID> switch para especificar a plataforma de destino para a qual deseja publicar. Para obter uma lista de identificadores de tempo de execução, consulte Catálogo de identificador de tempo de execução (RID).

Mais informações sobre binários específicos da plataforma são abordadas nas seções Executável dependente do Framework e Implantação independente.

Aplicativo de exemplo

Você pode usar o aplicativo a seguir para explorar os comandos de publicação. O aplicativo é criado executando os seguintes comandos no seu terminal:

mkdir apptest1
cd apptest1
dotnet new console
dotnet add package Figgle

O Program.cs arquivo ou Program.vb gerado pelo modelo de console precisa ser alterado para o seguinte:

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

Quando você executa o aplicativo (dotnet run), a seguinte saída é exibida:

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

Implantação dependente da estrutura

Quando você publica seu aplicativo como um FDD, um <PROJECT-NAME>.dll arquivo é criado na ./bin/<BUILD-CONFIGURATION>/<TFM>/publish/ pasta. Para executar seu aplicativo, navegue até a pasta de saída e use o dotnet <PROJECT-NAME>.dll comando.

Seu aplicativo está configurado para direcionar uma versão específica do .NET. Esse tempo de execução .NET direcionado é necessário para estar em qualquer máquina em que seu aplicativo seja executado. Por exemplo, se seu aplicativo tiver como destino o .NET Core 8, qualquer máquina em que seu aplicativo seja executado deverá ter o tempo de execução do .NET Core 8 instalado. Conforme indicado na seção Noções básicas de publicação, você pode editar seu arquivo de projeto para alterar a estrutura de destino padrão ou para direcionar mais de uma estrutura.

A publicação de um FDD cria um aplicativo que avança automaticamente para o patch de segurança .NET mais recente disponível no sistema que executa o aplicativo. Para obter mais informações sobre vinculação de versão em tempo de compilação, consulte Selecione a versão .NET a ser usada.

Modo de publicação	Comando
Implantação dependente da estrutura	`dotnet publish -c Release -p:UseAppHost=false`

Executável dependente da estrutura

Executável dependente de estrutura (FDE) é o modo padrão para o comando básico dotnet publish . Não é necessário especificar outros parâmetros, desde que pretenda visar o sistema operativo atual.

Nesse modo, um host executável específico da plataforma é criado para hospedar seu aplicativo multiplataforma. Este modo é semelhante ao FDD, pois o FDD requer um host na forma do dotnet comando. O nome do arquivo executável do host varia de acordo com a plataforma e é nomeado algo semelhante ao <PROJECT-FILE>.exe. Você pode executar esse executável diretamente em vez de chamar dotnet <PROJECT-FILE>.dll, que ainda é uma maneira aceitável de executar o aplicativo.

Seu aplicativo está configurado para direcionar uma versão específica do .NET. Esse tempo de execução .NET direcionado é necessário para estar em qualquer máquina em que seu aplicativo seja executado. Por exemplo, se seu aplicativo tiver como destino o .NET 8, qualquer máquina em que seu aplicativo seja executado deverá ter o tempo de execução do .NET 8 instalado. Conforme indicado na seção Noções básicas de publicação, você pode editar seu arquivo de projeto para alterar a estrutura de destino padrão ou para direcionar mais de uma estrutura.

A publicação de um FDE cria um aplicativo que avança automaticamente para o patch de segurança .NET mais recente disponível no sistema que executa o aplicativo. Para obter mais informações sobre vinculação de versão em tempo de compilação, consulte Selecione a versão .NET a ser usada.

Modo de publicação	Comando
Executável dependente da estrutura	`dotnet publish -c Release -r <RID> --self-contained false` `dotnet publish -c Release`

Sempre que você usa o -r switch, o caminho da pasta de saída muda para: ./bin/<BUILD-CONFIGURATION>/<TFM>/<RID>/publish/

Se você usar o aplicativo de exemplo, execute dotnet publish -f net6.0 -r win-x64 --self-contained false. Este comando cria o seguinte executável: ./bin/Debug/net6.0/win-x64/publish/apptest1.exe

Nota

Você pode reduzir o tamanho total de sua implantação habilitando o modo invariante de globalização. Esse modo é útil para aplicativos que não estão globalmente cientes e que podem usar as convenções de formatação, convenções de caixa e comparação de cadeia de caracteres e ordem de classificação da cultura invariante. Para obter mais informações sobre o modo invariante de globalização e como habilitá-lo, consulte Modo invariante de globalização do .NET.

Implantação autônoma

Quando você publica uma implantação independente (SCD), o SDK do .NET cria um executável específico da plataforma. A publicação de um SCD inclui todos os arquivos .NET necessários para executar seu aplicativo, mas não inclui as dependências nativas do .NET (por exemplo, para .NET 6 no Linux ou .NET 8 no Linux). Essas dependências devem estar presentes no sistema antes que o aplicativo seja executado.

A publicação de um SCD cria um aplicativo que não avança para o patch de segurança .NET mais recente disponível. Para obter mais informações sobre vinculação de versão em tempo de compilação, consulte Selecione a versão .NET a ser usada.

Você deve usar as seguintes opções com o dotnet publish comando para publicar um SCD:

-r <RID>

Essa opção usa um identificador (RID) para especificar a plataforma de destino. Para obter uma lista de identificadores de tempo de execução, consulte Catálogo de identificador de tempo de execução (RID).
--self-contained true

Essa opção informa ao SDK do .NET para criar um executável como um SCD.

Modo de publicação	Comando
Implantação autônoma	`dotnet publish -c Release -r <RID> --self-contained true`

Gorjeta

No .NET 6 e versões posteriores, você pode reduzir o tamanho total de aplicativos autônomos compatíveis publicando cortados. Isso permite que o trimmer remova partes da estrutura e assemblies referenciados que não estão em nenhum caminho de código ou potencialmente referenciados na reflexão de tempo de execução. Consulte Incompatibilidades de corte para determinar se o corte faz sentido para seu aplicativo.
Você pode reduzir o tamanho total de sua implantação habilitando o modo invariante de globalização. Esse modo é útil para aplicativos que não estão globalmente cientes e que podem usar as convenções de formatação, convenções de caixa e comparação de cadeia de caracteres e ordem de classificação da cultura invariante. Para obter mais informações sobre o modo invariante de globalização e como habilitá-lo, consulte Modo invariante de globalização do .NET Core.

Partilhar via