Novidades do .NET Core 3.0What's new in .NET Core 3.0

Este artigo descreve o que há de novo no .NET Core 3,0.This article describes what is new in .NET Core 3.0. Um dos maiores avanços é o suporte para aplicativos Windows de área de trabalho (somente Windows).One of the biggest enhancements is support for Windows desktop applications (Windows only). Usando a Área de Trabalho do Windows do componente de SDK do .NET Core 3.0, você pode portar seus aplicativos Windows Forms e WPF (Windows Presentation Foundation).By using the .NET Core 3.0 SDK component Windows Desktop, you can port your Windows Forms and Windows Presentation Foundation (WPF) applications. Para deixar claro, o componente Windows Desktop só é compatível com o Windows e só é incluído nele.To be clear, the Windows Desktop component is only supported and included on Windows. Para obter mais informações, consulte a seção Área de Trabalho do Windows mais adiante neste artigo.For more information, see the Windows desktop section later in this article.

O .NET Core 3.0 adiciona suporte para C# 8.0..NET Core 3.0 adds support for C# 8.0. É altamente recomendável que você use o Visual Studio 2019 versão 16,3 ou mais recente, Visual Studio para Mac 8,3 ou mais recente ou Visual Studio Code com a C# extensãomais recente.It's highly recommended that you use Visual Studio 2019 version 16.3 or newer, Visual Studio for Mac 8.3 or newer, or Visual Studio Code with the latest C# extension.

Baixe e comece a usar o .NET Core 3,0 agora no Windows, no MacOS ou no Linux.Download and get started with .NET Core 3.0 right now on Windows, macOS, or Linux.

Para obter mais informações sobre a versão, consulte o anúncio do .NET Core 3,0.For more information about the release, see the .NET Core 3.0 announcement.

O .NET Core RC1 foi considerado pronto para produção pela Microsoft e foi totalmente suportado..NET Core RC1 was considered production ready by Microsoft and was fully supported. Se você estiver usando uma versão de visualização, deverá mover para a versão RTM para obter suporte contínuo.If you're using a preview release, you must move to the RTM version for continued support.

Melhorias na C# linguagem 8,0Language improvements C# 8.0

C#8,0 também faz parte desta versão, que inclui o recurso de tipos de referência anulável , fluxos assíncronose mais padrões.C# 8.0 is also part of this release, which includes the nullable reference types feature, async streams, and more patterns. Para obter mais informações sobre recursos do C# 8.0, consulte Novidades do C# 8.0.For more information about C# 8.0 features, see What's new in C# 8.0.

Foram adicionados aprimoramentos de linguagem para dar suporte aos seguintes recursos de API detalhados abaixo:Language enhancements were added to support the following API features detailed below:

.NET Standard 2.1.NET Standard 2.1

O .NET Core 3,0 implementa .NET Standard 2,1..NET Core 3.0 implements .NET Standard 2.1. No entanto, o modelo de dotnet new classlib padrão gera um projeto que ainda tem como alvo .NET Standard 2,0.However, the default dotnet new classlib template generates a project that still targets .NET Standard 2.0. Para direcionar ao .NET Standard 2.1, edite seu arquivo de projeto e altere a propriedade TargetFramework para netstandard2.1:To target .NET Standard 2.1, edit your project file and change the TargetFramework property to netstandard2.1:

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <TargetFramework>netstandard2.1</TargetFramework>
  </PropertyGroup>

</Project>

Se você estiver usando o Visual Studio, precisará do Visual Studio 2019, já que o Visual Studio 2017 não dá suporte ao .NET Standard 2.1 nem ao .NET Core 3.0.If you're using Visual Studio, you need Visual Studio 2019, as Visual Studio 2017 doesn't support .NET Standard 2.1 or .NET Core 3.0.

Compilar/implantarCompile/Deploy

Executáveis por padrãoDefault executables

O .NET Core agora compila executáveis dependentes de estrutura por padrão..NET Core now builds framework-dependent executables by default. Esse comportamento é novo para aplicativos que usam uma versão do .NET Core instalada globalmente.This behavior is new for applications that use a globally installed version of .NET Core. Anteriormente, apenas implantações autocontidas produziam um executável.Previously, only self-contained deployments would produce an executable.

Durante dotnet build ou dotnet publish, é criado um executável que corresponde ao ambiente e à plataforma do SDK que você está usando.During dotnet build or dotnet publish, an executable is created that matches the environment and platform of the SDK you're using. Você pode esperar desses executáveis o mesmo que de outros executáveis nativos, como:You can expect the same things with these executables as you would other native executables, such as:

  • Você pode clicar duas vezes no arquivo executável.You can double-click on the executable.
  • Você pode iniciar o aplicativo diretamente de um prompt de comando, como myapp.exe no Windows e ./myapp no Linux e macOS.You can launch the application from a command prompt directly, such as myapp.exe on Windows, and ./myapp on Linux and macOS.

Executáveis de arquivo únicoSingle-file executables

O comando dotnet publish dá suporte ao empacotamento de seu aplicativo em um executável de arquivo único específico da plataforma.The dotnet publish command supports packaging your app into a platform-specific single-file executable. O executável é autoextraível e contém todas as dependências (incluindo nativas) necessárias para a execução do aplicativo.The executable is self-extracting and contains all dependencies (including native) that are required to run your app. Quando o aplicativo é executado pela primeira vez, o aplicativo é extraído para um diretório com base no nome do aplicativo e no identificador do build.When the app is first run, the application is extracted to a directory based on the app name and build identifier. A inicialização é mais rápida quando o aplicativo é executado novamente.Startup is faster when the application is run again. O aplicativo não precisará autoextrair uma segunda vez, a menos que uma versão nova tenha sido usada.The application doesn't need to extract itself a second time unless a new version was used.

Para publicar um único arquivo executável, defina o PublishSingleFile em seu projeto ou na linha de comando com o comando dotnet publish:To publish a single-file executable, set the PublishSingleFile in your project or on the command line with the dotnet publish command:

<PropertyGroup>
  <RuntimeIdentifier>win10-x64</RuntimeIdentifier>
  <PublishSingleFile>true</PublishSingleFile>
</PropertyGroup>

- ou --or-

dotnet publish -r win10-x64 -p:PublishSingleFile=true

Para obter mais informações sobre a publicação de arquivo único, consulte o documento de design de empacotador de arquivo único.For more information about single-file publishing, see the single-file bundler design document.

Vinculação de assemblyAssembly linking

