Publicar aplicativos .NET com a CLI do .NET

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.

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.

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.

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

Configurar o comportamento de pesquisa de instalação do .NET

No .NET 9 e versões posteriores, você pode configurar os caminhos de pesquisa de instalação do .NET do executável publicado por meio das AppHostDotNetSearch propriedades e AppHostRelativeDotNet .

AppHostDotNetSearch permite especificar um ou mais locais onde o executável procurará uma instalação .NET:

• AppLocal: pasta do executável do aplicativo
• AppRelative: caminho relativo ao executável do aplicativo
• EnvironmentVariables: valor das variáveis de DOTNET_ROOT[_<arch>] ambiente
• Global: locais de instalação globais registrados e padrão

AppHostRelativeDotNet especifica o caminho relativo ao executável que será pesquisado quando AppHostDotNetSearch contiver AppRelative.

Para obter mais informações, consulte AppHostDotNetSearche AppHostRelativeDotNet instale as opções de localização no apphost.

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.

Consulte também

• Visão geral da implantação de aplicativos .NET
• Catálogo do .NET Runtime IDentifier (RID)