Visão geral da publicação de aplicativos .NET
Os aplicativos criados com o .NET podem ser publicados em dois modos diferentes, e o modo afeta como um usuário executa seu aplicativo.
Publicar a sua aplicação como autónomo produz uma aplicação que inclui o runtime e as bibliotecas do .NET, bem como a sua aplicação e as suas dependências. Os usuários do aplicativo podem executá-lo em uma máquina que não tenha o tempo de execução do .NET instalado.
Publicar a sua aplicação como dependente da framework produz uma aplicação que inclui apenas a própria aplicação e as suas dependências. Os utilizadores da aplicação têm de instalar separadamente o runtime do .NET.
Ambos os modos de publicação produzem um executável específico da plataforma por padrão. Aplicativos dependentes da estrutura podem ser criados sem um executável, e esses aplicativos são multiplataforma.
Quando um executável é produzido, você pode especificar a plataforma de destino com um identificador de tempo de execução (RID). Para mais informações sobre RIDs, veja Catálogo de RID do .NET.
A tabela a seguir descreve os comandos usados para publicar um aplicativo como dependente da estrutura ou independente:
| Tipo | Comando |
|---|---|
| executável dependente de framework para a plataforma atual. | dotnet publish |
| executáveis dependentes da estrutura para uma plataforma específica. | dotnet publish -r <RID> |
| binárias dependentes da estrutura . | dotnet publish |
| executável independente. | dotnet publish -r <RID> --self-contained |
Para obter mais informações, consulte comando .NET dotnet publish.
Produzir um executável
Os executáveis não são multiplataforma, eles são específicos para um sistema operacional e arquitetura de CPU. Ao publicar a sua aplicação e criar um executável, pode publicá-lo como autónomo ou dependente de estrutura. Publicar uma aplicação como autossuficiente inclui o runtime do .NET com a aplicação, e os utilizadores da aplicação não precisam de se preocupar em instalar o .NET antes de a executar. Publicar um aplicativo como dependente da estrutura não inclui o tempo de execução do .NET; Apenas o aplicativo e dependências de terceiros estão incluídos.
Os comandos a seguir produzem um executável:
| Tipo | Comando |
|---|---|
| executável dependente de framework para a plataforma atual. | dotnet publish |
| executáveis dependentes da estrutura para uma plataforma específica. | dotnet publish -r <RID> |
| executável independente. | dotnet publish -r <RID> --self-contained |
Produzir um binário multiplataforma
Os binários multiplataforma são criados quando publica a sua aplicação como dependente da estrutura, sob a forma de um ficheiro dll. O arquivo dll é nomeado após o seu projeto. Por exemplo, se você tiver um aplicativo chamado word_reader, um arquivo chamado word_reader.dll será criado. As aplicações publicadas desta forma são executadas com o comando dotnet <filename.dll> e podem ser executadas em qualquer plataforma.
Os binários multiplataforma podem ser executados em qualquer sistema operativo, desde que o runtime .NET pretendido já esteja instalado. Se o tempo de execução do .NET de destino não estiver instalado, o aplicativo poderá ser executado usando um tempo de execução mais recente se o aplicativo estiver configurado para roll-forward. Para obter mais informações, consulte aplicações dependentes da estrutura que avançam automaticamente.
Você pode optar por executar o aplicativo como um executável específico da plataforma ou como um binário entre plataformas por meio dotnet comando. Não deve haver diferença de comportamento do aplicativo ao iniciar o executável específico da plataforma versus o comando dotnet para aplicativos de servidor comuns A inicialização por meio de um executável específico da plataforma oferece uma melhor integração com o sistema operacional subjacente. Por exemplo:
- Você vê o nome executável do aplicativo em sua lista de processos e não
dotnet, o que pode ser confuso se houver mais de um. - Você pode personalizar o executável específico da plataforma com recursos específicos do sistema operacional. Por exemplo, consulte esta discussão sobre como configurar o tamanho da pilha padrão no Windows.
O comando a seguir produz um binário entre plataformas:
| Tipo | Comando |
|---|---|
| binário multiplataforma dependente da estrutura . | dotnet publish |
Publicar dependente da estrutura
Os aplicativos publicados como dependentes da estrutura são multiplataforma e não incluem o tempo de execução do .NET. O utilizador da sua aplicação tem de instalar o .NET runtime.
A publicação de um aplicativo como dependente da estrutura produz um binário de plataforma cruzada
O binário multiplataforma do seu aplicativo pode ser executado com o comando dotnet <filename.dll> e pode ser executado em qualquer plataforma.
Específico da plataforma e dependente da estrutura
Você pode publicar um aplicativo dependente da estrutura que seja específico da plataforma passando os parâmetros -r <RID> para o comando dotnet publish. Publicar desta forma é o mesmo que publicar dependente de framework , a única diferença é o tratamento das dependências específicas da plataforma. Se o aplicativo usar um pacote NuGet com implementações específicas da plataforma, somente as dependências da plataforma de destino serão copiadas. Essas dependências são copiadas diretamente para a pasta de publicação .
Embora tecnicamente o binário produzido seja multiplataforma, ao segmentar uma plataforma específica, não é garantido que seu aplicativo seja executado entre plataformas. Você pode executar dotnet <filename.dll>, mas o aplicativo pode falhar quando tenta acessar dependências específicas da plataforma que estão faltando.
Para obter mais informações sobre RIDs, consulte Catálogo RID do .NET.
Vantagens
Pequena implantação
Apenas a sua aplicação e as suas dependências são distribuídas. O tempo de execução e as bibliotecas do .NET são instalados pelo usuário e todos os aplicativos compartilham o tempo de execução.multiplataforma
O seu aplicativo e qualquer biblioteca baseada em .NET execute em outros sistemas operativos. Você não precisa definir uma plataforma de destino para seu aplicativo. Para obter informações sobre o formato de arquivo .NET, consulte .NET Assembly File Format.Usa o tempo de execução corrigido mais recente
A aplicação utiliza o tempo de execução mais recente (dentro da versão principal-secundária alvo do .NET) instalado no sistema alvo. Isso significa que seu aplicativo usa automaticamente a versão corrigida mais recente do tempo de execução do .NET. Esse comportamento padrão pode ser substituído. Para obter mais informações, consulte avanço de aplicações dependentes da framework.
Desvantagens
Requer a pré-instalação do tempo de execução
Seu aplicativo só pode ser executado se a versão do .NET que seu aplicativo destina já estiver instalada no sistema host. Você pode configurar o comportamento de roll-forward para que o aplicativo exija uma versão específica do .NET ou permita uma versão mais recente do .NET. Para obter mais informações, consulte aplicações dependentes da framework com atualização progressiva..NET pode mudar
É possível que o tempo de execução e as bibliotecas do .NET sejam atualizados na máquina em que o aplicativo é executado. Em casos raros, isso pode alterar o comportamento do seu aplicativo se você usar as bibliotecas .NET, o que a maioria dos aplicativos faz. Você pode configurar como seu aplicativo usa versões mais recentes do .NET. Para mais informações, consulte aplicações dependentes da estrutura que avançam automaticamente.
Exemplos
Publique uma aplicação como multiplataforma e dependente do framework. Um executável direcionado à sua plataforma atual é criado junto com o arquivo dll
dotnet publish
Publique um aplicativo como específico da plataforma e dependente da estrutura. Um executável Linux de 64 bits é criado junto com o arquivo dll
dotnet publish -r linux-x64
Publicar autossuficiente
Publicar seu aplicativo como autônomo produz um executável específico da plataforma. A pasta de publicação de saída contém todos os componentes do aplicativo, incluindo as bibliotecas .NET e o tempo de execução de destino. O aplicativo é isolado de outros aplicativos .NET e não usa um tempo de execução compartilhado instalado localmente. O usuário do seu aplicativo não precisa baixar e instalar o .NET.
Você pode publicar um aplicativo independente passando o parâmetro --self-contained para o comando dotnet publish. O binário executável é produzido para a plataforma de destino especificada. Por exemplo, se tiveres uma aplicação chamada word_readere publicares um executável autónomo para Windows, um arquivo word_reader.exe será criado. Ao publicar para Linux ou macOS, é criado um arquivo word_reader. A plataforma e a arquitetura de destino são especificadas com o parâmetro -r <RID> para o comando dotnet publish. Para obter mais informações sobre RIDs, consulte Catálogo RID do .NET.
Se o aplicativo tiver dependências específicas da plataforma, como um pacote NuGet contendo dependências específicas da plataforma, elas serão copiadas para a pasta de publicação junto com o aplicativo.
Vantagens
Controlar a versão do .NET
Você controla qual versão do .NET é implantada com seu aplicativo.Segmentação específica da plataforma
Como você precisa publicar seu aplicativo para cada plataforma, você sabe onde seu aplicativo é executado. Se o .NET introduzir uma nova plataforma, os usuários não poderão executar seu aplicativo nessa plataforma até que você lance uma versão direcionada a essa plataforma. Você pode testar seu aplicativo quanto a problemas de compatibilidade antes que os usuários executem seu aplicativo na nova plataforma.
Desvantagens
Implantações maiores
Como seu aplicativo inclui o tempo de execução do .NET e todas as dependências do aplicativo, o tamanho do download e o espaço no disco rígido necessários são maiores do que uma versão dependente da estrutura. Dica
Você pode reduzir o tamanho de sua implantação em sistemas Linux em aproximadamente 28 MB usando o .NET modo invariante de globalização. Isso força seu aplicativo a tratar todas as culturas como a cultura invariante.
Dica
A poda de IL pode reduzir ainda mais o tamanho da sua implantação.
Mais difícil atualizar a versão do .NET
O .NET Runtime (distribuído com seu aplicativo) só pode ser atualizado lançando uma nova versão do seu aplicativo.
Exemplos
Publique um aplicativo independente. É criado um executável macOS de 64 bits.
dotnet publish -r osx-x64 --self-contained
Publique um aplicativo independente. Um executável do Windows de 64 bits é criado.
dotnet publish -r win-x64 --self-contained
Publicar utilizando imagens ReadyToRun
A publicação com imagens ReadyToRun melhora o tempo de inicialização da sua aplicação, mas aumenta o seu tamanho. Para obter mais informações, consulte ReadyToRun.
Vantagens
-
Tempo de inicialização melhorado
O aplicativo gasta menos tempo executando o JIT.
Desvantagens
-
Tamanho maior
O aplicativo é maior no disco.
Exemplos
Publique um aplicativo independente e ReadyToRun. É criado um executável macOS de 64 bits.
dotnet publish -c Release -r osx-x64 --self-contained -p:PublishReadyToRun=true
Publique uma aplicação independente e ReadyToRun (pronto para execução). Um executável do Windows de 64 bits é criado.
dotnet publish -c Release -r win-x64 --self-contained -p:PublishReadyToRun=true