O SDK do .NET Core 3.0 vem com uma ferramenta que pode reduzir o tamanho dos aplicativos analisando a IL e cortando assemblies não utilizados.The .NET core 3.0 SDK comes with a tool that can reduce the size of apps by analyzing IL and trimming unused assemblies.

Os aplicativos autossuficientes incluem todos os componentes necessários para executar seu código, sem exigir que o .NET seja instalado no computador host.Self-contained apps include everything needed to run your code, without requiring .NET to be installed on the host computer. No entanto, muitas vezes o aplicativo requer apenas um pequeno subconjunto da estrutura para funcionar, e outras bibliotecas não utilizadas podem ser removidas.However, many times the app only requires a small subset of the framework to function, and other unused libraries could be removed.

O .NET Core agora inclui uma configuração que usará a ferramentaVinculador de IL para verificar a IL do seu aplicativo..NET Core now includes a setting that will use the IL linker tool to scan the IL of your app. Essa ferramenta detecta o código necessário e, em seguida, corta as bibliotecas não utilizadas.This tool detects what code is required, and then trims unused libraries. Ela pode reduzir significativamente o tamanho da implantação de alguns aplicativos.This tool can significantly reduce the deployment size of some apps.

Para habilitá-la, adicione a configuração <PublishTrimmed> ao seu projeto e publique um aplicativo autossuficiente:To enable this tool, add the <PublishTrimmed> setting in your project and publish a self-contained app:

<PropertyGroup>
  <PublishTrimmed>true</PublishTrimmed>
</PropertyGroup>
dotnet publish -r <rid> -c Release

Por exemplo, o modelo básico de novo projeto de console "hello world" incluído, quando publicado, atinge cerca de 70 MB de tamanho.As an example, the basic "hello world" new console project template that is included, when published, hits about 70 MB in size. Usando <PublishTrimmed>, esse tamanho é reduzido para cerca de 30 MB.By using <PublishTrimmed>, that size is reduced to about 30 MB.

É importante considerar que os aplicativos ou estruturas (incluindo ASP.NET Core e WPF) que usam reflexão ou recursos dinâmicos relacionados, geralmente são interrompidos quando cortados.It's important to consider that applications or frameworks (including ASP.NET Core and WPF) that use reflection or related dynamic features, will often break when trimmed. Essa interrupção ocorre porque o vinculador não tem ciência desse comportamento dinâmico e não pode determinar quais tipos de estrutura são necessários para reflexão.This breakage occurs because the linker doesn't know about this dynamic behavior and can't determine which framework types are required for reflection. A ferramenta Vinculador de IL pode ser configurada para estar ciente deste cenário.The IL Linker tool can be configured to be aware of this scenario.

Antes de mais nada, teste seu aplicativo depois de cortar.Above all else, be sure to test your app after trimming.

Para saber mais sobre a ferramenta Vinculador de IL, confira a documentação ou visite o repositório mono/linker.For more information about the IL Linker tool, see the documentation or visit the mono/linker repo.

Compilação em camadasTiered compilation

A TC (compilação em camadas) está ativa por padrão com o .NET Core 3.0.Tiered compilation (TC) is on by default with .NET Core 3.0. Esse recurso permite que o tempo de execução use de modo mais adaptável o compilador JIT (just-in-time) para obter um melhor desempenho.This feature enables the runtime to more adaptively use the Just-In-Time (JIT) compiler to get better performance.

O principal benefício de TC é habilitar métodos de (re)jitting com uma camada de qualidade inferior, porém mais rápida, ou uma camada de qualidade superior, porém mais lenta.The main benefit of TC is to enable (re-)jitting methods with a lower-quality-but-faster tier or a higher-quality-but-slower tier. Isso ajuda a aumentar o desempenho de um aplicativo quando ele passa por vários estágios da execução, desde a inicialização até o estado estável.This helps increase performance of an application as it goes through various stages of execution, from startup through steady-state. Isso contrasta com a abordagem de não TC, em que cada método é compilado de uma única maneira (o mesmo que a camada de alta qualidade) que é mais voltada para o estado estável em detrimento do desempenho de inicialização.This contrasts with the non-TC approach, where every method is compiled a single way (the same as the high-quality tier), which is biased to steady-state over startup performance.

Para habilitar o JIT rápido (código com compilação JIT de camada 0), use esta configuração em seu arquivo de projeto:To enable Quick JIT (tier 0 jitted code), use this setting in your project file:

<PropertyGroup>
  <TieredCompilationQuickJit>true</TieredCompilationQuickJit>
</PropertyGroup>

Para desabilitar completamente a TC, use esta configuração em seu arquivo de projeto:To disable TC completely, use this setting in your project file:

<TieredCompilation>false</TieredCompilation>

Imagens ReadyToRunReadyToRun images

Você pode melhorar o tempo de inicialização do seu aplicativo .NET Core compilando seus assemblies de aplicativos como o formato ReadyToRun (R2R).You can improve the startup time of your .NET Core application by compiling your application assemblies as ReadyToRun (R2R) format. R2R é uma forma de compilação antecipada (AOT).R2R is a form of ahead-of-time (AOT) compilation.

Os binários R2R melhoram o desempenho de inicialização reduzindo a quantidade de trabalho que o compilador just-in-time (JIT) precisa fazer à medida que seu aplicativo é carregado.R2R binaries improve startup performance by reducing the amount of work the just-in-time (JIT) compiler needs to do as your application loads. Os binários contêm código nativo similar comparado ao que o JIT produziria.The binaries contain similar native code compared to what the JIT would produce. Entretanto, os binários R2R são maiores porque contêm código de IL (linguagem intermediária), que ainda é necessário para alguns cenários, e a versão nativa do mesmo código.However, R2R binaries are larger because they contain both intermediate language (IL) code, which is still needed for some scenarios, and the native version of the same code. O R2R só está disponível quando você publica um aplicativo autocontido que tenha como alvo um RID (Runtime Environment) específico, como o Linux x64 ou o Windows x64.R2R is only available when you publish a self-contained app that targets specific runtime environments (RID) such as Linux x64 or Windows x64.

Para compilar seu projeto como ReadyToRun, faça o seguinte:To compile your project as ReadyToRun, do the following:

  1. Adicione a configuração de <PublishReadyToRun> ao seu projeto:Add the <PublishReadyToRun> setting to your project:

    <PropertyGroup>
      <PublishReadyToRun>true</PublishReadyToRun>
    </PropertyGroup>
    
  2. Publique um aplicativo autossuficiente.Publish a self-contained app. Por exemplo, esse comando cria um aplicativo autossuficiente para a versão de 64 bits do Windows:For example, this command creates a self-contained app for the 64-bit version of Windows:

    dotnet publish -c Release -r win-x64 --self-contained
    

