Implantar aplicativos .NET Core com o Visual Studio

Você pode implantar um aplicativo .NET Core como uma implantação dependente da estrutura, que inclui os binários do aplicativo, mas depende da presença do .NET Core no sistema de destino, ou como uma implantação independente, que inclui seus binários do aplicativo e do .NET Core. Para obter uma visão geral da implantação do aplicativo .NET Core, consulte Implantação do aplicativo .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 da estrutura
• Implantação dependente da estrutura com dependências de terceiros
• Implantação autônoma
• Implantação autônoma com dependências de terceiros

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

Implantação dependente da estrutura

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

1. Crie o projeto.

   Selecione Ficheiro>Novo>Projeto. Na caixa de diálogo Novo Projeto, expanda as categorias de projeto do seu idioma (C# ou Visual Basic) no painel Tipos de projeto instalados, escolha .NET Core e 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 pelo código a seguir. Ele solicita que o usuário insira texto e exibe as palavras individuais inseridas pelo usuário. Ele usa a expressão \w+ regular 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 uma compilação de depuração do seu aplicativo.

   Selecione Build Build Solution (Criar>solução de compilação). Você também pode compilar e executar a compilação Debug do seu aplicativo selecionando Debug>Start Debugging.

4. Implante seu aplicativo.

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

   1. Altere a configuração da solução de Debug para Release na barra de ferramentas para criar uma versão Release (em vez de Debug) do seu aplicativo.

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

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

   4. A guia Publicar agora mostra um único perfil, FolderProfile. As definições de configuração 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 seu aplicativo, o processo de publicação emite um arquivo de banco de dados de programa (.pdb) que contém informações de depuração sobre seu aplicativo. O arquivo é útil principalmente para depurar exceções. Você pode optar por não empacotá-lo com os arquivos do seu aplicativo. No entanto, você deve salvá-lo caso queira depurar a compilação Release do seu aplicativo.

Implante o conjunto completo de arquivos do aplicativo da maneira que desejar. Por exemplo, você pode empacotá-los em um arquivo Zip, usar um comando simples 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 dotnet comando e fornecendo o nome do arquivo do aplicativo, como dotnet fdd.dll.

Além dos binários do aplicativo, o instalador também deve agrupar o instalador da estrutura compartilhada ou verificá-lo como pré-requisito como parte da instalação do aplicativo. A instalação da estrutura compartilhada requer acesso Administrador/raiz, uma vez que é em toda a máquina.

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

A implantação de uma implantação dependente da estrutura com uma ou mais dependências de terceiros requer que todas as dependências estejam disponíveis para seu projeto. As seguintes etapas adicionais são necessárias antes que você possa criar seu aplicativo:

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

2. Confirme se as dependências de terceiros (por exemplo, Newtonsoft.Json) estão instaladas no seu sistema e, se não estiverem, instale-as. A guia Instalado lista os pacotes NuGet instalados no seu sistema. Se Newtonsoft.Json não estiver listado lá, selecione a guia Procurar e digite "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 em seu sistema, adicione-o ao seu projeto selecionando seu projeto no painel direito da guia Gerenciar pacotes para solução .

Uma implantação dependente da estrutura com dependências de terceiros é tão portátil quanto suas dependências de terceiros. Por exemplo, se uma biblioteca de terceiros suportar apenas macOS, a aplicação não é portátil para sistemas Windows. Isso acontece se a própria dependência de terceiros depender de código nativo. Um bom exemplo disso é o servidor Kestrel, que requer uma dependência nativa do libuv. Quando um FDD é criado para um aplicativo com esse tipo de dependência de terceiros, a saída publicada contém uma pasta para cada Identificador de Tempo de Execução (RID) que a dependência nativa suporta (e que existe em seu pacote NuGet).

Implantação autônoma sem dependências de terceiros

A implantação de uma implantação autônoma sem dependências de terceiros envolve a criação do projeto, a modificação do arquivo csproj, a criação, o teste e a publicação do aplicativo. Um exemplo simples escrito em C# ilustra o processo. Você começa criando, codificando e testando seu projeto da mesma forma que faria com uma implantação dependente da estrutura:

1. Crie o projeto.

   Selecione Ficheiro>Novo>Projeto. Na caixa de diálogo Novo Projeto, expanda as categorias de projeto do seu idioma (C# ou Visual Basic) no painel Tipos de projeto instalados, escolha .NET Core e selecione o modelo Aplicativo de Console (.NET Core) no painel central. Digite 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 pelo código a seguir. Ele solicita que o usuário insira texto e exibe as palavras individuais inseridas pelo usuário. Ele usa a expressão \w+ regular 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 invariante de globalização.

   Particularmente se seu aplicativo tem como alvo o Linux, você pode reduzir o tamanho total de sua implantação aproveitando o modo invariante de globalização. O modo invariante de globalização é útil para aplicativos que não são globalmente conscientes 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 habilitar o modo invariante, clique com o botão direito do mouse em 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 uma compilação de depuração do seu aplicativo.

   Selecione Build Build Solution (Criar>solução de compilação). Você também pode compilar e executar a compilação Debug do seu aplicativo selecionando Debug>Start Debugging. Esta etapa de depuração permite identificar problemas com seu aplicativo quando ele está sendo executado em sua plataforma host. Você ainda terá que testá-lo em cada uma das suas plataformas de destino.

   Se você habilitou o modo invariante de globalização, certifique-se de testar se a ausência de dados sensíveis à cultura é adequada para seu aplicativo.

Depois de concluir a depuração, você pode 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 autônoma com dependências de terceiros

A implantação de uma implantação autônoma com uma ou mais dependências de terceiros envolve a adição das dependências. As seguintes etapas adicionais são necessárias antes que você possa criar seu aplicativo:

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

2. Confirme se as dependências de terceiros (por exemplo, Newtonsoft.Json) estão instaladas no seu sistema e, se não estiverem, instale-as. A guia Instalado lista os pacotes NuGet instalados no seu sistema. Se Newtonsoft.Json não estiver listado lá, selecione a guia Procurar e digite "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 em seu sistema, adicione-o ao seu projeto selecionando seu projeto no painel direito da guia Gerenciar pacotes para solução .

A seguir está o arquivo csproj completo para este 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 estão contidas nos arquivos do aplicativo. Bibliotecas de terceiros não são necessárias no sistema no qual o aplicativo está sendo executado.

Você só pode implantar uma implantação independente com uma biblioteca de terceiros em plataformas suportadas por essa biblioteca. Isso é semelhante a ter dependências de terceiros com dependências nativas em sua implantação dependente da estrutura, onde as dependências nativas não existirão na plataforma de destino, a menos que tenham sido instaladas anteriormente lá.

Consulte também

• Implantação de aplicativos .NET Core
• Catálogo do .NET Core Runtime Identifier (RID)