Implantar aplicativos .NET Core com o Visual Studio

Você pode implantar um aplicativo .NET Core como uma implantação dependente de estrutura, que inclui os binários do seu aplicativo, mas depende da presença do .NET Core no sistema de destino, ou como uma implantação autocontida, que inclui os binários do seu aplicativo e do .NET Core. Para obter uma visão geral da implantação de aplicativos .NET Core, consulte Implantação de aplicativos .NET Core.

As seções a seguir mostram como usar o Microsoft Visual Studio para criar os seguintes tipos de implantações:

• Implantação dependente de estrutura
• Implantação dependente de estrutura com dependências de terceiros
• Implantação autocontida
• Implantação autocontida com dependências de terceiros

Para obter mais informações sobre como usar o Visual Studio para desenvolver aplicativos .NET Core, consulte Dependências e requisitos do .NET Core.

Implantação dependente de estrutura

Implantar uma implantação dependente de estrutura sem dependências de terceiros significa simplesmente compilar, testar e publicar o aplicativo. Um exemplo simples criado em C# ilustra o processo.

1. Crie o projeto.

   Selecione Arquivo>Novo>Projeto. Na caixa de diálogo Novo projeto, expanda as categorias de projeto (C# ou Visual Basic) de sua linguagem no painel de tipos de projeto Instalados, escolha .NET Core e, em seguida, selecione o modelo Aplicativo de console (.NET Core) no painel central. Insira um nome de projeto, como "FDD" na caixa de texto Nome. Selecione o botão OK.

2. Adicione o código-fonte do aplicativo.

   Abra o arquivo Program.cs ou Program.vb no editor e substitua o código gerado automaticamente com o seguinte código. Ele solicitará que o usuário insira texto e exibirá as palavras individuais inseridas pelo usuário. Ele usa a expressão regular \w+ para separar as palavras no texto de entrada.

   using System;
   using System.Text.RegularExpressions;
   
   namespace Applications.ConsoleApps
   {
       public class ConsoleParser
       {
           public static void Main()
           {
               Console.WriteLine("Enter any text, followed by <Enter>:\n");
               String? s = Console.ReadLine();
               ShowWords(s ?? "You didn't enter anything.");
               Console.Write("\nPress any key to continue... ");
               Console.ReadKey();
           }
   
           private static void ShowWords(String s)
           {
               String pattern = @"\w+";
               var matches = Regex.Matches(s, pattern);
               if (matches.Count == 0)
               {
                   Console.WriteLine("\nNo words were identified in your input.");
               }
               else
               {
                   Console.WriteLine($"\nThere are {matches.Count} words in your string:");
                   for (int ctr = 0; ctr < matches.Count; ctr++)
                   {
                       Console.WriteLine($"   #{ctr,2}: '{matches[ctr].Value}' at position {matches[ctr].Index}");
                   }
               }
           }
       }
   }
   

   Imports System.Text.RegularExpressions
   
   Namespace Applications.ConsoleApps
       Public Module ConsoleParser
           Public Sub Main()
               Console.WriteLine("Enter any text, followed by <Enter>:")
               Console.WriteLine()
               Dim s = Console.ReadLine()
               ShowWords(s)
               Console.Write($"{vbCrLf}Press any key to continue... ")
               Console.ReadKey()
           End Sub
   
           Private Sub ShowWords(s As String)
               Dim pattern = "\w+"
               Dim matches = Regex.Matches(s, pattern)
               Console.WriteLine()   
               If matches.Count = 0 Then
                   Console.WriteLine("No words were identified in your input.")
               Else
                   Console.WriteLine($"There are {matches.Count} words in your string:")
                   For ctr = 0 To matches.Count - 1
                       Console.WriteLine($"   #{ctr,2}: '{matches(ctr).Value}' at position {matches(ctr).Index}")
                   Next
               End If
               Console.WriteLine()
           End Sub
       End Module
   End Namespace
   
   

3. Crie um build de depuração do seu aplicativo.

   Selecione Compilar>Compilar Solução. Você também pode compilar e executar o build de Depuração do aplicativo selecionando Depurar>Iniciar Depuração.

4. Implante seu aplicativo.

   Depois de ter depurado e testado o programa, crie os arquivos a serem implantados com seu aplicativo. Para publicar do Visual Studio, faça o seguinte:

   1. Altere a configuração da solução de Depuração para Lançamento na barra de ferramentas para compilar uma versão de lançamento (em vez de uma de depuração) do aplicativo.

   2. Clique com o botão direito do mouse no projeto (e não na solução) no Gerenciador de Soluções e selecione Publicar.

   3. Na guia Publicar, selecione Publicar. O Visual Studio grava os arquivos que compõem seu aplicativo no sistema de arquivos local.

   4. A guia Publicar agora mostra um único perfil FolderProfile. As configurações do perfil são mostradas na seção Resumo da guia.

   Os arquivos resultantes são colocados em um diretório nomeado Publish no Windows e publish em sistemas Unix que está em um subdiretório do subdiretório .\bin\release\netcoreapp2.1 do seu projeto.

Junto com os arquivos do aplicativo, o processo de publicação emite um arquivo de banco de dados do programa (.pdb) que contém informações de depuração sobre seu aplicativo. O arquivo é útil principalmente para exceções de depuração. Você pode optar por não empacotá-lo com os arquivos do aplicativo. No entanto, você deve salvá-lo no caso de desejar depurar o build de lançamento para seu aplicativo.

Implante o conjunto completo de arquivos de aplicativo da maneira que desejar. Por exemplo, você pode empacotá-los em um arquivo zip, usar um simples comando copy ou implantá-los com qualquer pacote de instalação de sua escolha. Uma vez instalado, os usuários podem executar seu aplicativo usando o comando dotnet e fornecendo o nome de arquivo de aplicativo, como dotnet fdd.dll.

Além dos binários do aplicativo, o instalador deverá também agrupar o instalador da estrutura compartilhada ou procurar por ele como um pré-requisito como parte da instalação do aplicativo. A instalação da estrutura compartilhada requer acesso de Administrador/raiz, pois se trata de todo o computador.

Implantação dependente de estrutura com dependências de terceiros

Implantar uma implantação dependente de estrutura com uma ou mais dependências de terceiros requer que todas as dependências estejam disponíveis para seu projeto. As etapas adicionais a seguir são necessárias antes de ser possível compilar seu aplicativo:

1. Use o Gerenciador de Pacotes NuGet para adicionar uma referência a um pacote NuGet ao projeto e se o pacote ainda não estiver disponível no sistema, instale-o. Para abrir o gerenciador de pacotes, selecione Ferramentas>Gerenciador de Pacotes NuGet>Gerenciar Pacotes NuGet para a Solução.

2. Confirme se as dependências de terceiros (por exemplo, Newtonsoft.Json) estão instaladas no sistema e, se não estiverem, instale-as. A guia Instalados lista os pacotes NuGet instalados no sistema. Se Newtonsoft.Json não estiver listado, selecione a guia Procurar e insira "Newtonsoft.Json" na caixa de pesquisa. Selecione Newtonsoft.Json e, no painel direito, selecione seu projeto antes de selecionar Instalar.

3. Se Newtonsoft.Json já estiver instalado no sistema, adicione-o ao projeto selecionando o projeto no painel direito da guia Gerenciar Pacotes para a Solução.

Uma implantação dependente de estrutura com dependências de terceiros é tão portátil quanto as dependências de terceiros. Por exemplo, se uma biblioteca de terceiros der suporte apenas a macOS, o aplicativo não será portátil para sistemas Windows. Isso acontecerá se a dependência de terceiros em si depender do código nativo. Um bom exemplo disso é o servidor Kestrel, que requer uma dependência nativa no libuv. Quando uma FDD é criada para um aplicativo com esse tipo de dependência de terceiros, a saída publicada contém uma pasta para cada RID (Identificador de Runtime) que dá suporte a dependência nativa (e que existe em seu pacote NuGet).

Implantação autocontida sem dependências de terceiros

Implantar uma implantação autocontida sem dependências de terceiros inclui a criação do projeto, a modificação do arquivo csproj, a compilação, os testes e a publicação do aplicativo. Um exemplo simples criado em C# ilustra o processo. Comece criando, codificando e testando seu projeto como você faria com uma implantação que depende da estrutura:

1. Crie o projeto.

   Selecione Arquivo>Novo>Projeto. Na caixa de diálogo Novo projeto, expanda as categorias de projeto (C# ou Visual Basic) de sua linguagem no painel de tipos de projeto Instalados, escolha .NET Core e, em seguida, selecione o modelo Aplicativo de console (.NET Core) no painel central. Insira um nome de projeto, como "SCD" na caixa de texto Nome e selecione o botão OK.

2. Adicione o código-fonte do aplicativo.

   Abra o arquivo Program.cs ou Program.vb no editor e substitua o código gerado automaticamente com o código a seguir. Ele solicitará que o usuário insira texto e exibirá as palavras individuais inseridas pelo usuário. Ele usa a expressão regular \w+ para separar as palavras no texto de entrada.

   using System;
   using System.Text.RegularExpressions;
   
   namespace Applications.ConsoleApps
   {
       public class ConsoleParser
       {
           public static void Main()
           {
               Console.WriteLine("Enter any text, followed by <Enter>:\n");
               String? s = Console.ReadLine();
               ShowWords(s ?? "You didn't enter anything.");
               Console.Write("\nPress any key to continue... ");
               Console.ReadKey();
           }
   
           private static void ShowWords(String s)
           {
               String pattern = @"\w+";
               var matches = Regex.Matches(s, pattern);
               if (matches.Count == 0)
               {
                   Console.WriteLine("\nNo words were identified in your input.");
               }
               else
               {
                   Console.WriteLine($"\nThere are {matches.Count} words in your string:");
                   for (int ctr = 0; ctr < matches.Count; ctr++)
                   {
                       Console.WriteLine($"   #{ctr,2}: '{matches[ctr].Value}' at position {matches[ctr].Index}");
                   }
               }
           }
       }
   }
   

   Imports System.Text.RegularExpressions
   
   Namespace Applications.ConsoleApps
       Public Module ConsoleParser
           Public Sub Main()
               Console.WriteLine("Enter any text, followed by <Enter>:")
               Console.WriteLine()
               Dim s = Console.ReadLine()
               ShowWords(s)
               Console.Write($"{vbCrLf}Press any key to continue... ")
               Console.ReadKey()
           End Sub
   
           Private Sub ShowWords(s As String)
               Dim pattern = "\w+"
               Dim matches = Regex.Matches(s, pattern)
               Console.WriteLine()   
               If matches.Count = 0 Then
                   Console.WriteLine("No words were identified in your input.")
               Else
                   Console.WriteLine($"There are {matches.Count} words in your string:")
                   For ctr = 0 To matches.Count - 1
                       Console.WriteLine($"   #{ctr,2}: '{matches(ctr).Value}' at position {matches(ctr).Index}")
                   Next
               End If
               Console.WriteLine()
           End Sub
       End Module
   End Namespace
   
   

3. Determine se você deseja usar o modo de invariável de globalização.

   Especialmente se seu aplicativo for destinado ao Linux, será possível reduzir o tamanho total da sua implantação usando o modo invariável de globalização. O modo invariável de globalização é útil para aplicativos que não são conhecidos globalmente e que podem usar as convenções de formatação, de maiúsculas e minúsculas e a comparação de cadeia de caracteres e ordem de classificação da cultura invariável.

   Para habilitar o modo invariável, clique com o botão direito do mouse no seu projeto (não na solução) no Gerenciador de Soluções e selecione Editar SCD.csproj ou Editar SCD.vbproj. Em seguida, adicione as seguintes linhas realçadas ao arquivo:

   <Project Sdk="Microsoft.NET.Sdk">
   
     <PropertyGroup>
       <TargetFramework>net8.0</TargetFramework>
       <Nullable>enable</Nullable>
     </PropertyGroup>
   
     <ItemGroup>
       <RuntimeHostConfigurationOption Include="System.Globalization.Invariant" Value="true" />
     </ItemGroup> 
   
   </Project>
   

4. Crie um build de depuração do seu aplicativo.

   Selecione Compilar>Compilar Solução. Você também pode compilar e executar o build de Depuração do aplicativo selecionando Depurar>Iniciar Depuração. Essa etapa de depuração permite identificar problemas com seu aplicativo quando ele está em execução em sua plataforma de host. Ainda será necessário testá-lo em cada uma de suas plataformas de destino.

   Se você tiver habilitado o modo invariável de globalização, certifique-se principalmente de testar se a ausência de dados que levam em conta a cultura é adequada para o seu aplicativo.

Após concluir a depuração, será possível publicar sua implantação independente:

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>netcoreapp2.1</TargetFramework>
    <RuntimeIdentifiers>win-x64;osx-x64</RuntimeIdentifiers>
  </PropertyGroup>
</Project>

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>netcoreapp2.1</TargetFramework>
  </PropertyGroup>
</Project>

<?xml version="1.0" encoding="utf-8"?>
<!--
https://go.microsoft.com/fwlink/?LinkID=208121.
-->
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <PropertyGroup>
    <PublishProtocol>FileSystem</PublishProtocol>
    <Configuration>Release</Configuration>
    <Platform>Any CPU</Platform>
    <TargetFramework>netcoreapp2.1</TargetFramework>
    <PublishDir>bin\Release\netcoreapp2.1\publish\linux</PublishDir>
    <RuntimeIdentifier>win-x86</RuntimeIdentifier>
    <SelfContained>true</SelfContained>
    <_IsPortable>false</_IsPortable>
  </PropertyGroup>
</Project>

Implantação autocontida com dependências de terceiros

Implantar uma implantação autocontida com uma ou mais dependências de terceiros envolve adicionar as dependências. As etapas adicionais a seguir são necessárias antes de ser possível compilar seu aplicativo:

1. Use o Gerenciador de Pacotes NuGet para adicionar uma referência a um pacote NuGet ao projeto e se o pacote ainda não estiver disponível no sistema, instale-o. Para abrir o gerenciador de pacotes, selecione Ferramentas>Gerenciador de Pacotes NuGet>Gerenciar Pacotes NuGet para a Solução.

2. Confirme se as dependências de terceiros (por exemplo, Newtonsoft.Json) estão instaladas no sistema e, se não estiverem, instale-as. A guia Instalados lista os pacotes NuGet instalados no sistema. Se Newtonsoft.Json não estiver listado, selecione a guia Procurar e insira "Newtonsoft.Json" na caixa de pesquisa. Selecione Newtonsoft.Json e, no painel direito, selecione seu projeto antes de selecionar Instalar.

3. Se Newtonsoft.Json já estiver instalado no sistema, adicione-o ao projeto selecionando o projeto no painel direito da guia Gerenciar Pacotes para a Solução.

A seguir está o arquivo csproj completo para esse projeto:

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>netcoreapp2.1</TargetFramework>
    <RuntimeIdentifiers>win-x64;osx-x64</RuntimeIdentifiers>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="Newtonsoft.Json" Version="10.0.2" />
  </ItemGroup>
</Project>

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>netcoreapp2.1</TargetFramework>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="Newtonsoft.Json" Version="10.0.2" />
  </ItemGroup>
</Project>

Quando você implanta seu aplicativo, todas as dependências de terceiros usadas em seu aplicativo também contém os arquivos do aplicativo. As bibliotecas de terceiros não são necessárias no sistema em que o aplicativo está em execução.

Você só poderá implantar uma implantação independente com uma biblioteca de terceiros em plataformas que tenham suporte para essa biblioteca. Isso é semelhante a ter dependências de terceiros com dependências nativas em sua implantação dependente de estrutura, em que as dependências nativas não existem na plataforma de destino a menos que elas tenham sido instaladas anteriormente.

Confira também

• Implantação do .NET Core Application
• Catálogo de RID (identificador de runtime) do .NET Core