Restrições de plataforma cruzada/arquiteturaCross platform/architecture restrictions

O compilador ReadyToRun atualmente não tem suporte para o direcionamento cruzado.The ReadyToRun compiler doesn't currently support cross-targeting. Você precisa compilar em determinado destino.You must compile on a given target. Por exemplo, se você quiser imagens R2R para Windows x64, será necessário executar o comando Publicar nesse ambiente.For example, if you want R2R images for Windows x64, you need to run the publish command on that environment.

Exceções ao direcionamento cruzado:Exceptions to cross-targeting:

  • O Windows x64 pode ser usado para compilar imagens do Windows ARM32, ARM64 e x86.Windows x64 can be used to compile Windows ARM32, ARM64, and x86 images.
  • O Windows x86 pode ser usado para compilar imagens do Windows ARM32.Windows x86 can be used to compile Windows ARM32 images.
  • O Linux x64 pode ser usado para compilar imagens do Linux ARM32 e ARM64.Linux x64 can be used to compile Linux ARM32 and ARM64 images.

Tempo de execução/SDKRuntime/SDK

Roll forward de versão principalMajor-version Roll Forward

O .NET Core 3.0 introduz um recurso opcional que permite que seu aplicativo efetue roll forward para a versão principal mais recente do .NET Core..NET Core 3.0 introduces an opt-in feature that allows your app to roll forward to the latest major version of .NET Core. Adicionalmente, foi adicionada uma nova configuração para controlar como o roll forward é aplicado ao seu aplicativo.Additionally, a new setting has been added to control how roll forward is applied to your app. Isso pode ser configurado das seguintes maneiras:This can be configured in the following ways:

  • Propriedade do arquivo de projeto: RollForwardProject file property: RollForward
  • Propriedade do arquivo de configuração de tempo de execução: rollForwardRuntime configuration file property: rollForward
  • Variável de ambiente: DOTNET_ROLL_FORWARDEnvironment variable: DOTNET_ROLL_FORWARD
  • Argumento de linha de comando: --roll-forwardCommand-line argument: --roll-forward

Um dos valores a seguir precisa ser especificado.One of the following values must be specified. Se a configuração for omitida, Secundária será o padrão.If the setting is omitted, Minor is the default.

  • LatestPatchLatestPatch
    Efetuar roll forward para a versão de patch mais recente.Roll forward to the highest patch version. Isso desabilita o roll forward da versão secundária.This disables minor version roll forward.
  • SecundáriaMinor
    Se a versão secundária solicitada estiver ausente, efetue roll forward para a menor versão secundária mais alta.Roll forward to the lowest higher minor version, if requested minor version is missing. Se a versão secundária solicitada estiver presente, a política LatestPatch será usada.If the requested minor version is present, then the LatestPatch policy is used.
  • PrincipalMajor
    Se a versão principal solicitada estiver ausente, efetuar roll forward para a versão principal mais alta e a versão secundária mais baixa.Roll forward to lowest higher major version, and lowest minor version, if requested major version is missing. Se a versão principal solicitada está presente, a política Secundária é usada.If the requested major version is present, then the Minor policy is used.
  • LatestMinorLatestMinor
    Efetuar roll forward para a versão secundária mais recente, mesmo se a versão secundária solicitada estiver presente.Roll forward to highest minor version, even if requested minor version is present. Destinado a cenários de hospedagem de componente.Intended for component hosting scenarios.
  • LatestMajorLatestMajor
    Efetuar roll forward para a versão principal e a secundária mais altas, mesmo se a principal solicitada estiver presente.Roll forward to highest major and highest minor version, even if requested major is present. Destinado a cenários de hospedagem de componente.Intended for component hosting scenarios.
  • DesabilitarDisable
    Não efetuar roll forward.Don't roll forward. Associar somente à versão especificada.Only bind to specified version. Essa política não é recomendada para uso geral, pois ela desabilita a capacidade de efetuar roll forward para os patches mais recentes.This policy isn't recommended for general use because it disables the ability to roll forward to the latest patches. Esse valor só é recomendado para teste.This value is only recommended for testing.

Com a exceção da configuração Desabilitar, todas as configurações usarão a versão de patch mais recente disponível.Besides the Disable setting, all settings will use the highest available patch version.

O build copia dependênciasBuild copies dependencies

O comando dotnet build agora copia as dependências do NuGet para seu aplicativo do cache NuGet para a pasta de saída de build.The dotnet build command now copies NuGet dependencies for your application from the NuGet cache to the build output folder. Anteriormente, as dependências eram copiadas apenas como parte de dotnet publish.Previously, dependencies were only copied as part of dotnet publish.

Há algumas operações, como vinculação e publicação de página do razor, que ainda exigem publicação.There are some operations, like linking and razor page publishing that will still require publishing.

Ferramentas locaisLocal tools

O .NET Core 3.0 apresenta ferramentas locais..NET Core 3.0 introduces local tools. Ferramentas locais são semelhantes às ferramentas globais, mas estão associadas a um local específico no disco.Local tools are similar to global tools but are associated with a particular location on disk. Ferramentas locais não estão disponíveis globalmente e são distribuídas como pacotes NuGet.Local tools aren't available globally and are distributed as NuGet packages.

Aviso

Se você tiver tentado ferramentas locais no .NET Core 3.0 Versão Prévia 1, tais como executar dotnet tool restore ou dotnet tool install, exclua a pasta de cache local de ferramentas.If you tried local tools in .NET Core 3.0 Preview 1, such as running dotnet tool restore or dotnet tool install, delete the local tools cache folder. Caso contrário, as ferramentas locais não funcionarão em nenhuma versão mais recente.Otherwise, local tools won't work on any newer release. Essa pasta está localizada em:This folder is located at:

No macOS ou Linux: rm -r $HOME/.dotnet/toolResolverCacheOn macOS, Linux: rm -r $HOME/.dotnet/toolResolverCache

No Windows: rmdir /s %USERPROFILE%\.dotnet\toolResolverCacheOn Windows: rmdir /s %USERPROFILE%\.dotnet\toolResolverCache

As ferramentas locais dependem de um nome de arquivo de manifesto dotnet-tools.json no seu diretório atual.Local tools rely on a manifest file name dotnet-tools.json in your current directory. Esse arquivo de manifesto define as ferramentas que estarão disponíveis nessa pasta e abaixo.This manifest file defines the tools to be available at that folder and below. Você pode distribuir o arquivo de manifesto com o seu código para garantir que qualquer pessoa que trabalha com o seu código possa restaurar e usar as mesmas ferramentas.You can distribute the manifest file with your code to ensure that anyone who works with your code can restore and use the same tools.

Para ferramentas globais e locais, é necessária uma versão compatível do tempo de execução.For both global and local tools, a compatible version of the runtime is required. Muitas ferramentas que estão atualmente em NuGet.org direcionam para o tempo de execução do .NET Core 2.1.Many tools currently on NuGet.org target .NET Core Runtime 2.1. Para instalar essas ferramentas, de forma global ou local, você ainda precisará instalar o Tempo de execução do NET Core 2.1.To install these tools globally or locally, you would still need to install the NET Core 2.1 Runtime.

Tamanhos menores de heap de coleta de lixoSmaller Garbage Collection heap sizes

O tamanho do heap do coletor de lixo padrão foi reduzido, resultando em menor uso de memória pelo .NET Core.The Garbage Collector's default heap size has been reduced resulting in .NET Core using less memory. Essa alteração se alinha melhor com o orçamento de alocação de geração 0 com os tamanhos de cache de processadores modernos.This change better aligns with the generation 0 allocation budget with modern processor cache sizes.

Suporte de página grande de coleta de lixoGarbage Collection Large Page support

Páginas grandes (também conhecidas como páginas enormes no Linux) é um recurso em que o sistema operacional é capaz de estabelecer regiões de memória maiores do que o tamanho da página nativo (geralmente 4K) para melhorar o desempenho do aplicativo que está solicitando essas páginas grandes.Large Pages (also known as Huge Pages on Linux) is a feature where the operating system is able to establish memory regions larger than the native page size (often 4K) to improve performance of the application requesting these large pages.

O coletor de lixo agora pode ser configurado com a configuração GCLargePages como um recurso opcional a ser escolhido para alocar páginas grandes no Windows.The Garbage Collector can now be configured with the GCLargePages setting as an opt-in feature to choose to allocate large pages on Windows.

Windows Desktop & COMWindows Desktop & COM

Windows Installer do SDK do .NET Core.NET Core SDK Windows Installer

O instalador MSI para Windows foi alterado do .NET Core 3.0 em diante.The MSI installer for Windows has changed starting with .NET Core 3.0. Os instaladores de SDK agora atualizarão versões de faixa de recurso do SDK no local.The SDK installers will now upgrade SDK feature-band releases in place. Faixas de recurso são definidas nos grupos de centenas na seção patch do número de versão.Feature bands are defined in the hundreds groups in the patch section of the version number. Por exemplo, 3.0.101 e 3.0.201 são versões em duas faixas de recurso diferentes, enquanto 3.0.101 e 3.0.199 estão na mesma faixa de recurso.For example, 3.0.101 and 3.0.201 are versions in two different feature bands while 3.0.101 and 3.0.199 are in the same feature band. Além disso, quando o SDK do .NET Core 3.0.101 for instalado, o SDK do .NET Core 3.0.100 será removido do computador se ele existir.And, when .NET Core SDK 3.0.101 is installed, .NET Core SDK 3.0.100 will be removed from the machine if it exists. Quando o SDK do .NET Core 3.0.200 for instalado no mesmo computador, o SDK do .NET Core 3.0.101 não será removido.When .NET Core SDK 3.0.200 is installed on the same machine, .NET Core SDK 3.0.101 won't be removed.

Para obter mais informações sobre controle de versão, consulte Visão geral de como é o controle de versão no .NET Core.For more information about versioning, see Overview of how .NET Core is versioned.

Área de Trabalho do WindowsWindows desktop

O .NET Core 3.0 dá suporte a aplicativos da Área de Trabalho do Windows usando o Windows Forms e o WPF (Windows Presentation Foundation)..NET Core 3.0 supports Windows desktop applications using Windows Presentation Foundation (WPF) and Windows Forms. Essas estruturas também oferecem suporte ao uso de controles modernos e no estilo Fluent da biblioteca XAML da interface do usuário do Windows (WinUI) por meio de Ilhas XAML.These frameworks also support using modern controls and Fluent styling from the Windows UI XAML Library (WinUI) via XAML islands.

O componente Windows Desktop faz parte do SDK do .NET Core 3.0 do Windows.The Windows Desktop component is part of the Windows .NET Core 3.0 SDK.

É possível criar um novo aplicativo de WPF ou Windows Forms com os seguintes comandos dotnet:You can create a new WPF or Windows Forms app with the following dotnet commands:

dotnet new wpf
dotnet new winforms

O Visual Studio 2019 adiciona modelos de Novo Projeto ao Windows Forms e WPF no .NET Core 3.0.Visual Studio 2019 adds New Project templates for .NET Core 3.0 Windows Forms and WPF.

Para obter mais informações sobre como portar um aplicativo existente do .NET Framework, consulte Portar projetos do WPF e Portar projetos do Windows Forms.For more information about how to port an existing .NET Framework application, see Port WPF projects and Port Windows Forms projects.

WinForms com DPI altoWinForms high DPI

Aplicativos do Windows Forms do .NET Core podem definir o modo de DPI alto com Application.SetHighDpiMode(HighDpiMode)..NET Core Windows Forms applications can set high DPI mode with Application.SetHighDpiMode(HighDpiMode). O método SetHighDpiMode define o modo de DPI alto correspondente, a menos que a configuração tenha sido definida por outros meios, tais como App.Manifest ou P/Invoke antes de Application.Run.The SetHighDpiMode method sets the corresponding high DPI mode unless the setting has been set by other means like App.Manifest or P/Invoke before Application.Run.

Os valores highDpiMode possíveis, conforme expressos pelo enum System.Windows.Forms.HighDpiMode, são:The possible highDpiMode values, as expressed by the System.Windows.Forms.HighDpiMode enum are:

  • DpiUnaware
  • SystemAware
  • PerMonitor
  • PerMonitorV2
  • DpiUnawareGdiScaled

Para obter mais informações sobre os modos de DPI alto, confira Desenvolvimento de aplicativos de área de trabalho de DPI alto no Windows.For more information about high DPI modes, see High DPI Desktop Application Development on Windows.

Criar componentes COMCreate COM components

No Windows, agora você pode criar componentes gerenciados que podem ser chamados por COM.On Windows, you can now create COM-callable managed components. Essa funcionalidade é fundamental para usar o .NET Core com modelos de suplemento do COM e também para fornecer paridade com o .NET Framework.This capability is critical to use .NET Core with COM add-in models and also to provide parity with .NET Framework.

Ao contrário do .NET Framework em que o mscoree. dll foi usado como o servidor COM, o .NET Core adicionará uma dll de inicializador nativa ao diretório bin quando você compilar o componente COM.Unlike .NET Framework where the mscoree.dll was used as the COM server, .NET Core will add a native launcher dll to the bin directory when you build your COM component.

Para obter um exemplo de como criar um componente COM e consumi-lo, veja a demonstração de COM.For an example of how to create a COM component and consume it, see the COM Demo.

Interoperabilidade nativa do WindowsWindows Native Interop

O Windows oferece uma API nativa rica na forma de APIs C simples, COM e WinRT.Windows offers a rich native API in the form of flat C APIs, COM, and WinRT. Embora o .NET Core dê suporte a P/Invoke, o .NET Core 3.0 adiciona a capacidade de criar conjuntamente APIs COM e ativar APIs WinRT.While .NET Core supports P/Invoke, .NET Core 3.0 adds the ability to CoCreate COM APIs and Activate WinRT APIs. Para obter um exemplo de código, consulte a demonstração do Excel.For a code example, see the Excel Demo.

Implantação do MSIXMSIX Deployment

MSIX é um novo formato de pacote de aplicativos do Windows.MSIX is a new Windows application package format. Ele pode ser usado para implantar aplicativos da área de trabalho do .NET Core 3.0 no Windows 10.It can be used to deploy .NET Core 3.0 desktop applications to Windows 10.

O Projeto de Empacotamento de Aplicativos do Windows, disponível no Visual Studio 2019, permite criar pacotes MSIX com aplicativos .NET Core autossuficientes.The Windows Application Packaging Project, available in Visual Studio 2019, allows you to create MSIX packages with self-contained .NET Core applications.

O arquivo de projeto do .NET Core precisa especificar os tempos de execução compatíveis na propriedade <RuntimeIdentifiers>:The .NET Core project file must specify the supported runtimes in the <RuntimeIdentifiers> property:

<RuntimeIdentifiers>win-x86;win-x64</RuntimeIdentifiers>

Aprimoramentos do LinuxLinux improvements

SerialPort para LinuxSerialPort for Linux

O .NET Core 3.0 fornece suporte básico para System.IO.Ports.SerialPort no Linux..NET Core 3.0 provides basic support for System.IO.Ports.SerialPort on Linux.

Anteriormente, o .NET Core só dava suporte ao uso de SerialPort no Windows.Previously, .NET Core only supported using SerialPort on Windows.

Para saber mais sobre o suporte limitado para a porta serial no Linux, confira o Problema do GitHub nº 33146.For more information about the limited support for the serial port on Linux, see GitHub issue #33146.

Limites de memória do Docker e cgroupDocker and cgroup memory Limits

A execução do .NET Core 3,0 no Linux com o Docker funciona melhor com limites de memória CGroup.Running .NET Core 3.0 on Linux with Docker works better with cgroup memory limits. Executar um contêiner do Docker com limites de memória, tais como docker run -m, altera o comportamento do .NET Core.Running a Docker container with memory limits, such as with docker run -m, changes how .NET Core behaves.

  • Tamanho de heap do GC (coletor de lixo) padrão: máximo de 20 MB ou 75% do limite de memória no contêiner.Default Garbage Collector (GC) heap size: maximum of 20 mb or 75% of the memory limit on the container.
  • O tamanho explícito pode ser definido como um número absoluto ou um percentual do limite de cgroup.Explicit size can be set as an absolute number or percentage of cgroup limit.
  • O tamanho mínimo do segmento reservado por heap de GC é de 16 MB.Minimum reserved segment size per GC heap is 16 mb. Esse tamanho reduz o número de heaps que são criados em computadores.This size reduces the number of heaps that are created on machines.

Suporte de GPIO para o Raspberry PiGPIO Support for Raspberry Pi

Foram lançados dois pacotes para o NuGet que você pode usar para programação de GPIO:Two packages have been released to NuGet that you can use for GPIO programming:

Os pacotes GPIO incluem as APIs para dispositivos GPIO, SPI, I2C e PWM.The GPIO packages include APIs for GPIO, SPI, I2C, and PWM devices. O pacote de associações de IoT inclui associações de dispositivo.The IoT bindings package includes device bindings. Para obter mais informações, veja o repositório GitHub de dispositivos.For more information, see the devices GitHub repo.

Suporte a ARM64 no LinuxARM64 Linux support

O .NET Core 3.0 adiciona suporte para ARM64 para Linux..NET Core 3.0 adds support for ARM64 for Linux. O principal caso de uso para ARM64 atualmente é em cenários de IoT.The primary use case for ARM64 is currently with IoT scenarios. Para obter mais informações, consulte Status do .NET Core ARM64.For more information, see .NET Core ARM64 Status.

Imagens do Docker para o .NET Core ARM64 estão disponíveis para Alpine, Debian e Ubuntu.Docker images for .NET Core on ARM64 are available for Alpine, Debian, and Ubuntu.

Observação

O suporte do Windows a ARM64 ainda não está disponível.ARM64 Windows support isn't yet available.

SegurançaSecurity

TLS 1.3 e OpenSSL 1.1.1 no LinuxTLS 1.3 & OpenSSL 1.1.1 on Linux

O .NET Core agora faz proveito do suporte a protocolo TLS 1.3 no OpenSSL 1.1.1 quando esse protocolo está disponível em um determinado ambiente..NET Core now takes advantage of TLS 1.3 support in OpenSSL 1.1.1, when it's available in a given environment. Com o TLS 1.3:With TLS 1.3:

  • Tempos de conexão são aprimorados com um menor número de viagens de ida e volta necessárias entre o cliente e o servidor.Connection times are improved with reduced round trips required between the client and server.
  • Segurança aprimorada devido à remoção de vários algoritmos criptográficos obsoletos e não seguros.Improved security because of the removal of various obsolete and insecure cryptographic algorithms.

Quando disponíveis, o .NET Core 3.0 usa OpenSSL 1.1.1, 1.1.0 ou 1.0.2 em um sistema Linux.When available, .NET Core 3.0 uses OpenSSL 1.1.1, OpenSSL 1.1.0, or OpenSSL 1.0.2 on a Linux system. Quando o OpenSSL 1.1.1 está disponível, ambos os tipos System.Net.Security.SslStream e System.Net.Http.HttpClient usarão o protocolo TLS 1.3 (supondo que o cliente e o servidor deem suporte ao protocolo TLS 1.3).When OpenSSL 1.1.1 is available, both System.Net.Security.SslStream and System.Net.Http.HttpClient types will use TLS 1.3 (assuming both the client and server support TLS 1.3).

Importante

Windows e macOS ainda não oferecem suporte a TLS 1.3.Windows and macOS do not yet support TLS 1.3. O .NET Core 3.0 será compatível com TLS 1.3 nesses sistemas operacionais quando o suporte for disponibilizado..NET Core 3.0 will support TLS 1.3 on these operating systems when support becomes available.

O exemplo de C# 8.0 a seguir demonstra o .NET Core 3.0 no Ubuntu 18.10 conectando-se a https://www.cloudflare.com:The following C# 8.0 example demonstrates .NET Core 3.0 on Ubuntu 18.10 connecting to https://www.cloudflare.com:

using System;
using System.Net.Security;
using System.Net.Sockets;
using System.Threading.Tasks;

namespace whats_new
{
    public static class TLS
    {
        public static async Task ConnectCloudFlare()
        {
            var targetHost = "www.cloudflare.com";

            using TcpClient tcpClient = new TcpClient();

            await tcpClient.ConnectAsync(targetHost, 443);

            using SslStream sslStream = new SslStream(tcpClient.GetStream());
            
            await sslStream.AuthenticateAsClientAsync(targetHost);
            await Console.Out.WriteLineAsync($"Connected to {targetHost} with {sslStream.SslProtocol}");
        }
    }
}

Cifras de criptografiaCryptography ciphers

O .NET 3.0 adiciona o suporte para as criptografias AES-GCM e AES-CCM, implementadas com System.Security.Cryptography.AesGcm e System.Security.Cryptography.AesCcm, respectivamente..NET 3.0 adds support for AES-GCM and AES-CCM ciphers, implemented with System.Security.Cryptography.AesGcm and System.Security.Cryptography.AesCcm respectively. Esses algoritmos são ambos do tipo AEAD (criptografia autenticada com os dados de associação).These algorithms are both Authenticated Encryption with Association Data (AEAD) algorithms.

O código a seguir demonstra como usar criptografia AesGcm para criptografar e descriptografar dados aleatórios.The following code demonstrates using AesGcm cipher to encrypt and decrypt random data.

using System;
using System.Linq;
using System.Security.Cryptography;

namespace whats_new
{
    public static class Cipher
    {
        public static void Run()
        {
            // key should be: pre-known, derived, or transported via another channel, such as RSA encryption
            byte[] key = new byte[16];
            RandomNumberGenerator.Fill(key);

            byte[] nonce = new byte[12];
            RandomNumberGenerator.Fill(nonce);

            // normally this would be your data
            byte[] dataToEncrypt = new byte[1234];
            byte[] associatedData = new byte[333];
            RandomNumberGenerator.Fill(dataToEncrypt);
            RandomNumberGenerator.Fill(associatedData);

            // these will be filled during the encryption
            byte[] tag = new byte[16];
            byte[] ciphertext = new byte[dataToEncrypt.Length];

            using (AesGcm aesGcm = new AesGcm(key))
            {
                aesGcm.Encrypt(nonce, dataToEncrypt, ciphertext, tag, associatedData);
            }

            // tag, nonce, ciphertext, associatedData should be sent to the other part

            byte[] decryptedData = new byte[ciphertext.Length];

            using (AesGcm aesGcm = new AesGcm(key))
            {
                aesGcm.Decrypt(nonce, ciphertext, tag, decryptedData, associatedData);
            }

            // do something with the data
            // this should always print that data is the same
            Console.WriteLine($"AES-GCM: Decrypted data is {(dataToEncrypt.SequenceEqual(decryptedData) ? "the same as" : "different than")} original data.");
        }
    }
}

Importar/exportar chave de criptografiaCryptographic Key Import/Export

O .NET Core 3.0 dá suporte à importação e exportação de chaves públicas e privadas assimétricas de formatos padrão..NET Core 3.0 supports the import and export of asymmetric public and private keys from standard formats. Você não precisa usar um certificado X.509.You don't need to use an X.509 certificate.

Todos os tipos principais, tais como RSA, DSA, ECDsa e ECDiffieHellman, dão suporte aos seguintes formatos:All key types, such as RSA, DSA, ECDsa, and ECDiffieHellman, support the following formats:

  • Chave públicaPublic Key

    • X.509 SubjectPublicKeyInfoX.509 SubjectPublicKeyInfo
  • Chave privadaPrivate key

    • PKCS nº 8 PrivateKeyInfoPKCS#8 PrivateKeyInfo
    • PKCS nº 8 EncryptedPrivateKeyInfoPKCS#8 EncryptedPrivateKeyInfo

Chaves RSA também dão suporte a:RSA keys also support:

  • Chave públicaPublic Key

    • PKCS nº 1 RSAPublicKeyPKCS#1 RSAPublicKey
  • Chave privadaPrivate key

    • PKCS nº 1 RSAPrivateKeyPKCS#1 RSAPrivateKey

Os métodos de exportação produzem dados binários codificados em DER e os métodos de importação esperam o mesmo.The export methods produce DER-encoded binary data, and the import methods expect the same. Se uma chave for armazenada no formato PEM compatível com texto, o chamador precisará decodificar o conteúdo em Base64 antes de chamar um método de importação.If a key is stored in the text-friendly PEM format, the caller will need to base64-decode the content before calling an import method.

using System;
using System.Security.Cryptography;

namespace whats_new
{
    public static class RSATest
    {
        public static void Run(string keyFile)
        {
            using var rsa = RSA.Create();

            byte[] keyBytes = System.IO.File.ReadAllBytes(keyFile);
            rsa.ImportRSAPrivateKey(keyBytes, out int bytesRead);

            Console.WriteLine($"Read {bytesRead} bytes, {keyBytes.Length - bytesRead} extra byte(s) in file.");
            RSAParameters rsaParameters = rsa.ExportParameters(true);
            Console.WriteLine(BitConverter.ToString(rsaParameters.D));
        }
    }
}

Arquivos PKCS nº 8 podem ser inspecionados com System.Security.Cryptography.Pkcs.Pkcs8PrivateKeyInfo e arquivos PFX/PKCS nº 12 podem ser inspecionados com System.Security.Cryptography.Pkcs.Pkcs12Info.PKCS#8 files can be inspected with System.Security.Cryptography.Pkcs.Pkcs8PrivateKeyInfo and PFX/PKCS#12 files can be inspected with System.Security.Cryptography.Pkcs.Pkcs12Info. Arquivos PFX/PKCS nº 12 podem ser manipulados com System.Security.Cryptography.Pkcs.Pkcs12Builder.PFX/PKCS#12 files can be manipulated with System.Security.Cryptography.Pkcs.Pkcs12Builder.

Alterações da API do .NET Core 3,0.NET Core 3.0 API changes

Intervalos e índicesRanges and indices

O novo tipo System.Index pode ser usado para indexação.The new System.Index type can be used for indexing. É possível criar um a partir de um int que conta desde o início, ou com um operador ^ de prefixo (C#) que conta do final:You can create one from an int that counts from the beginning, or with a prefix ^ operator (C#) that counts from the end:

Index i1 = 3;  // number 3 from beginning
Index i2 = ^4; // number 4 from end
int[] a = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
Console.WriteLine($"{a[i1]}, {a[i2]}"); // "3, 6"

Há também o tipo System.Range, que consiste em dois valores Index (um para o início e outro para o final) e pode ser escrito com uma expressão de intervalo x..y (C#).There's also the System.Range type, which consists of two Index values, one for the start and one for the end, and can be written with a x..y range expression (C#). Em seguida, você pode indexar com um Range, o que produz uma fatia:You can then index with a Range, which produces a slice:

var slice = a[i1..i2]; // { 3, 4, 5 }

Para obter mais informações, consulte o tutorial de intervalos e índices.For more information, see the ranges and indices tutorial.

Fluxos assíncronosAsync streams

O tipo IAsyncEnumerable<T> é uma nova versão assíncrona de IEnumerable<T>.The IAsyncEnumerable<T> type is a new asynchronous version of IEnumerable<T>. A linguagem permite o uso de await foreach em IAsyncEnumerable<T> para consumir seus elementos e o uso de yield return neles para produzir elementos.The language lets you await foreach over IAsyncEnumerable<T> to consume their elements, and use yield return to them to produce elements.

O exemplo a seguir demonstra a produção e o consumo de fluxos assíncronos.The following example demonstrates both production and consumption of async streams. A instrução foreach é assíncrona e usa yield return para produzir um fluxo assíncrono para chamadores.The foreach statement is async and itself uses yield return to produce an async stream for callers. Esse padrão (usar yield return) é o modelo recomendado para a produção de fluxos assíncronos.This pattern (using yield return) is the recommended model for producing async streams.

async IAsyncEnumerable<int> GetBigResultsAsync()
{
    await foreach (var result in GetResultsAsync())
    {
        if (result > 20) yield return result;
    }
}

Além de poder await foreach, você também pode criar iteradores assíncronos, por exemplo, um iterador que retorne um IAsyncEnumerable/IAsyncEnumerator em que é possível aplicar await e yield.In addition to being able to await foreach, you can also create async iterators, for example, an iterator that returns an IAsyncEnumerable/IAsyncEnumerator that you can both await and yield in. Para objetos que precisam ser descartados, você pode usar IAsyncDisposable, que vários tipos BCL implementam, como Stream e Timer.For objects that need to be disposed, you can use IAsyncDisposable, which various BCL types implement, such as Stream and Timer.

Para obter mais informações, consulte o tutorial de fluxos assíncronos.For more information, see the async streams tutorial.

Ponto flutuante de IEEEIEEE Floating-point

APIs de ponto flutuante estão sendo atualizadas para entrar em conformidade com a revisão IEEE 754-2008.Floating point APIs are being updated to comply with IEEE 754-2008 revision. O objetivo dessas alterações é expor todas as operações necessárias e garantir que elas sejam compatíveis de forma comportamental com a especificação IEEE. Para obter mais informações sobre melhorias de ponto flutuante, consulte a postagem de ponto flutuante e aprimoramentos de formatação no blog do .NET Core 3,0 .The goal of these changes is to expose all required operations and ensure that they're behaviorally compliant with the IEEE spec. For more information about floating-point improvements, see the Floating-Point Parsing and Formatting improvements in .NET Core 3.0 blog post.

As correções de análise e formatação incluem:Parsing and formatting fixes include:

  • Analisar e arredondar corretamente entradas de qualquer tamanho.Correctly parse and round inputs of any length.
  • Analisar e formatar corretamente o zero negativo.Correctly parse and format negative zero.
  • Analisar corretamente Infinity e NaN, fazendo uma verificação sem diferenciação de maiúsculas e minúsculas e permitindo um + precedente opcional onde aplicável.Correctly parse Infinity and NaN by doing a case-insensitive check and allowing an optional preceding + where applicable.

Novas APIs System.Math incluem:New System.Math APIs include:

  • BitIncrement(Double) e BitDecrement(Double)BitIncrement(Double) and BitDecrement(Double)
    Correspondem às operações nextUp e nextDown do IEEE.Corresponds to the nextUp and nextDown IEEE operations. Retornam o menor número de ponto flutuante que compara o valor maior ou menor que a entrada (respectivamente).They return the smallest floating-point number that compares greater or lesser than the input (respectively). Por exemplo, Math.BitIncrement(0.0) retorna double.Epsilon.For example, Math.BitIncrement(0.0) would return double.Epsilon.

  • MaxMagnitude(Double, Double) e MinMagnitude(Double, Double)MaxMagnitude(Double, Double) and MinMagnitude(Double, Double)
    Correspondem às operações maxNumMag e minNumMag do IEEE; retornam o valor maior ou menor em magnitude das duas entradas (respectivamente).Corresponds to the maxNumMag and minNumMag IEEE operations, they return the value that is greater or lesser in magnitude of the two inputs (respectively). Por exemplo, Math.MaxMagnitude(2.0, -3.0) retorna -3.0.For example, Math.MaxMagnitude(2.0, -3.0) would return -3.0.

  • ILogB(Double)
    Corresponde à operação logB IEEE que retorna um valor integral, ele retorna o log de base 2 integral do parâmetro de entrada.Corresponds to the logB IEEE operation that returns an integral value, it returns the integral base-2 log of the input parameter. Esse método é praticamente o mesmo que floor(log2(x)), mas feito com o mínimo de erro de arredondamento.This method is effectively the same as floor(log2(x)), but done with minimal rounding error.

  • ScaleB(Double, Int32)
    Corresponde à operação IEEE scaleB que usa um valor integral, ele retorna efetivamente x * pow(2, n), mas é feito com o mínimo de erro de arredondamento.Corresponds to the scaleB IEEE operation that takes an integral value, it returns effectively x * pow(2, n), but is done with minimal rounding error.

  • Log2(Double)
    Corresponde à operação log2 do IEEE; retorna o logaritmo de base 2.Corresponds to the log2 IEEE operation, it returns the base-2 logarithm. Minimiza o erro de arredondamento.It minimizes rounding error.

  • FusedMultiplyAdd(Double, Double, Double)
    Corresponde à operação fma do IEEE; executa uma adição e multiplicação fundida.Corresponds to the fma IEEE operation, it performs a fused multiply add. Em outras palavras, realiza (x * y) + z como uma única operação, minimizando o erro de arredondamento.That is, it does (x * y) + z as a single operation, thereby minimizing the rounding error. Um exemplo é FusedMultiplyAdd(1e308, 2.0, -1e308), que retorna 1e308.An example would be FusedMultiplyAdd(1e308, 2.0, -1e308) which returns 1e308. O (1e308 * 2.0) - 1e308 regular retorna double.PositiveInfinity.The regular (1e308 * 2.0) - 1e308 returns double.PositiveInfinity.

  • CopySign(Double, Double)
    Corresponde à operação copySign do IEEE; retorna o valor de x, mas com o sinal de y.Corresponds to the copySign IEEE operation, it returns the value of x, but with the sign of y.

Intrínsecos dependentes da plataforma .NET.NET Platform-Dependent Intrinsics

Foram adicionadas APIs que permitem acesso a determinadas instruções da CPU orientadas a desempenho, como o SIMD ou conjuntos de instruções de manipulação de bits.APIs have been added that allow access to certain perf-oriented CPU instructions, such as the SIMD or Bit Manipulation instruction sets. Essas instruções podem ajudar a obter melhorias significativas de desempenho em determinados cenários, tais como processamento de dados eficiente em paralelo.These instructions can help achieve significant performance improvements in certain scenarios, such as processing data efficiently in parallel.

Quando apropriado, as bibliotecas .NET começaram usando estas instruções para melhorar o desempenho.Where appropriate, the .NET libraries have begun using these instructions to improve performance.

Para obter mais informações, consulte Intrínsecos dependentes da plataforma .NET.For more information, see .NET Platform Dependent Intrinsics.

APIs de versão aprimoradas do .NET CoreImproved .NET Core Version APIs

Começando com o .NET Core 3.0, as APIs de versão fornecidas com o .NET Core agora retornam as informações que você espera.Starting with .NET Core 3.0, the version APIs provided with .NET Core now return the information you expect. Por exemplo:For example:

System.Console.WriteLine($"Environment.Version: {System.Environment.Version}");

// Old result
//   Environment.Version: 4.0.30319.42000
//
// New result
//   Environment.Version: 3.0.0
System.Console.WriteLine($"RuntimeInformation.FrameworkDescription: {System.Runtime.InteropServices.RuntimeInformation.FrameworkDescription}");

// Old result
//   RuntimeInformation.FrameworkDescription: .NET Core 4.6.27415.71
//
// New result (notice the value includes any preview release information)
//   RuntimeInformation.FrameworkDescription: .NET Core 3.0.0-preview4-27615-11

Aviso

Alteração da falha.Breaking change. Isso é tecnicamente uma alteração da falha, porque o esquema de controle de versão foi alterado.This is technically a breaking change because the versioning scheme has changed.

Suporte interno rápido a JSONFast built-in JSON support

Usuários do .NET têm dependido basicamente de Json.NET e outras bibliotecas JSON populares, que continuam a ser boas opções..NET users have largely relied on Json.NET and other popular JSON libraries, which continue to be good choices. O Json.NET usa cadeias de caracteres do .NET como seu tipo de dados base, o qual subjacentemente é UTF-16.Json.NET uses .NET strings as its base datatype, which is UTF-16 under the hood.

O novo suporte interno ao JSON é de alto desempenho, baixa alocação e baseado em Span<byte>.The new built-in JSON support is high-performance, low allocation, and based on Span<byte>. Para obter mais informações sobre o namespace e tipos de System.Text.Json, consulte serialização JSON em .net-visão geral.For more information about the System.Text.Json namespace and types, see JSON serialization in .NET - overview. Para obter tutoriais sobre cenários comuns de serialização JSON, consulte como serializar e desserializar JSON no .net.For tutorials on common JSON serialization scenarios, see How to serialize and deserialize JSON in .NET.

Compatibilidade com HTTP/2HTTP/2 support

O tipo System.Net.Http.HttpClient dá suporte ao protocolo HTTP/2.The System.Net.Http.HttpClient type supports the HTTP/2 protocol. Se o HTTP/2 estiver habilitado, a versão do protocolo HTTP é negociada via TLS/ALPN, e o HTTP/2 é usado apenas se o servidor selecionar seu uso.If HTTP/2 is enabled, the HTTP protocol version is negotiated via TLS/ALPN, and HTTP/2 is used if the server elects to use it.

O protocolo padrão permanece HTTP/1.1, mas o HTTP/2 pode ser ativado de duas maneiras diferentes.The default protocol remains HTTP/1.1, but HTTP/2 can be enabled in two different ways. Primeiro, você pode definir a mensagem de solicitação HTTP para usar HTTP/2:First, you can set the HTTP request message to use HTTP/2:

var client = new HttpClient() { BaseAddress = new Uri("https://localhost:5001") };

// HTTP/1.1 request
using (var response = await client.GetAsync("/"))
    Console.WriteLine(response.Content);

// HTTP/2 request
using (var request = new HttpRequestMessage(HttpMethod.Get, "/") { Version = new Version(2, 0) })
using (var response = await client.SendAsync(request))
    Console.WriteLine(response.Content);

Segundo, você pode alterar HttpClient para usar HTTP/2 por padrão:Second, you can change HttpClient to use HTTP/2 by default:

var client = new HttpClient()
{
    BaseAddress = new Uri("https://localhost:5001"),
    DefaultRequestVersion = new Version(2, 0)
};

// HTTP/2 is default
using (var response = await client.GetAsync("/"))
    Console.WriteLine(response.Content);

Muitas vezes, quando você está desenvolvendo um aplicativo, quer usar uma conexão não criptografada.Many times when you're developing an application, you want to use an unencrypted connection. Se você souber que o ponto de extremidade estará usando HTTP/2, poderá ativar conexões não criptografadas para HTTP/2.If you know the target endpoint will be using HTTP/2, you can turn on unencrypted connections for HTTP/2. Você pode ativá-lo definindo a variável de ambiente DOTNET_SYSTEM_NET_HTTP_SOCKETSHTTPHANDLER_HTTP2UNENCRYPTEDSUPPORT como 1 ou ativando-a no contexto do aplicativo:You can turn it on by setting the DOTNET_SYSTEM_NET_HTTP_SOCKETSHTTPHANDLER_HTTP2UNENCRYPTEDSUPPORT environment variable to 1 or by enabling it in the app context:

AppContext.SetSwitch("System.Net.Http.SocketsHttpHandler.Http2UnencryptedSupport", true);

Próximas etapasNext steps