Anunciando o .NET 5.0/Release

Estamos ansiosos para lançar o .NET 5.0 hoje e para você começar a usá-lo. É um lançamento importante — incluindo C# 9 e F# 5 — com um amplo conjunto de novos recursos e melhorias atraentes. Já está em uso ativo por equipes da Microsoft e outras empresas, em produção e para testes de desempenho. Essas equipes estão nos mostrando ótimos resultados que demonstram ganhos de desempenho e/ou oportunidades de redução de custos de hospedagem para suas aplicações web. Temos executado nosso próprio site no 5.0 desde o Preview 1. Pelo que vimos e ouvimos até agora, o .NET 5.0 oferece um valor significativo sem muito esforço para atualizar. É uma ótima opção para seu próximo aplicativo e uma atualização direta de versões anteriores do .NET Core. Esperamos que você goste de usá-lo em seu desktop, laptop e instâncias de nuvem.

Estamos empolgados em lançar o .NET 5.0 hoje para que você possa começar a usá-lo. Esta é uma versão importante, incluindo C#9 e F#5, com uma série de novos recursos e melhorias drásticas. As equipes da Microsoft e de outras empresas já o estão usando ativamente em testes de produção e desempenho. Ou mostre-nos uma grande oportunidade de reduzir custos e resultados de hospedagem na web. Temos executado nosso próprio site no 5.0 desde a visualização 1. Pelo que vimos até agora, o .NET 5.0 oferece um valor significativo sem muitos upgrades. É uma ótima opção para seu próximo aplicativo e uma atualização direta de versões anteriores do .NET Core. Esperamos que você goste de usá-lo em seus desktops, laptops e instâncias de nuvem.

ASP.NET Core, EF Core, C# 9 e F# 5 também estão sendo lançados hoje. .NET Conf 2020 — nossa conferência gratuita e virtual — está sendo realizada hoje para que você possa conhecer todos os novos lançamentos.

Você pode baixar .NET 5.0, para Windows, macOS e Linux, para x86, x64, Arm32, Arm64.

ASP.NET Core, EF Core, C#9 e F#5 também serão lançados hoje. Nossa reunião virtual é gratuita hoje e você pode aprender sobre todas as nossas sessões.

Você pode baixar .NET5.0 para Windows, macOS e Linux, para x86, x64, Arm32, Arm64.

Instaladores e binários

Imagens de contêiner

pacotes Linux

Notas de lançamento

Problemas conhecidos

Rastreador de problemas do GitHub

Colaboradores do .NET 5.0

Para usuários do Visual Studio, você precisa do Visual Studio 16.8 ou posterior para usar o .NET 5.0 no Windows e a versão mais recente do Visual Studio para Mac) no macOS. A extensão C# para Visual Studio Code já suporta .NET 5.0 e C# 9.

Para usuários do Visual Studio, o Visual Studio 16.8 ou superior é necessário para usar o .NET 5.0 no Windows e a versão mais recente do Visual Studio para Mac no Mac OS). A extensão C para Visual Studio Code já suporta .NET 5.0 e C#9.

O .NET 5.0 é o primeiro lançamento em nossa jornada de unificação do .NET. Criamos o .NET 5.0 para permitir que um grupo muito maior de desenvolvedores migre seus códigos e aplicativos do .NET Framework para o .NET 5.0. Também fizemos grande parte do trabalho inicial no 5.0 para que os desenvolvedores do Xamarin possam usar a plataforma .NET unificada quando lançarmos o .NET 6.0. Há mais sobre a unificação do .NET mais adiante neste post.

O .NET 5.0 é o primeiro lançamento em nossa jornada de unificação do .NET. Criamos o .NET 5.0 para permitir que mais desenvolvedores migrem seus códigos e aplicativos do .NET Framework para o .NET 5.0. Também fizemos muito trabalho prévio no 5.0 para que os desenvolvedores do Xamarin possam usar uma plataforma .NET unificada quando o .NET 6.0 for lançado. Mais sobre a unidade .NET em um post posterior.

Agora é um bom momento para destacar a incrível colaboração de todos que contribuem para o projeto .NET. Esta versão marca a quinta versão principal do .NET como um projeto de código aberto. Existe agora uma grande mistura de indivíduos e pequenas e grandes empresas (incluindo os patrocinadores corporativos da .NET Foundation) trabalhando juntos como uma grande comunidade em vários aspectos do .NET na dotnet org no GitHub. As melhorias no .NET 5.0 são o resultado de muitas pessoas, seus esforços, ideias inteligentes e seu cuidado e amor pela plataforma, tudo acima e além da administração do projeto pela Microsoft. Da equipe principal que trabalha no .NET todos os dias, estendemos um grande “obrigado” a todos que contribuíram para o .NET 5.0 (e versões anteriores)!

Agora é um ótimo momento para colaborações incríveis com todos aqueles que contribuem para projetos .NET. Esta versão marca a quinta versão principal do .NET como um projeto de código aberto. Agora, em dotnetorg no GitHub, indivíduos e empresas grandes e pequenas (incluindo patrocinadores corporativos .netfoundation) colaboram como uma grande comunidade em todos os aspectos do .NET. NET 5.0 são o resultado do trabalho árduo, ideias inteligentes e cuidado e amor pela plataforma de muitas pessoas, que foram além do gerenciamento do projeto pela Microsoft. Da equipe principal que trabalha no .NET todos os dias, enviamos um grande "obrigado" a todos que contribuíram para o .NET 5.0 (e versões anteriores)!

Introduzimos o .NET 5.0 em maio de 2019 e até definimos a data de lançamento para novembro de 2020 na época. Dessa postagem: “iremos lançar o .NET Core 3.0 em setembro, o .NET 5 em novembro de 2020 e, em seguida, pretendemos lançar uma versão principal do .NET uma vez por ano, todo mês de novembro”. Você pensaria que “novembro de 2020” era um cheque que não poderia ser descontado devido a todos os desafios deste ano, no entanto, o .NET 5.0 foi lançado a tempo. Obrigado a todos da equipe que fizeram isso acontecer! Eu sei que não tem sido fácil. Olhando para o futuro, você deve esperar o .NET 6.0 em novembro de 2021. Pretendemos lançar novas versões do .NET todo mês de novembro.

Agora é um ótimo momento para colaborações incríveis com todos aqueles que contribuem para projetos .NET. Esta versão marca a quinta versão principal do .NET como um projeto de código aberto. Agora, em dotnetorg no GitHub, indivíduos e empresas grandes e pequenas (incluindo patrocinadores corporativos .netfoundation) colaboram como uma grande comunidade em todos os aspectos do .NET. NET 5.0 são o resultado do trabalho árduo, ideias inteligentes e cuidado e amor pela plataforma de muitas pessoas, que foram além do gerenciamento do projeto pela Microsoft. Da equipe principal que trabalha no .NET todos os dias, enviamos um grande "obrigado" a todos que contribuíram para o .NET 5.0 (e versões anteriores)!

O restante do blog é dedicado a destacar e detalhar a maioria das melhorias no .NET 5.0. Há também uma atualização em nossa visão de unificação .NET.

O restante do blog é dedicado a destacar e detalhar a maioria das melhorias no .NET 5.0. Há também uma atualização para nossa visão de unificação .NET.

.NET 5.0 Highlights/.NET 5.0亮点
Há muitas melhorias importantes no .NET 5.0:

Há muitas melhorias importantes no .NET 5.0:

O .NET 5.0 já foi testado em batalha por estar hospedado por meses em dot.net e Bing.com (versão).

O desempenho é bastante aprimorado em muitos componentes e é descrito em detalhes em Melhorias de desempenho no .NET 5.0, Desempenho Arm64 no .NET 5.0 e gRPC.

C# 9 e F# 5 oferecem novas melhorias de linguagem, como programas de nível superior e registros para C# 9, enquanto F# 5 oferece programação interativa e um aumento de desempenho para programação funcional em .NET.

As bibliotecas .NET têm desempenho aprimorado para serialização Json, expressões regulares e HTTP (HTTP 1.1, HTTP/2). Eles também são agora completamente anotados para nulidade.

A latência do P95 caiu devido a refinamentos no GC, compilação em camadas e outras áreas.

As opções de implantação de aplicativos são melhores, com publicação de aplicativo cliente ClickOnce, aplicativos de arquivo único, tamanho de imagem de contêiner reduzido e a adição de imagens de contêiner Server Core.

Escopo da plataforma expandido com Windows Arm64 e WebAssembly.

O .NET 5.0 tem sido o ponto de teste de batalha .net, bem como o Bing (versões) por vários meses.

O desempenho de muitos componentes foi bastante aprimorado e é descrito em detalhes em Melhorias de desempenho no .NET 5.0, Desempenho Arm64 no .NET 5.0 e gRPC.

C#9 e F#5 oferecem novas melhorias de linguagem, como procedimentos e registros de nível superior do C#9, enquanto F#5 oferece melhorias de desempenho para programação interativa e programação funcional .NET.

A biblioteca .NET melhora o desempenho da serialização Json, expressões regulares e HTTP (HTTP 1.1, HTTP/2). Eles também estão agora totalmente anotados como vazios.

A latência do P95 caiu devido ao GC, compilação em camadas e outras melhorias.

Melhores opções de implantação de aplicativos, publicação de aplicativos cliente ClickOnce, aplicativos de arquivo único, redução do tamanho da imagem do contêiner e adição de imagens de contêiner Server Core.

Faixa de plataforma expandida com Windows Arm64 e WebAssembly.

Escrevi muitos exemplos para as postagens de visualização do .NET 5.0. Talvez você queira dar uma olhada nos exemplos do .NET 5.0 para saber mais sobre o novo C# 9 e os recursos de bibliotecas.

Escrevi muitos exemplos para o artigo de visualização do .NET 5.0. Talvez você queira dar uma olhada nos exemplos do .NET 5.0 para saber mais sobre o novo C# 9 e os recursos de biblioteca.

Suporte de plataforma e Microsoft/
Microsoft.NET 5.0 tem uma matriz de suporte de plataforma quase idêntica à do .NET Core 3.1, para Windows, macOS e Linux. Se você estiver usando o .NET Core 3.1 em um sistema operacional com suporte, poderá adotar o .NET 5.0 na mesma versão do sistema operacional em sua maior parte. A adição mais significativa para .NET 5.0 é o Windows Arm64.

O .NET 5.0 tem quase a mesma matriz de suporte de plataforma que o .NET Core 3.1 (para Windows, macOS e Linux). Se você estiver usando o .NET Core 3.1 em um sistema operacional compatível, na maioria dos casos poderá adotar o .NET 5.0 na mesma versão do sistema operacional. Para ARMNET, 64.0.0 é a adição mais importante.

.NET 5.0 é uma versão atual. Isso significa que ele terá suporte por três meses após o lançamento do .NET 6.0. Como resultado, esperamos dar suporte ao .NET 5.0 até meados de fevereiro de 2022. O .NET 6.0 será uma versão LTS e terá suporte por três anos, assim como o .NET Core 3.1.

.NET5.0 é a versão atual. Isso significa que ele terá suporte por três meses após o lançamento do .NET 6.0. Portanto, esperamos dar suporte ao .NET 5.0 em meados de fevereiro de 2022. NET 6.0 será uma versão LTS com suporte por três anos, assim como o .NET Core 3.1.

Visão de plataforma unificada/统一平台愿景
No ano passado, compartilhamos uma visão de uma pilha e ecossistema .NET unificados. O valor para você é que você poderá usar um único conjunto de APIs, linguagens e ferramentas para atingir um amplo conjunto de tipos de aplicativos, incluindo dispositivos móveis, nuvem, desktop e IoT. Você pode perceber que já pode atingir um amplo conjunto de plataformas com .NET hoje, no entanto, as ferramentas e APIs nem sempre são as mesmas na Web e no celular, por exemplo, ou lançadas ao mesmo tempo.

No ano passado, compartilhamos nossa visão para uma pilha e um ecossistema .NET unificados. O valor para você é que você poderá usar um conjunto de APIs, linguagens e ferramentas para atingir uma ampla variedade de tipos de aplicativos, incluindo dispositivos móveis, nuvem, desktop e IoT. Você provavelmente está ciente de que agora é possível atingir uma ampla variedade de plataformas com .NET, mas, por exemplo, as ferramentas e APIs na Web e em dispositivos móveis nem sempre são as mesmas ou lançadas ao mesmo tempo.

Como parte do .NET 5.0 e 6.0, estamos unificando o .NET em uma única experiência de produto, permitindo que você escolha apenas as partes da plataforma .NET que deseja usar. Se você deseja direcionar Mobile e não WebAssembly, não precisa baixar as ferramentas WebAssembly e vice-versa. O mesmo com ASP.NET Core e WPF. Você também terá uma maneira muito mais fácil de adquirir todas as ferramentas .NET e pacotes de compilação e tempo de execução necessários na linha de comando. Estamos habilitando uma experiência de gerenciador de pacotes (incluindo o uso de gerenciadores de pacotes existentes) para componentes da plataforma .NET. Isso será ótimo para muitos cenários. A construção rápida de um ambiente de desenvolvimento e CI/CD provavelmente serão os maiores beneficiários.

Como parte do .NET 5.0 e 6.0, estamos unificando o .NET em uma única experiência de produto, permitindo que você escolha quais partes da plataforma .NET deseja usar. Você não precisa baixar as ferramentas do WebAssembly se quiser segmentar dispositivos móveis em vez do WebAssembly ou vice-versa. O mesmo que ASP.NET Core e WPF. Você também pode obter mais facilmente todas as ferramentas .NET, buildpacks e pacotes de tempo de execução necessários na linha de comando. Estamos habilitando a experiência do gerenciador de pacotes (incluindo o uso de gerenciadores de pacotes existentes) para componentes da plataforma .NET. Isso é bom para muitos cenários. Ambientes de desenvolvimento de construção rápida e CI/CD provavelmente serão os maiores beneficiários.

Tínhamos a intenção de entregar a totalidade da visão de unificação com o .NET 5.0, mas após a pandemia global, tivemos que nos adaptar às mudanças nas necessidades de nossos clientes. Temos trabalhado com equipes de empresas de todo o mundo que precisam de ajuda para acelerar a adoção de tecnologias de nuvem. Eles também tiveram que se adaptar às novas necessidades de seus clientes. Como resultado, estamos entregando a visão em dois lançamentos.

Originalmente pretendíamos usar o .NET 5.0 para alcançar a visão unificada, mas após a pandemia global, tivemos que nos adaptar às mudanças nas necessidades de nossos clientes. Temos trabalhado com equipes de empresas de todo o mundo que precisam de ajuda para acelerar a adoção da nuvem. Eles também se adaptaram às novas necessidades de seus clientes. Então, vamos implementar essa visão em dois lançamentos.

O primeiro passo para essa visão foi consolidar os repositórios .NET, incluindo um grande subconjunto do Mono. Ter um repositório para o tempo de execução e bibliotecas para .NET é uma pré-condição para entregar o mesmo produto em qualquer lugar. Também ajuda a fazer alterações amplas que afetam o tempo de execução e as bibliotecas, onde antes havia limites de repo. Algumas pessoas temiam que uma grande recompra fosse mais difícil de gerenciar. Isso não provou ser o caso.

O primeiro passo para concretizar essa visão é integrar o repositório .NET, incluindo grande parte do Mono. Fornecer um repositório e uma biblioteca .NET para o tempo de execução é um pré-requisito para entregar o mesmo produto em qualquer lugar. Também é útil para fazer alterações extensas no tempo de execução e na biblioteca que existiam anteriormente nos limites do repo. Alguns temem que grandes recompras sejam mais difíceis de gerenciar. mas não é a verdade.

Na versão .NET 5.0, o Blazor é o melhor exemplo de aproveitamento da consolidação de repo e unificação do .NET. O runtime e as bibliotecas do Blazor WebAssembly agora são criados a partir do repositório dotnet/runtime consolidado. Isso significa que Blazor WebAssembly e Blazor no servidor usam exatamente o mesmo código para List, por exemplo. Esse não era o caso do Blazor antes do .NET 5.0. A abordagem que adotamos para o Blazor WebAssembly é muito semelhante ao que faremos com o Xamarin no .NET 6.0.

Na versão .NET 5.0, o Blazor é o melhor exemplo de utilização da fusão de repo e da unidade .NET. O tempo de execução e as bibliotecas do Blazor WebAssembly agora são criados a partir do repositório dotnet/runtime mesclado. Isso significa que Blazor WebAssembly no servidor e Blazor usam exatamente o mesmo código para List. Esse não era o caso do Blazor antes do .NET 5.0. A abordagem que estamos adotando com o Blazor Web Assembly é muito semelhante à que fizemos com o Xamarin no .NET 6.0.

O .NET Framework continua sendo um produto compatível da Microsoft e continuará a ser compatível com cada nova versão do Windows. Anunciamos no ano passado que paramos de adicionar novos recursos ao .NET

O .NET Framework continua sendo um produto compatível da Microsoft e continuará a ser compatível com cada nova versão do Windows. Anunciamos no ano passado que pararíamos de adicionar novos recursos ao .NET

Framework e terminei de adicionar APIs do .NET Framework ao .NET Core. Isso significa que agora é um ótimo momento para considerar mover seus aplicativos .NET Framework para .NET Core. Para desenvolvedores de cliente .NET Framework, Windows Forms e WPF são suportados com .NET 5.0. Ouvimos de muitos desenvolvedores que a portabilidade do .NET Framework é simples. Para desenvolvedores de servidores .NET Framework, você precisa adotar o ASP.NET Core para usar o .NET 5.0. Para desenvolvedores de Web Forms, acreditamos que o Blazor fornece uma experiência de desenvolvedor semelhante com uma implementação eficiente e muito mais moderna. Os usuários do servidor WCF e do fluxo de trabalho podem procurar projetos da comunidade que oferecem suporte a essas estruturas. A portabilidade do documento .NET Framework para .NET Core é um bom ponto de partida. Dito isso, manter seu aplicativo no .NET Framework é uma boa abordagem se você estiver satisfeito com sua experiência.

Concluída a adição da API do .NET Framework ao .NET Core. Isso significa que agora é um bom momento para considerar a migração de aplicativos .NET Framework para .NET Core. Para desenvolvedores de cliente .NET Framework, .NET5.0 oferece suporte a Windows Forms e WPF. Ouvimos de muitos desenvolvedores que a portabilidade do .NET Framework é fácil. Para desenvolvedores de servidores .NET Framework, você precisa adotar o ASP.NET para usar o núcleo do .NET5.0. Para desenvolvedores de formulários da Web, acreditamos que o Blazor oferece uma experiência de desenvolvedor semelhante, com uma implementação eficiente e mais moderna. Os usuários do Wcfserver e do fluxo de trabalho podem verificar os projetos da comunidade que oferecem suporte a essas estruturas. A portabilidade da documentação do .NET Framework para o .NET Core é um bom começo. Concluindo, se você está satisfeito com sua experiência, manter seu aplicativo no .NETFramework é uma boa opção.

A equipe do Windows está trabalhando no Project Reunion como o próximo passo para UWP e tecnologias relacionadas. Temos colaborado com a equipe Reunion para garantir que o .NET 5.0 e versões posteriores funcionem bem com WinUI e WebView2. O repositório Project Reunion é o melhor lugar para se manter atualizado com o progresso.

A equipe do Windows está trabalhando no projeto Reunion como a próxima etapa para UWP e tecnologias relacionadas. Temos trabalhado com a equipe Reunion para garantir que o .NET 5.0 e superior funcionem com WinUI e WebView2. O repositório de reunião do projeto é o melhor lugar para se manter atualizado com o progresso.

Vamos ver o que há de novo na versão 5.0.

Vejamos a nova versão 5.0.

Languages/语言文字
C# 9 e F# 5 fazem parte da versão .NET 5.0 e estão incluídos no .NET 5.0 SDK. O Visual Basic também está incluído no SDK 5.0. Ele não inclui alterações de idioma, mas possui melhorias para dar suporte ao Visual Basic Application Framework no .NET Core.

C#9 e F#5 fazem parte da versão .NET5.0 e estão incluídos no .NET5.0SDK. O Visual Basic também está incluído no SDK 5.0. Ele não inclui alterações de idioma, mas há algumas melhorias para dar suporte ao VisualBasic Application Framework no .NETCore.

C# Source Generators são um novo recurso importante do compilador C#. Eles não são tecnicamente parte do C# 9, pois não possui nenhuma sintaxe de linguagem. Consulte Novos exemplos de gerador de código-fonte C# para ajudá-lo a começar a usar esse novo recurso. Esperamos fazer mais uso de geradores de origem no produto .NET no .NET 6.0 e posteriores.

O gerador de código-fonte C é um novo recurso importante do compilador C. Tecnicamente, eles não fazem parte do C#9, pois não possui nenhuma sintaxe de linguagem. Consulte o novo exemplo de gerador de código-fonte C para ajudá-lo a começar a usar esse novo recurso. Queremos ver mais uso de geradores de origem em produtos .NET no .NET 6.0 e superior.

Como forma de experimentar a nova versão, alguns de nós decidimos atualizar o repositório dotnet/iot para usar a nova sintaxe do C# 9 e o .NET 5.0 de destino. As alterações resultaram na remoção de mais de 2.000 linhas de código, apenas adotando a nova sintaxe. Ele usa programas de nível superior, registros, padrões e expressões de comutação. Ele também foi atualizado para aproveitar o conjunto completo de anotações anuláveis ​​em bibliotecas .NET. Também atualizamos os documentos do .NET IoT. Vamos dar uma olhada em alguns exemplos desse repositório para explorar o C# 9.

Como forma de experimentar a nova versão, alguns de nós decidiram atualizar o repositório dotnet/iot para usar a nova sintaxe C#9 e o destino .net5.0. Essas alterações removem mais de 2 mil linhas de código simplesmente adotando a nova sintaxe. Ele usa expressões de programa, registro, padrão e troca de nível superior. Ele também foi atualizado para aproveitar o conjunto completo de anotações anuláveis ​​na biblioteca .NET. Também atualizamos a documentação do .NET IoT. Exploraremos o C#9 observando alguns exemplos deste repositório.

Programas de nível superior/Apresentação
O programa led-blink é um bom exemplo de programa compacto de nível superior.

O programa led blink é um bom exemplo de um programa compacto de alto nível.

using System; using System.Device.Gpio; using System. Threading; var pin = 18; var lightTime = 1000; var dimTime = 200 $"Deixe\_{\_}^{\prime }sblinkanLED!");usingoGpioControlercontroler\_\_\_\_\_=novo();\_\_controler.\_\_\_\_\_\_AbrePino(pino,\_\_\_\_\_\_\_ModoPino.\_\_\_\_\_Saída);\_\_\_\_\_Console.\_WriteLine($ “Pino GPIO habilitado para uso: {pin}”);// liga e desliga o LED while (true){ Console.WriteLine($“Luz por {lightTime}ms”); controller.Write(pin, PinValue.High); Thread.Sleep(lightTime);

Console.WriteLine($"Dim for {dimTime}ms");
controller.Write(pin, PinValue.Low);
Thread.Sleep(dimTime);}

Você também pode ver o uso de new com tipo de destino, com a atribuição à variável do controlador. O tipo GpioController é definido apenas no lado esquerdo da atribuição. O tipo é inferido no lado direito. Essa nova sintaxe é uma alternativa para var, que tem o tipo exibido apenas no lado direito da atribuição e é inferido no lado esquerdo com a palavra-chave var.

Você também pode ver o uso do tipo de destino novo e a atribuição às variáveis ​​do controlador. O tipo GpioController é definido apenas no lado esquerdo de uma atribuição. O tipo é inferido à direita. Essa nova sintaxe é uma alternativa para var, cujo tipo é mostrado apenas no lado direito da atribuição e inferido no lado esquerdo com a palavra-chave var.

Os programas de nível superior também podem crescer em complexidade, definindo métodos e aproveitando os tipos definidos no mesmo ou em outros arquivos. O exemplo CharacterLcd demonstra alguns desses recursos.

Os programas de nível superior também podem aumentar em complexidade definindo métodos e utilizando tipos definidos no mesmo ou em outros arquivos. A amostra CharacterLcd demonstra alguns desses recursos.

Padrões lógicos e de propriedade/Configuração de padrão
C# 9 inclui suporte para novos padrões. Você pode ver um exemplo de um padrão lógico no seguinte código do sensor de gás CCS811.

C#9 inclui suporte para novos padrões. Você pode ver um exemplo de modo lógico para o sensor de gás CCS811 no código a seguir.

var threshChoice = Console.ReadKey();Console.WriteLine();if (threshChoice.KeyChar é 'Y' ou 'y'){ TestThresholdAndInterrupt(ccs811);} Outro novo padrão são os padrões de propriedade. Você pode ver várias verificações de propriedades em meu exemplo de acesso às informações do Mycroft 6.0. O código a seguir foi obtido do exemplo de leitor RFID e NFC PN532.

Outro novo modo é o modo de propriedade. Você pode ver exemplos de propriedades My6.0 em My6.0. O código a seguir foi obtido do exemplo de leitor pn532rfid e NFC.

if (pollingType é nulo ou { Length: >15 }){ return null;} Este código testa se pollingType (que é digitado como byte[]?) é nulo ou contém >15 bytes.

Este código testa se pollingType (do tipo byte[]?) está vazio ou contém mais de 15 bytes.

Quero mostrar-lhe mais dois padrões. O primeiro é um padrão lógico no barramento CAN Mcp25xxx.

Quero mostrar-lhe mais dois modos. O primeiro é o modo lógico no barramento CAN Mcp25xxx.

public static byte GetRxBufferNumber(Address address) => switch de endereço{ >= Address.RxB0D0 and <= Address.RxB0D7 => 0, >= Address.RxB1D0 and <= Address.RxB1D7 => 1, _ => throw new ArgumentException( nameof(address), $“Valor de endereço inválido {address}.”),}; O segundo é um padrão lógico no Piezo Buzzer Controller.

O segundo é o modo lógico do controlador piezo buzzer.

if (element is not NoteElement noteElement){ // Caso seja um elemento de pausa, basta aguardar o tempo desejado. Thread.Sleep(durationInMilliseconds);}else{ // Caso seja um elemento de nota, nós o tocamos. var frequência = GetFrequency(noteElement.Note, noteElement.Octave); _buzzer.PlayTone(frequência, (int)(duraçãoEmMilliseconds * 0,7)); Thread.Sleep((int)(durationInMilliseconds * 0.3));} Records/记录C# 9 inclui um novo tipo de classe chamado registro. Ele tem vários benefícios em comparação com as aulas regulares, metade dos quais relacionados a uma sintaxe mais concisa. O registro a seguir é retirado da ligação do sensor RGB Bh1745.

C# 9 inclui uma nova classe chamada registro. Tem muitas vantagens sobre classes regulares, metade das quais tem a ver com uma sintaxe mais limpa. Os registros a seguir são retirados da ligação do sensor Bh1745 RGB.

registro público ChannelCompensationMultipliers (duplo vermelho, duplo verde, duplo azul, duplo claro);
Em seguida, é usado um pouco mais tarde no mesmo arquivo, com sintaxe familiar:

Use-o posteriormente no mesmo arquivo, usando a sintaxe familiar:

ChannelCompensationMultipliers = novo (2.2, 1.0, 1.8, 10.0);
Aprimoramentos de anotação de nulidade/Aprimoramentos de anotação de nulidade
As bibliotecas .NET agora são completamente anotadas para nulidade. Isso significa que, se você habilitar a nulidade, obterá mais informações de tipo da plataforma para direcionar o uso do recurso. No momento, os documentos .NET não foram totalmente anotados. Por exemplo, String.IsNullOrEmpty(string) deve ser anotado para receber uma string?, enquanto String.Split(Char[]) tem uma anotação de char[]?. Esperamos que isso seja corrigido em breve. Informações completas estão disponíveis em source.dot.net e por meio de pesquisas de metadados F12 no Visual Studio.

NET agora está totalmente comentada e vazia. Isso significa que, se você habilitar a nulidade, obterá mais informações de tipo da plataforma para orientá-lo no uso do recurso. Atualmente, a documentação do .NET não está totalmente comentada. Por exemplo, String.IsNullOrEmpty(string) deve ser anotado para obter uma string? , enquanto a string. Anotação para split(Char[]) como Char[]? . Esperamos que seja corrigido em breve. Para obter informações completas, visite source.dot.net Encontre metadados por meio do Visual Studio F12.

Os pacotes System.Device.Gpio e Iot.Device.Bindings (versão 1.1.0 para ambos) também foram anotados como parte desta versão, usando as anotações .NET 5.0 atualizadas. Essas bibliotecas são multidirecionadas, no entanto, usamos a visualização 5.0 para produzir anotações para todos os destinos.

Os pacotes SystemDevice.Gpio e IoTDevice (versão 1.1.0) também são anotados nesta versão com anotações .NET 5.0 atualizadas. Essas bibliotecas são todas multialvo, no entanto, usamos a visualização 5.0 para gerar anotações para todos os destinos.

Observação: o código .NET Core 3.1 existente pode gerar novos diagnósticos (se você tiver capacidade de nulidade habilitada) ao redirecioná-lo para .NET 5.0, pois há novas anotações.

OBSERVAÇÃO: quando você redireciona o código .NET Core 3.1 existente para .NET 5.0, ele pode gerar novos diagnósticos (se você habilitar a capacidade de nulidade) devido às novas anotações.

Também adicionamos novos tipos de anotação. É comum que classes grandes instanciem membros de objeto em métodos auxiliares chamados de um construtor. O compilador C# não pode seguir o fluxo de chamadas para a atribuição de objeto. Ele pensará que o membro é nulo ao sair do construtor e avisará com CS8618. O atributo MemberNotNull resolve esse problema. Você aplica o atributo ao método auxiliar. O compilador verá que você definiu esse valor e perceberá que o método é chamado de um construtor. MemberNotNullWhen é semelhante.

Também adicionamos novos tipos de anotação. É comum que classes grandes instanciem membros de objeto em métodos auxiliares chamados de construtores. Os compiladores C não podem seguir o fluxo de chamadas para atribuições de objetos. Ao sair do construtor, ele considerará o membro nulo e emitirá um aviso com CS8618. O atributo MemberNotNull resolve esse problema. Aplique atributos a métodos auxiliares. O compilador verá que você definiu esse valor e perceberá que o método foi chamado pelo construtor. MemberNotNullWhen é semelhante.

Você pode ver um exemplo de MemberNotNull nos sensores de temperatura BMxx80 com o seguinte código.

Você pode ver um exemplo de MemberNotNull no sensor de temperatura BMxx80, o código está abaixo.

[MemberNotNull(nameof(_calibrationData))]private void ReadCalibrationData(){ switch (this) { case Bme280 _: _calibrationData = new Bme280CalibrationData(); _controlRegister = (byte)Bmx280Register.CTRL_MEAS; quebrar; case Bmp280 _: _calibrationData = new Bmp280CalibrationData(); _controlRegister = (byte)Bmx280Register.CTRL_MEAS; quebrar; case Bme680 _: _calibrationData = new Bme680CalibrationData(); _controlRegister = (byte)Bme680Register.CTRL_MEAS; quebrar; default: throw new Exception(“O dispositivo Bmxx80 não foi configurado corretamente. Não foi possível encontrar os dados de calibração.”); }

_calibrationData.ReadFromDevice(this);}
O código real usa compilação condicional. Isso ocorre porque o projeto tem vários destinos e esse atributo só é compatível com .NET 5.0+ . O uso do atributo permite pular verificações de tempo de execução (no construtor) que seriam necessárias para atender aos requisitos de nulidade, como é o caso de versões anteriores do .NET.

O código real usa compilação condicional. Isso ocorre porque o projeto tem vários destinos e essa propriedade só tem suporte em .NET5.0+. Use esse atributo para ignorar as verificações de tempo de execução (no construtor) que, de outra forma, seriam necessárias para atender aos requisitos de nulidade, assim como as versões anteriores do .NET.

Tools/工具
Melhoramos o designer do Windows Forms, mudamos a maneira como as estruturas de destino funcionam para .NET 5.0 e posteriores, mudamos a maneira como o WinRT é suportado e fizemos outras melhorias.

Melhoramos o designer do Windows Forms, alteramos a forma como as estruturas de destino funcionam no .NET 5.0 e posterior, alteramos a forma como o WinRT é suportado e fizemos outras melhorias.

Windows Forms designer/Windows Forms designer
O Windows Forms designer (para .NET Core 3.1 e .NET 5.0) foi atualizado no Visual Studio 16.8 e agora dá suporte a todos os controles de Windows Forms. Ele também suporta a interface do usuário Telerik para controles WinForms. O designer inclui todas as funcionalidades de designer que você esperaria, incluindo: arrastar e soltar, seleção, mover e redimensionar, recortar/copiar/colar/excluir de controles, integração com a janela de propriedades, geração de eventos e muito mais. A vinculação de dados e o suporte para um conjunto mais amplo de controles de terceiros serão disponibilizados em breve.

O designer de Windows Forms (para .NET Core 3.1 e .NET 5.0) foi atualizado no Visual Studio 16.8 e agora dá suporte a todos os controles de Windows Forms. Ele também suporta a interface de usuário Telerik para controles WinForms. O designer inclui todos os recursos de designer esperados, incluindo: arrastar e soltar, seleção, mover e redimensionar, cortar/copiar/colar/excluir controles, integração com janelas de propriedades, geração de eventos e muito mais. Vinculação de dados e suporte para controles de terceiros mais amplos estão chegando.

Saiba mais na postagem Windows Forms Designer for .NET Core Released.

Para obter mais informações, consulte o artigo publicado pelo Windows Forms Designer para .NET Core.

Estrutura de destino do .NET 5.0/.NET 5.0
Alteramos a abordagem que usamos para estruturas de destino com .NET 5.0. O arquivo de projeto a seguir demonstra a nova estrutura de destino .NET 5.0.

Mudamos a abordagem para estruturas de destino usando .NET 5.0. O arquivo de projeto abaixo demonstra a nova estrutura de destino .NET 5.0.

Exe net5.0 O novo formulário net5.0 é mais compacto e intuitivo do que o estilo netcoreapp3.1 que usamos até agora. Além disso, estamos estendendo a estrutura de destino para descrever as dependências do sistema operacional. Essa mudança é motivada por nossa visão de habilitar o direcionamento para iOS e Android com Xamarin no .NET 6.0.

O novo formulário net5.0 é mais conciso e intuitivo do que o estilo netcoreapp3.1 que usamos antes. Além disso, estamos estendendo a estrutura de destino para descrever as dependências do sistema operacional. A motivação para essa mudança é nossa visão de segmentar iOS e Android com Xamarin no .NET 6.0.

As APIs de área de trabalho do Windows (incluindo Windows Forms, WPF e WinRT) só estarão disponíveis ao direcionar net5.0-windows. Você pode especificar uma versão do sistema operacional, como net5.0-windows7 ou net5.0-windows10.0.17763.0 (para Windows Update de outubro de 2018). Você precisa direcionar uma versão do Windows 10 se quiser usar APIs do WinRT.

As APIs da área de trabalho do Windows (incluindo Windows Forms, WPF e WinRT) estão disponíveis apenas ao direcionar net5.0-Windows. Você pode especificar a versão do sistema operacional, como net5.0-windows7 ou net5.0-windows10.0.17763.0 (para a atualização de outubro de 2018 do Windows). Se você precisar usar a versão da API do WinRT, precisará usar a API do WinRT.

Cenários de plataforma cruzada podem ser um pouco mais desafiadores, ao usar o novo TFM net5.0-windows. System.Device.Gpio demonstra um padrão para gerenciar a estrutura de destino do Windows se você quiser evitar compilar para o Windows ou evitar obter pacotes de tempo de execução do Windows no Linux, por exemplo.

Cenários de plataforma cruzada podem ser mais desafiadores ao usar o novo TFM net5.0-windows. SystemDevice.Gpio demonstra um padrão para gerenciar estruturas de destino do Windows se você deseja evitar a criação para o Windows ou evitar a extração de pacotes do Windows Runtime no Linux, por exemplo.

Sumário de Mudanças:

net5.0 é o novo Target Framework Moniker (TFM) para .NET 5.0.

O net5.0 combina e substitui os TFMs netcoreapp e netstandard.

net5.0 oferece suporte ao modo de compatibilidade do .NET Framework

net5.0-windows será usado para expor a funcionalidade específica do Windows, incluindo Windows Forms, WPF e APIs do WinRT.

O .NET 6.0 usará a mesma abordagem, com net6.0, e adicionará net6.0-ios e net6.0-android.

Os TFMs específicos do sistema operacional podem incluir números de versão do sistema operacional, como net6.0-ios14.

APIs portáteis, como ASP.NET Core, poderão ser usadas com net5.0. O mesmo acontecerá com os formulários Xamarin com net6.0.

Sumário de Mudanças:

net5.0 é o novo moniker de estrutura de destino (TFM) para .net5.0.

O net5.0 combina e substitui os TFMs netcoreapp e netstandard.

net5.0 oferece suporte ao modo de compatibilidade do .NET Framework

net5.0-windows será usado para expor a funcionalidade específica do Windows, incluindo Windows Forms, WPF e WinRTApi.

.net6.0 usará a mesma abordagem que net6.0 e adicionará net6.0-ios e net6.0-android.

Um tfm específico do sistema operacional pode incluir um número de versão do sistema operacional, como net6.0-ios14.

A API portátil, como ASP.NET core, estará disponível para net5.0. O mesmo vale para formulários Xamarin para net6.0.

Os modelos no Visual Studio 16.8 ainda visam o .NET Core 3.1, para aplicativos de console, WPF e Windows Forms. Os modelos ASP.NET foram atualizados para suportar .NET 5.0. Atualizaremos os modelos no Visual Studio 16.9 para os modelos restantes.

Os modelos no Visual Studio 16.8 ainda visam o .NET Core 3.1 para aplicativos de console, WPF e Windows Forms. Este modelo ASP.NET foi atualizado para suportar .NET5.0. Atualizaremos os modelos para os modelos restantes no Visual Studio 16.9.

WinRT Interop (Breaking Change)/WinRT Interop（中断更改）
Com relação ao direcionamento de APIs do Windows, mudamos para um novo modelo de suporte a APIs do WinRT como parte do .NET 5.0. Isso inclui chamar APIs (em qualquer direção; CLR <==> WinRT), empacotamento de dados entre os dois sistemas de tipos e unificação de tipos que devem ser tratados da mesma forma no sistema de tipos ou limite ABI (ou seja, “tipos projetados ”; IEnumerable e IIterable são exemplos).

Quanto ao direcionamento de APIs do Windows, mudamos para um novo modelo que oferece suporte a APIs WinRT como parte do .NET 5.0. Isso inclui chamar APIs (em qualquer direção; CLR<=>WinRT), empacotar dados entre dois sistemas de tipos e manipular tipos idênticos uniformemente em sistemas de tipos ou limites ABI (ou seja, "tipos projetados"; IEnumerable e IIterable são exemplos).

O sistema de interoperabilidade WinRT existente foi removido do tempo de execução do .NET como parte do .NET 5.0. Esta é uma mudança radical. Isso significa que aplicativos e bibliotecas que usam WinRT com .NET Core 3.x precisarão ser reconstruídos e não serão executados no .NET 5.0 como está. As bibliotecas que usam APIs do WinRT precisarão de vários destinos para gerenciar essa diferença entre .NET Core 3.1 e .NET 5.0.

O sistema de interoperabilidade WinRT existente foi removido do tempo de execução .NET como parte do .NET 5.0. Esta é uma mudança radical. Isso significa que aplicativos e bibliotecas que usam WinRT e .NET Core 3.x precisam ser reconstruídos para serem executados no .NET 5.0 como fazem agora. As bibliotecas que usam a API do WinRT exigem multidirecionamento para gerenciar as diferenças entre .NETCore3.1 e .NET5.0.

No futuro, contaremos com a nova ferramenta CsWinRT fornecida pela equipe WinRT no Windows. Ele gera assemblies de interoperabilidade WinRT baseados em C#, que podem ser entregues via NuGet. Isso é exatamente o que a equipe do Windows está fazendo para as APIs do WinRT no Windows. A ferramenta pode ser usada por qualquer pessoa que queira usar o WinRT (no Windows) como um sistema de interoperabilidade, para expor APIs nativas para .NET ou APIs .NET para código nativo.

A seguir, contaremos com a nova ferramenta CsWinRT fornecida pela equipe WinRT no Windows. Ele gera assemblies de interoperabilidade WinRT baseados em C que podem ser entregues via NuGet. Isso é exatamente o que a equipe do Windows está fazendo para o winrtapi no Windows. Qualquer pessoa pode usar a ferramenta para usar o WinRT (no Windows) como um sistema interoperável, para expor APIs nativas para .NET ou para expor APIs .net para código nativo.

A ferramenta CsWinRT é logicamente semelhante a tlbimp e tlbexp, embora muito melhor. As ferramentas tlb dependiam de muitos encanamentos de interoperabilidade COM no tempo de execução do .NET. A ferramenta CsWinRT depende apenas de APIs .NET públicas. Dito isso, o recurso de ponteiros de função no C# 9 — e parcialmente implementado no tempo de execução do .NET 5.0 — foi parcialmente inspirado pelas necessidades da ferramenta CsWinRT.

A ferramenta CsWinRT é logicamente semelhante a tlbimp e tlbexp, embora melhor. A ferramenta tlb depende de um amplo encanamento de interoperabilidade COM no tempo de execução do .NET. A ferramenta CsWinRT depende apenas do .netapi público. Dito isso, o recurso de ponteiros de função em C#9 - implementado em parte no tempo de execução do .NET 5.0 - foi inspirado em parte pelas necessidades da ferramenta CsWinRT.

Existem vários benefícios para este novo modelo de interoperabilidade do WinRT:

Ele pode ser desenvolvido e aprimorado separadamente do tempo de execução do .NET.

É simétrico com os sistemas de interoperabilidade baseados em ferramentas fornecidos para outros sistemas operacionais, como iOS e Android.

A ferramenta pode aproveitar outros recursos do .NET (AOT, C# recursos, IL linking), que não era uma opção para o sistema anterior.

Simplifica a base de código do tempo de execução do .NET.

Este novo modelo de interoperabilidade WinRT tem várias vantagens:

Ele pode ser desenvolvido e aprimorado independentemente do tempo de execução do .NET.

É simétrico aos sistemas de interoperabilidade baseados em ferramentas fornecidos para outros sistemas operacionais, como iOS e Android.

A ferramenta pode tirar proveito de outros recursos .NET (AOT, C# recursos, IL linking), o que não era uma opção em sistemas anteriores.

Simplifique a base de código de tempo de execução do .NET.

Você não precisa adicionar referências do NuGet para usar as APIs do WinRT. Direcionar um Windows 10 TFM — discutido anteriormente na seção .NET 5.0 TFM — é suficiente. Se você tiver como destino o .NET Core 3.1 ou anterior, precisará fazer referência aos pacotes WinRT. Você pode ver esse padrão no projeto System.Device.Gpio.

Você pode usar winrtapi sem adicionar referências do NuGet. Direcionar o Windows 10 TFM — discutido agora na seção .NET 5.0 TFM — é suficiente. Se tiver como alvo o .NET Core 3.1 ou anterior, você precisará referenciar o pacote WinRT. Você pode encontrá-lo no projeto systemdevice.Gpio.

Exportações nativas/Recebemos
solicitações para habilitar exportações para binários nativos que chamam o código .NET há muito tempo. O bloco de construção para o cenário é o suporte de API de hospedagem para UnmanagedCallersOnlyAttribute.

Pedimos há muito tempo para habilitar a exportação de binários nativos que chamam o código .NET. O bloco de construção deste cenário é o suporte de API gerenciado para UnmanagedCallersOnlyAttribute.

Esse recurso é um bloco de construção para criar experiências de nível superior. Aaron Robinson, da nossa equipe, está trabalhando em um projeto .NET Native Exports que fornece uma experiência mais completa para a publicação de componentes .NET como bibliotecas nativas. Estamos procurando feedback sobre esse recurso para ajudar a decidir se a abordagem deve ser incluída no produto.

Essa funcionalidade é o bloco de construção para criar experiências de nível superior. Aaron Robinson tem trabalhado em um projeto de exportação nativa .NET em nossa equipe que fornece uma experiência mais completa para a publicação de componentes .NET como bibliotecas nativas. Estamos procurando feedback sobre esse recurso para ajudar a decidir se esse método deve ser incluído no produto.

O projeto de exportação .NET Native permite:

Exponha exportações nativas personalizadas.

Não requer uma tecnologia de interoperabilidade de alto nível como COM.

Funciona em plataforma cruzada.

O projeto de exportação .NET Native permite:

Expõe exportações nativas personalizadas.

Tecnologias de interoperabilidade de alto nível, como COM, não são necessárias.

Trabalhe em várias plataformas.

Existem projetos existentes que possibilitam cenários semelhantes, como:

Exportações não gerenciadas

DllExport

Os projetos existentes apoiam esquemas semelhantes, tais como:

exportação não gerenciada

Porta DLLEX

Ao longo dos anos, vimos uma variedade de modelos de hospedagem para .NET em aplicativos nativos. @rseanhall propôs e implementou um novo modelo para fazer isso, que aproveita toda a funcionalidade integrada do aplicativo oferecida pela camada de hospedagem do aplicativo .NET (especificamente carregando dependências), enquanto permite que um ponto de entrada personalizado seja chamado a partir do código nativo. Isso é perfeito para muitos cenários e pode-se imaginar que se tornou popular entre os desenvolvedores que hospedam componentes .NET de aplicativos nativos. Isso não existia antes. Obrigado pela contribuição, @rseanhall.

Ao longo dos anos, vimos vários modelos de hospedagem .NET em aplicativos nativos. @rseanhall propôs e implementou um novo modelo para isso que aproveita toda a funcionalidade integrada do aplicativo fornecida pela camada de hospedagem do aplicativo .NET (principalmente carregamento de dependências) enquanto permite que pontos de entrada personalizados sejam chamados a partir do código nativo. Isso é perfeito para muitos cenários e é concebível que tenha se tornado popular entre os desenvolvedores que hospedam componentes .NET de aplicativos nativos. não existia antes. Obrigado pela sua contribuição, @rseanhall.

Dois PRs principais:

Ativar chamar get_runtime_delegate no contexto do aplicativo

Implementar hdt_get_function_pointer

Duas requisições principais:

Habilitar chamar get_runtime_delegate do contexto do aplicativo

Implementar hdt_get_function_pointer

Event pipe/事件管道
Event pipe é um novo subsistema e API que adicionamos no .NET Core 2.2 para possibilitar a execução de desempenho e outras investigações de diagnóstico em qualquer sistema operacional. No .NET 5.0, o canal de evento foi estendido para permitir que criadores de perfil gravem eventos de canal de evento. Esse cenário é crítico para instrumentar criadores de perfil que anteriormente dependiam do ETW (no Windows) para monitorar o comportamento e o desempenho do aplicativo.

O Event Pipeline é um novo subsistema e API que adicionamos no .NET Core 2.2 para realizar investigações de desempenho e outros diagnósticos em qualquer sistema operacional. No .NET 5.0, o pipeline de eventos foi estendido para permitir que criadores de perfil gravem eventos de pipeline de eventos. Esse cenário é crítico para detectar criadores de perfil que anteriormente dependiam do ETW (no Windows) para monitorar o comportamento e o desempenho do aplicativo.

As informações de carga do assembly agora estão disponíveis por meio do canal de evento. Essa melhoria é o início da disponibilização de funcionalidades de diagnóstico semelhantes como parte do .NET Framework, como o Fusion Log Viewer. Agora você pode usar dotnet-trace para coletar essas informações, usando o seguinte comando:

As informações de carregamento do assembly agora estão disponíveis por meio do pipeline de eventos. Essa melhoria é o início da disponibilização de recursos de diagnóstico semelhantes como parte do .NET Framework, como o Fusion Log Viewer. Essas informações agora podem ser coletadas usando dotnet trace usando o seguinte comando:

dotnet-trace collect --providers Microsoft-Windows-DotNETRuntime:4:4 – ./MyApp –my-arg 1
O fluxo de trabalho é descrito nos documentos dotnet-trace. Você pode ver as informações de carregamento do assembly para um aplicativo de teste simples.

O fluxo de trabalho é descrito na documentação do dotnet trace. Você pode ver as informações de carregamento do assembly para um aplicativo de teste simples.

Microsoft.Extensions.Logging
Fizemos melhorias no provedor de log do console na biblioteca Microsoft.Extensions.Logging. Agora você pode implementar um ConsoleFormatter personalizado para exercer controle total sobre a formatação e a colorização da saída do console. As APIs do formatador permitem uma formatação avançada implementando um subconjunto das sequências de escape VT-100 (suportadas pela maioria dos terminais modernos). O logger do console pode analisar sequências de escape em terminais não suportados, permitindo que você crie um único formatador para todos os terminais.

Fizemos melhorias no provedor de log do console na biblioteca Microsoft.Extensions.Logging. Agora você pode implementar um formato de console personalizado para ter controle total sobre a formatação e as cores da saída do console. A API do formatador permite formatação avançada implementando um subconjunto de sequências de escape VT-100 (suportadas pela maioria dos terminais modernos). O logger do console pode analisar sequências de escape em terminais não suportados, permitindo que você escreva um formatador para todos os terminais.

Além do suporte para formatadores personalizados, também adicionamos um formatador JSON integrado que emite logs JSON estruturados para o console.

Além de oferecer suporte a formatadores personalizados, adicionamos um formatador JSON integrado que envia logs JSON estruturados para o console.

Dump debugging/转储调试
A depuração de código gerenciado requer conhecimento de objetos e construções gerenciados. O Data Access Component (DAC) é um subconjunto do mecanismo de execução de tempo de execução que tem conhecimento dessas construções e pode acessar esses objetos gerenciados sem um tempo de execução. Os despejos de processo do .NET Core coletados no Linux agora podem ser analisados ​​no Windows usando WinDBG ou análise de despejo dotnet.

A depuração do código gerenciado requer uma compreensão dos objetos e construções gerenciados. Componentes de acesso a dados (DACs), um subconjunto do mecanismo de execução em tempo de execução, compreendem essas construções e podem acessar esses objetos gerenciados sem usar o tempo de execução. NET core process dumps coletados no Linux agora podem ser analisados ​​no Windows usando WinDBG ou análise de dump dotnet.

Também adicionamos suporte para capturar dumps ELF de processos .NET em execução no macOS. Como o ELF não é o formato de arquivo executável nativo (depuradores nativos como lldb não funcionarão com esses despejos) no macOS, tornamos esse um recurso opcional. Para habilitar o suporte para coleta de despejo no macOS, defina a variável de ambiente COMPlus_DbgEnableElfDumpOnMacOS=1. Os despejos resultantes podem ser analisados ​​usando a análise de despejo dotnet.

Também adicionamos suporte para capturar dumps ELF de processos .NET em execução no macOS. Como o ELF não é um formato executável nativo no macOS (depuradores nativos como lldb não podem lidar com esses arquivos de despejo), estamos incluindo-o como um recurso opcional. Para habilitar o suporte para coleta de despejo no macOS, defina a variável de ambiente COMPlus_dbgenablelfdumponmacos=1. O despejo resultante pode ser analisado com análise de despejo dotnet.

Impressão de informações do ambiente/打印环境信息
Como o .NET ampliou o suporte para novos sistemas operacionais e arquiteturas de chip, às vezes as pessoas querem uma maneira de imprimir informações do ambiente. Criamos uma ferramenta .NET simples que faz isso, chamada dotnet-runtimeinfo.

À medida que o .NET expande seu suporte para novos sistemas operacionais e arquiteturas de chip, as pessoas às vezes precisam de uma maneira de imprimir informações ambientais. Criamos uma ferramenta .NET simples para fazer isso chamada dotnetruntimeinfo.

Você pode instalar e executar a ferramenta com os seguintes comandos.

Você pode instalar e executar a ferramenta com os seguintes comandos.

dotnet tool install -g dotnet-runtimeinfo
dotnet-runtimeinfo
A ferramenta produz saída no seguinte formato para seu ambiente.

A ferramenta produz a saída do seguinte formulário para o seu ambiente.

**
Versão da informação .NET: 5.0.0FrameworkDescription: .NET 5.0.0Libraries version: 5.0.0Libraries hash: cf258a14b70ad9069470a108f13765e0e5988f51

Informações do ambiente
OSDescription: Linux 5.8.6-1-MANJARO-ARM #1 SMP Thu Set 3 22:01:08 CEST 2020OSVersion: Unix 5.8.6.1OSArchitecture: Arm64ProcessorCount: 6 CGroup info**
cfs_quota_us: -1
memory.limit_in_bytes: 922337203685477 1712
memory.usage_in_bytes: 2740666368
Runtime and Libraries/运行时和库
Houve muitas melhorias no tempo de execução e nas bibliotecas.

Há muitas melhorias no tempo de execução e na biblioteca.

Melhorias na qualidade do código em RyuJIT/RyuJIT的代码质量改进
Houve muitas melhorias no JIT nesta versão, muitas das quais eu compartilhei em postagens prévias do .NET 5.0. Neste post, estou elevando as mudanças que vieram da comunidade.

Esta versão do JIT tem muitas melhorias, muitas das quais eu compartilhei em artigos de visualização anteriores do .net 5.0. Neste post, estarei promovendo as mudanças trazidas pela comunidade.

Use xmm para o prólogo da pilha – dotnet/runtime #32538 — Mude para o código de zeragem do prólogo x86/x64. Melhorias: Json; TechEmpower. Crédito: Ben Adams.

Vectorize BitArray para Arm64 – dotnet/runtime #33749 — A classe BitArray foi atualizada para incluir uma implementação acelerada por hardware para Arm64 usando Arm64 intrinisics. As melhorias de desempenho do BitArray são muito significativas. Crédito para @Gnbrkm41.

Recurso dinâmico de expansão de dicionário genérico dotnet/runtime #32270 – Alguns (talvez a maioria?) informações sobre tipos e métodos genéricos. Consulte Perf: Collection Count() é mais lento no Core do que no CLR para obter mais informações. Crédito para @RealDotNetDave pelo relatório de bug.

Implementar Vector.Ceiling / Vector.Floor dotnet/runtime #31993 – Implementar Vector.Ceiling / Vector.Floor usando intrínsecos x64 e Arm64, por proposta de API. Crédito para @Gnbrkm41.

Implementação nova, muito mais rápida e portátil de assistentes de chamada traseira. Crédito: Jakob Botsch Nielsen (estagiário da equipe .NET). Reação de @dsymetweets.

Adicionar intrínsecos VectorTableList e TableVectorExtension — Crédito: @TamarChristinaArm (ARM Holdings)

Melhor desempenho da arquitetura Intel usando novos componentes intrínsecos de hardware BSF/BSR — Credit @saucecontrol

Implemente Vector{Size}.AllBitsSet — Crédito @Gnbrkm41

Habilite a eliminação de algumas verificações de limites — Crédito @nathan-moore

Use xmm para o prólogo da pilha – dotnet/runtime#32538 – altere para o código zero do prólogo x86/x64. Melhorias: Json; TechEmpower. Autor: Ben Adams.

Vetorizar BitArray para Arm64 – dotnet/runtime#33749 - A classe BitArray foi atualizada para incluir uma implementação Arm64 acelerada por hardware usando Arm64 Intrinsics. A melhoria de desempenho do BitArray é bastante significativa. Crédito para @Gnbrkm41.

Recurso de extensão de dicionário genérico dinâmico dotnet/runtime Š32270 – algumas (provavelmente a maioria?) descoberta de desempenho). Consulte Perf: Collection Count() é mais lento no núcleo do que CLR para obter detalhes. Créditos do relatório de bug para @RealDotNetDave.

Implemente Vector Ceiling/Vector Floor dotnet/runtime#31993 – Implemente Vector Ceiling/Vector Floor usando intrínsecos x64 e Arm64 de acordo com as recomendações da API. Crédito para @Gnbrkm41.

Implementação nova, mais rápida e portátil de assistentes de chamada posterior. Por Jakob Botsch Nielsen (estagiário da equipe .NET). Reação de @dsymetweets.

Adicionando intrínsecos VectorTableList e tablevectorenextension - Crédito: @TamarChristinaArm (ARM Holdings)

Desempenho aprimorado em arquiteturas Intel com novos intrínsecos de hardware BSF/BSR - Credit@saucecontrol

Implemente o vetor {Size}.AllBitsSet - Credit @Gnbrkm41

Permitir que algumas verificações de limites sejam omitidas - crédito @nathan moore

Garbage Collector/Garbage Collector
As seguintes melhorias foram feitas no GC.

Roubo de marca de cartão – dotnet/coreclr #25986 — O GC do servidor (em diferentes threads) agora pode funcionar como roubo ao marcar objetos gen0/1 mantidos ativos por objetos de geração mais antiga. Isso significa que as pausas efêmeras de GC são mais curtas para cenários em que alguns encadeamentos de GC levaram muito mais tempo para serem marcados do que outros.

Apresentando o Pinned Object Heap – dotnet/runtime #32283 — Adiciona o Pinned Object Heap (POH). Este novo heap (um par para o Large Object Heap (LOH)) permitirá que o GC gerencie objetos fixados separadamente e, como resultado, evite os efeitos negativos de objetos fixados nos heaps geracionais.

Permitir a alocação de objetos grandes da lista livre enquanto o SOH varre o plano de fundo — alocações de LOH habilitadas usando a lista livre enquanto o BGC está varrendo o SOH. Anteriormente, isso estava usando apenas o espaço de fim de segmento no LOH. Isso permitiu um melhor uso do heap.

Correções de suspensão do GC em segundo plano – dotnet/coreclr #27729 — Correções de suspensão para reduzir o tempo de suspensão do BGC e dos threads do usuário. Isso reduz o tempo total necessário para suspender os encadeamentos gerenciados antes que um GC possa acontecer. dotnet/coreclr #27578 também contribui para o mesmo resultado.

Correção do manuseio de cgroups nomeados no docker — Adicionado suporte para ler limites de cgroups nomeados. Anteriormente, lemos apenas do global.

Otimizar classificação vetorizada – dotnet/runtime #37159 — classificação de lista de marcas vetorizada em GC que reduz o tempo efêmero de pausa do GC (também dotnet/runtime #40613).

Análise de reconhecimento de geração – dotnet/runtime #40322 — análise de reconhecimento de geração que permite determinar quais objetos da geração antiga se apegam aos objetos da geração mais jovem, fazendo com que eles sobrevivam e contribuam para o tempo efêmero de pausa do GC.

Otimize a descompactação de páginas de memória heap do GC – dotnet/runtime #35896 — descommit otimizado, lógica de descommit muito melhor e para o servidor GC retirou completamente o descommit da fase “parar o mundo” que reduziu o tempo de pausa do GC de bloqueio.

As seguintes melhorias foram feitas no GC.

Roubo de marca de cartão - dotnet/corecrr#25986 - Servidor GC (em um encadeamento diferente) agora pode roubar ao marcar objetos gen0/1 mantidos por objetos de geração mais antiga. Isso significa que, para cenários em que alguns encadeamentos de GC demoram muito mais para serem marcados do que outros, as pausas curtas de GC são mais curtas.

Apresentando o Pinned Object Heap - dotnet/runtime#32283 - Adiciona o Pinned Object Heap (POH). Este novo heap (a contraparte do Large Object Heap (LOH)) permitirá que o GC gerencie objetos fixados separadamente, evitando o impacto negativo de objetos fixados no heap de geração.

Permitir que objetos grandes sejam alocados da lista livre durante a varredura do SOH em segundo plano - Permite a alocação de LOH usando a lista livre enquanto o BGC faz a varredura do SOH. Anteriormente, isso usava apenas o espaço de fim de segmento no LOH. Isso permite uma melhor utilização do heap.

Correção de pausa do GC em segundo plano - dotnet/corecrr#27729 - Correção de pausa para reduzir o BGC e o tempo de pausa do encadeamento do usuário. Isso reduz o tempo geral necessário para suspender os encadeamentos gerenciados antes que o GC ocorra. dotnet/corecrr 27578 também ajudou a obter o mesmo resultado.

Correção do manuseio de cgroups nomeados no docker - suporte adicionado para leitura de limites de cgroups nomeados. Anteriormente, lemos apenas global.

Otimize a classificação vetorizada – dotnet/runtime#37159 - Classificação vetorizada da lista de marcadores no GC, reduzindo as pausas curtas do GC (dotnet/runtime#40613).

Análise Geracional - dotnet/runtime#40322 - Análise geracional que permite determinar quais objetos da geração antiga estão se mantendo acima dos objetos da geração mais nova, mantendo-os vivos e causando tempos de pausa curtos do GC.

Desconfirmação otimizada de páginas de memória heap de GC – descommit otimizada para dotnet/tempo de execução, melhor lógica de descommit, para GC de servidor, descommit completamente fora da fase “parar o mundo”, reduzindo assim o tempo de pausa do GC de bloqueio.

O GC agora expõe informações detalhadas da coleção mais recente, por meio do método GC.GetGCMemoryInfo. A estrutura GCMemoryInfo fornece informações sobre a memória da máquina, a memória heap e a coleção mais recente, ou a coleção mais recente do tipo de GC que você especificar – efêmera, bloqueio total ou GC em segundo plano.

GC agora através do método GC.GetGCMemoryInfo. A estrutura GCMemoryInfo fornece informações sobre a memória do computador, a memória heap e a coleção mais recente ou a coleção mais recente do tipo de GC que você especificar — curto, bloqueio completo ou GC em segundo plano.

Os casos de uso mais prováveis ​​para usar essa nova API são para registro/monitoramento ou para indicar a um balanceador de carga que uma máquina deve ser retirada de rotação para solicitar um GC completo. Também pode ser usado para evitar limites rígidos de contêiner, reduzindo o tamanho dos caches.

O cenário mais provável para um novo carregador é usar um novo carregador para monitorar um novo carregador. Ele também evita limites rígidos de contêiner reduzindo o tamanho do cache.

Outra mudança pequena, mas impactante, foi feita para adiar a cara operação de redefinição de memória para situações de pouca memória. Esperamos que essas mudanças na política reduzam a latência do GC (e o uso da CPU do GC em geral).

Outra mudança pequena, mas impactante, é adiar a cara operação de reinicialização da memória até condições de pouca memória. Esperamos que essas alterações de política reduzam a latência do GC (e o uso da CPU do GC em geral).

Os aplicativos Windows Arm64
.NET agora podem ser executados nativamente no Windows Arm64. Isso segue o suporte que adicionamos para Linux Arm64 (suporte para glibc e musl) com .NET Core 3.0. Com o .NET 5.0, você pode desenvolver e executar aplicativos em dispositivos Windows Arm64, como Surface Pro X. Você já pode executar aplicativos .NET Core e .NET Framework no Windows Arm64, mas via emulação x86. É viável, mas a execução nativa do Arm64 tem um desempenho muito melhor.

Os aplicativos .NET agora podem ser executados nativamente no Windows Arm64. Este é o suporte .NETCore3.0 que adicionamos para LinuxARM64 (que suporta glibc e musl). Com o .NET 5.0, você pode desenvolver e executar aplicativos em dispositivos Windows Arm64, como o Surface Pro X. Você já pode executar aplicativos .NET Core e .NET Framework no Windows Arm64, mas por meio da emulação x86. Funciona, mas a implementação nativa do Arm64 tem melhor desempenho.

Os instaladores MSI para Arm64 foram uma das mudanças finais desta versão. Você pode ver o instalador do SDK do .NET 5.0 na imagem a seguir.

O instalador MSI para Arm64 foi uma das últimas alterações nesta versão. Você pode ver o instalador do SDK .NET5.0 na imagem abaixo.

O SDK .NET 5.0 atualmente não contém os componentes do Windows Desktop — Windows Forms e WPF — no Windows Arm64. Essa alteração foi inicialmente compartilhada na postagem .NET 5.0 Preview 8. Esperamos adicionar o pacote de área de trabalho do Windows para Windows Arm64 em uma atualização de serviço 5.0. No momento não temos uma data para compartilhar. Até então, os aplicativos SDK, console e ASP.NET Core têm suporte no Windows Arm64, mas não nos componentes da área de trabalho do Windows.

O SDK .NET 5.0 atualmente não inclui componentes da área de trabalho do Windows no Windows ARM64 — Windows Forms e WPF. Essa alteração foi originalmente compartilhada no .NET 5.0 Preview 8. Esperamos adicionar o pacote de desktop Windows do windowsrm64 na atualização de serviço 5.0. No momento não temos datas para compartilhar. Antes disso, o SDK, o console e o ASP.NET Windows Arm64 suportavam os principais aplicativos, mas não os componentes da área de trabalho do Windows.

Arm64 Performance/Arm64性能
Temos investido significativamente na melhoria do desempenho do Arm64 há mais de um ano. Estamos empenhados em tornar o Arm64 uma plataforma de alto desempenho com .NET. Essas melhorias se aplicam igualmente ao Windows e ao Linux. A portabilidade e a consistência da plataforma sempre foram características atraentes do .NET. Isso inclui oferecer excelente desempenho onde quer que você use .NET. Com o .NET Core 3.x, o Arm64 tem paridade de funcionalidade com o x64, mas faltam alguns recursos de desempenho e investimentos importantes. Resolvemos isso no .NET 5.0, conforme descrito em Desempenho do Arm64 no .NET 5.0.

Por mais de um ano, trabalhamos duro para melhorar o desempenho do Arm64. Estamos empenhados em tornar o Arm64 uma plataforma de alto desempenho com .NET. Essas melhorias também se aplicam ao Windows e ao Linux. A portabilidade e a consistência da plataforma sempre foram características atraentes do .NET. Não importa onde você usa produtos .NET, você pode obter um excelente desempenho. Para .NET Core 3.x, Arm64 é funcionalmente equivalente a x64, mas carece de alguns investimentos e recursos de desempenho importantes. Resolvemos esse problema no .NET 5.0 conforme descrito em Arm64 Desempenho no .NET 5.0.

As melhorias:

Ajustar otimizações JIT para Arm64 (exemplo)

Habilite e aproveite os intrínsecos de hardware Arm64 (exemplo).

Ajuste algoritmos críticos de desempenho em bibliotecas para Arm64 (exemplo).

medidas de melhoria:

Otimizando a otimização JIT para Arm64 (exemplo)

Habilite e aproveite os intrínsecos de hardware Arm64 (exemplo).

Ajustando algoritmos de desempenho crítico na biblioteca para Arm64 (exemplos).

Consulte Melhorando o desempenho do Arm64 no .NET 5.0 para obter mais detalhes.

Intrínsecos de hardware são um recurso de desempenho de baixo nível que adicionamos no .NET Core 3.0. Na época, adicionamos suporte para instruções e chips x86-64. Como parte do .NET 5.0, estamos estendendo o recurso para dar suporte ao Arm64. Apenas criar os intrínsecos não ajuda no desempenho. Eles precisam ser usados ​​em código de desempenho crítico. Aproveitamos extensivamente os intrínsecos Arm64 em bibliotecas .NET no .NET 5.0. Você também pode fazer isso em seu próprio código, embora precise estar familiarizado com as instruções da CPU para fazer isso.

Consulte Melhorando o desempenho do Arm64 no .NET 5.0 para obter mais detalhes.

Intrínsecos de hardware são um recurso de desempenho de baixo nível que adicionamos no .NET Core 3.0. Naquela época, adicionamos suporte para instruções e chips x86-64. Como parte do .NET 5.0, estamos estendendo essa funcionalidade para oferecer suporte a Arm64. A mera criação de intrínsecos não ajudará no desempenho. Eles precisam ser usados ​​no código crítico de desempenho. Fazemos uso extensivo de intrínsecos Arm64 na biblioteca .NET para .NET 5.0. Você também pode fazer isso em seu próprio código, embora precise estar familiarizado com as instruções da CPU para fazer isso.

Vou explicar como os intrínsecos de hardware funcionam com uma analogia. Na maioria das vezes, os desenvolvedores contam com tipos e APIs incorporados ao .NET, como string.Split ou HttpClient. Essas APIs geralmente aproveitam as APIs do sistema operacional nativo, por meio do recurso P/Invoke. O P/Invoke permite interoperabilidade nativa de alto desempenho e é amplamente usado nas bibliotecas .NET para essa finalidade. Você mesmo pode usar esse mesmo recurso para chamar APIs nativas. Os intrínsecos de hardware são semelhantes, exceto que, em vez de chamar APIs do sistema operacional, eles permitem que você use diretamente as instruções da CPU em seu código. É aproximadamente equivalente a uma versão .NET dos intrínsecos C++. Os intrínsecos de hardware são melhor pensados ​​como um recurso de aceleração de hardware da CPU. Eles fornecem benefícios muito tangíveis e agora são uma parte fundamental do substrato de desempenho das bibliotecas .NET, e responsável por muitos dos benefícios sobre os quais você pode ler na postagem de desempenho do .NET 5.0. Em termos de comparação com C++, quando os intrínsecos do .NET são compilados por AOT em arquivos prontos para execução, os intrínsecos não têm penalidade de desempenho de tempo de execução.

Usarei uma analogia para explicar como funcionam os componentes internos do hardware. Na maioria dos casos, os desenvolvedores contam com tipos e APIs incorporados ao .NET, como strings. Dividir ou HttpClient. Essas APIs normalmente utilizam APIs nativas do sistema operacional por meio do recurso P/Invoke. O P/Invoke oferece suporte à interoperabilidade nativa de alto desempenho e é amplamente usado em bibliotecas .NET. Você mesmo pode usar esse recurso para chamar APIs nativas. Os intrínsecos de hardware são semelhantes, exceto que, em vez de chamar APIs do sistema operacional, eles permitem que você use instruções de CPU diretamente em seu código. É aproximadamente equivalente à versão .NET dos componentes internos do C++. Os intrínsecos de hardware são melhor pensados ​​como recursos acelerados de hardware da CPU. Eles fornecem benefícios muito tangíveis e agora são uma parte fundamental da base de desempenho das bibliotecas .NET e são responsáveis ​​por muitos dos benefícios que você aprendeu no artigo sobre desempenho do .NET 5.0. Em comparação com C++, não há essencialmente nenhuma penalidade de desempenho de tempo de execução quando os componentes internos do .NET são compilados em arquivos executáveis.

Nota: O compilador Visual C++ possui um recurso intrínseco análogo. Você pode comparar diretamente C++ com intrínsecos de hardware .NET, como você pode ver se pesquisar _mm_i32gather_epi32 em System.Runtime.Intrinsics.X86.Avx2, lista de intrínsecos x64 (amd64) e guia Intel Intrinsics. Você verá muita semelhança.

Nota: O compilador Visual C++ tem características essenciais semelhantes. Você pode comparar o C++ diretamente com os componentes internos do hardware .NET, como pode ver se pesquisar por System.Runtime.Intrinsics.X86.Avx2, x64 (amd64) Intrinsics List e Intel Intrinsics Guide. Você encontrará muitas semelhanças.

Estamos fazendo nossos primeiros grandes investimentos no desempenho do Arm64 no 5.0 e continuaremos esse esforço nas versões subsequentes. Trabalhamos diretamente com engenheiros da Arm Holdings para priorizar as melhorias do produto e projetar algoritmos que melhor aproveitem o Armv8 I SA . Algumas dessas melhorias agregarão valor ao Arm32, no entanto, não estamos aplicando esforços exclusivos ao Arm32. Se você usa um Raspberry Pi, aproveitará essas melhorias se instalar a nova versão Arm64 do Raspberry Pi OS
. primeiro grande investimento no desempenho do Arm64 foi feito nesta versão, e este trabalho continuará nas versões subsequentes. Trabalhamos diretamente com os engenheiros da Arm Holdings para priorizar as melhorias do produto e projetar algoritmos que aproveitem ao máximo o Armv8 ISA. Algumas dessas melhorias agregarão valor ao Arm32, no entanto, não estamos fazendo algo exclusivo do Arm32. Se você estiver usando um Raspberry Pi, aproveitará essas melhorias se instalar a nova versão Arm64 do Raspberry PiOS.

Esperamos que a Apple anuncie novos computadores Mac Apple Silicon a qualquer momento. Já temos versões iniciais do .NET 6.0 para Apple Silicon e estamos trabalhando com os engenheiros da Apple para ajudar a otimizar o .NET para essa plataforma. Também tivemos algum envolvimento inicial da comunidade no Apple Silicon (Crédito @snickler).

Esperamos que a Apple lance novos Macs baseados em silício da Apple a qualquer momento. Desenvolvemos uma versão inicial do .NET 6.0 para Apple Silicon e trabalhamos com engenheiros da Apple para ajudar a otimizar o .NET para a plataforma. Também tivemos algumas atividades iniciais da comunidade no Apple Silicon (Crédito: @snickler).

P95+ Latency/P95+延迟
Vemos um número crescente de grandes sites e serviços voltados para a Internet sendo hospedados em .NET. Embora haja muito foco legítimo na métrica de solicitações por segundo (RPS), descobrimos que nenhum grande proprietário de site nos pergunta sobre isso ou exige milhões de RPS. Ouvimos muito sobre latência, no entanto, especificamente sobre como melhorar a latência P95 ou P99. Frequentemente, o número de máquinas ou núcleos provisionados para (e o maior direcionador de custo) de um local é escolhido com base na obtenção de uma métrica P95 específica, em vez de P50. Pensamos na latência como sendo a verdadeira “métrica do dinheiro”.

Estamos vendo cada vez mais sites e serviços voltados para a Internet sendo hospedados em .NET. Embora haja muito interesse legítimo na métrica de solicitações por segundo (RPS), não encontramos grandes proprietários de sites nos perguntando sobre isso, nem precisando de RPS na casa dos milhões. No entanto, estamos ouvindo muito sobre latência, especialmente sobre coisas para melhorar a latência no P95 ou P99. Normalmente, o número de máquinas ou núcleos configurados para um local (e o maior direcionador de custo) é escolhido com base na obtenção de uma métrica P95 específica, não P50. Consideramos a latência a verdadeira "métrica para o dinheiro".

Nossos amigos do Stack Overflow fazem um ótimo trabalho ao compartilhar dados em seus serviços. Um de seus engenheiros, Nick Craver, compartilhou recentemente as melhorias que viu na latência, como resultado da mudança para o .NET Core:

Nossos amigos do Stack Overflow fazem um ótimo trabalho ao compartilhar dados em seus serviços. Um de seus engenheiros, Nick Craver, compartilhou recentemente as melhorias de latência encontradas como resultado da mudança para o .NET Core:

O tempo médio de renderização da página para perguntas caiu de cerca de 21 ms (estávamos um pouco atrasados ​​devido ao GC) para aproximadamente 15 ms.

O percentil 95 caiu de ~40ms para ~30ms (mesma medição). 99 caiu de ~60ms para ~45ms.

Nada mal, já que ainda não otimizamos nada. pic.twitter.com/MMHjI9wkuL

— Nick Craver (@Nick_Craver) 31 de março de 2020

Os objetos fixados têm sido um desafio de longo prazo para o desempenho do GC, especificamente porque aceleram (ou causam) a fragmentação da memória. Adicionamos uma nova pilha de GC para objetos fixados. A pilha de objetos fixados é baseada na suposição de que há muito poucos objetos fixados em um processo, mas que sua presença causa desafios de desempenho desproporcionais. Faz sentido mover objetos fixados — especialmente aqueles criados por bibliotecas .NET como um detalhe de implementação — para uma área exclusiva, deixando as pilhas de GC geracionais com poucos ou nenhum objeto fixado e, como resultado, um desempenho substancialmente superior.

Os objetos fixados têm sido um desafio de longa data para o desempenho do GC, especialmente porque aceleram (ou causam) a fragmentação da memória. Adicionamos uma nova pilha de GC para objetos fixados. A pilha de objetos fixados é baseada na suposição de que existem apenas alguns objetos fixados em um processo, mas sua presença causa um desafio de desempenho desproporcional. Faz sentido mover objetos fixados (especialmente aqueles criados por bibliotecas .NET como um detalhe de implementação) para uma área distinta para que o heap GC resultante tenha poucos ou nenhum objeto fixado, melhorando assim muito o desempenho.

Mais recentemente, temos atacado desafios de longa data no GC. O dotnet/runtime #2795 aplica uma nova abordagem à verificação estática de GC que evita a contenção de bloqueio quando está determinando a atividade de objetos de heap de GC. dotnet/runtime #25986 usa um novo algoritmo para balancear o trabalho de GC entre os núcleos durante a fase de marcação da coleta de lixo, o que deve aumentar a taxa de transferência da coleta de lixo com grandes heaps, o que, por sua vez, reduz a latência.

Recentemente, enfrentamos um desafio de longa data na GC. dotnet/runtime#2795 aplica uma nova abordagem à verificação estática de GC que evita a contenção de bloqueio ao determinar a atividade de objetos de heap de GC. dotnet/runtime#25986 usa um novo algoritmo para equilibrar o trabalho de GC entre os núcleos durante a fase de marcação da coleta de lixo, o que deve melhorar a taxa de transferência para coletas de lixo com grandes heaps e, assim, reduzir a latência.

Melhorando o desempenho da compilação em camadas/提高分层编译性能
Temos trabalhado para melhorar a compilação em camadas para vários lançamentos. Continuamos a vê-lo como um recurso de desempenho crítico, tanto para inicialização quanto para desempenho em estado estacionário. Fizemos duas grandes melhorias na compilação em camadas nesta versão.

Temos trabalhado para melhorar a compilação em camadas em várias versões. Continuamos a vê-lo como uma característica chave de desempenho, tanto para partida quanto para desempenho em estado estacionário. Nesta versão, fizemos duas melhorias importantes na compilação em camadas.

O principal mecanismo subjacente à compilação em camadas é a contagem de chamadas. Depois que um método é chamado n vezes, o tempo de execução solicita ao JIT que recompile o método com qualidade superior. Desde nossas primeiras análises de desempenho, sabíamos que o mecanismo de contagem de chamadas era muito lento, mas não vimos uma maneira direta de resolver isso. Como parte do .NET 5.0, melhoramos o mecanismo de contagem de chamadas usado pela compilação JIT em camadas para suavizar o desempenho durante a inicialização. Em versões anteriores, vimos relatórios de desempenho imprevisível durante os primeiros 10 a 15 segundos da vida útil do processo (principalmente para servidores da Web). Isso agora deve ser resolvido.

O principal mecanismo de compilação em camadas é a contagem de chamadas. Uma vez que um método é chamado n vezes, o runtime pede ao JIT para recompilar o método com maior qualidade. Desde o início da criação de perfil, sabíamos que o mecanismo de contagem de chamadas era muito lento, mas não encontramos uma maneira fácil de corrigir isso. Como parte do .NET 5.0, melhoramos o mecanismo de contagem de chamadas usado pela compilação JIT em camadas para suavizar o desempenho durante a inicialização. Em versões anteriores, vimos relatórios de desempenho imprevisível durante os primeiros 10 a 15 segundos do ciclo de vida do processo (principalmente para servidores da Web). Isso agora deve ser resolvido.

Outro desafio de desempenho que encontramos foi usar compilação em camadas para métodos com loops. O problema fundamental é que você pode ter um método frio (chamado apenas uma vez ou algumas vezes; $lt;n) com um loop que itera muitas vezes. Chamamos esse cenário patológico de “método frio; circuito quente”. É fácil imaginar isso acontecendo com o método Main de uma aplicação. Como resultado, desabilitamos a compilação em camadas para métodos com loops por padrão. Em vez disso, permitimos que os aplicativos optassem pelo uso de compilação em camadas com loops. O PowerShell é um aplicativo que optou por fazer isso, depois de observar melhorias de desempenho de um dígito em alguns cenários.

Outro desafio de desempenho que encontramos foi usar compilação em camadas para métodos com loops. O problema básico é que você pode ter um método frio (chamado apenas uma vez ou algumas vezes; $lt;n ) e um loop que itera várias vezes. Chamamos esse fenômeno patológico de "método frio; ciclo quente". É fácil imaginar isso acontecendo no método principal do aplicativo. Portanto, desabilitamos a compilação em camadas de métodos com loops por padrão. Em vez disso, permitimos que os aplicativos escolham usar compilação em camadas com loops. Um aplicativo que optou por fazer isso é o PowerShell, que obteve melhorias de desempenho de um dígito em alguns cenários.

Para abordar melhor os métodos com loops, implementamos a substituição na pilha (OSR). Isso é semelhante a um recurso que o Java Virtual Machines possui, de mesmo nome. OSR permite que o código executado por um método atualmente em execução seja recompilado no meio da execução do método, enquanto esses métodos estão ativos “on-stack”. Atualmente, esse recurso é experimental e opcional, e apenas em x64.

Para melhor endereçar métodos com loops, implementamos o Stack Replacement (OSR). Isso é semelhante ao recurso de mesmo nome que a máquina virtual Java possui. OSR permite que o código executado pelos métodos atualmente em execução seja recompilado durante a execução do método enquanto esses métodos estiverem ativos "na pilha". Este recurso é atualmente experimental e está disponível apenas em x64.

Para usar o OSR, vários recursos devem ser ativados. O arquivo de projeto do PowerShell é um bom ponto de partida. Você notará que a compilação em camadas e todos os recursos do quick-jit estão ativados. Além disso, você precisa definir a variável de ambiente COMPlus_TC_OnStackReplacement como 1.

Para usar o OSR, vários recursos devem ser ativados. Um arquivo de projeto do PowerShell é um bom lugar para começar. Você notará que a compilação em camadas e todos os recursos de jit rápido estão ativados. Além disso, a variável de ambiente COMPlus_TC_OnStackReplacement precisa ser definida como 1.

Como alternativa, você pode definir as duas variáveis ​​de ambiente a seguir, supondo que todas as outras configurações tenham seus valores padrão:

Como alternativa, as duas variáveis ​​de ambiente a seguir podem ser definidas, desde que todas as outras configurações tenham seus valores padrão:

COMPlus_TC_QuickJitForLoops=1

COMPlus_TC_OnStackReplacement=1

Não pretendemos habilitar o OSR por padrão no .NET 5.0 e ainda não decidimos se daremos suporte a ele na produção.

Não pretendemos habilitar o OSR por padrão no .NET 5.0 e ainda não decidimos se vamos suportá-lo na produção.

Suporte para ICU no Windows/Windows ICU
Usamos a biblioteca ICU para Unicode e suporte à globalização, anteriormente apenas no Linux e macOS. Agora estamos usando essa mesma biblioteca no Windows 10. Essa alteração torna o comportamento das APIs de globalização, como a comparação de string específica da cultura, consistente entre o Windows 10, macOS e Linux. Também usamos ICU com Blazor WebAssembly.

Usamos a biblioteca ICU para suporte a Unicode e globalização, anteriormente disponível apenas em Linux e macOS. Agora estamos usando a mesma biblioteca no Windows 10. Essa alteração torna o comportamento das APIs de globalização, como comparações de cadeia de caracteres específicas da cultura, consistente no Windows 10, macOS e Linux. Também usamos ICU com Blazor WebAssembly.

Expandindo System.DirectoryServices.Protocols para Linux e macOS/扩大System.DirectoryServices.Protocols.协议到Linux e macOS
Estamos adicionando suporte de plataforma cruzada para System.DirectoryServices.Protocols. Isso inclui suporte para Linux e suporte para macOS. O suporte do Windows era pré-existente.

System.DirectoryServices.Protocols é uma API de nível inferior a System.DirectoryServices e habilita (ou pode ser usado para habilitar) mais cenários. System.DirectoryServices inclui conceitos/implementações somente do Windows, então não era uma escolha óbvia fazer plataforma cruzada. Ambos os conjuntos de API permitem controlar e interagir com um servidor de serviço de diretório, como LDAP ou Active Directory.

Adicionamos suporte multiplataforma para System.DirectoryServices.Protocols. Protocols. Isso inclui suporte para Linux e suporte para macOS. O suporte do Windows é pré-existente.

System.DirectoryServices.Protocols.Protocolo é um serviço que o diretório do sistema, e habilita (ou pode ser usado para habilitar) mais programas. O serviço de diretório do sistema contém apenas o conceito/implementação do Windows, portanto, a escolha entre plataformas não é óbvia. Ambos os conjuntos de API suportam controle e interação com servidores de serviço de diretório, como LDAP ou Active Directory.

System.Text.Json
System.Text.Json foi significativamente aprimorado no .NET 5.0 para melhorar o desempenho, a confiabilidade e facilitar a adoção por pessoas familiarizadas com o Newtonsoft.Json. Ele também inclui suporte para desserializar objetos JSON para registros.

Os arquivos System.Text.Json foram significativamente aprimorados no .NET 5.0 para melhorar o desempenho, a confiabilidade e facilitar a adoção do familiar Newtonsoft.Json. Ele também oferece suporte à desserialização de objetos JSON em registros.

Se você estiver pensando em usar o System.Text.Json como uma alternativa ao Newtonsoft.Json, verifique o guia de migração. O guia esclarece a relação entre essas duas APIs. System.Text.Json destina-se a abranger muitos dos mesmos cenários que Newtonsoft.Json, mas não se destina a ser um substituto imediato ou obter paridade de recursos com a popular biblioteca JSON. Tentamos manter um equilíbrio entre desempenho e usabilidade e viés de desempenho em nossas escolhas de design.

Se você quiser usar os arquivos System.Text.Json como substitutos do Newtonsoft.Json, verifique o guia de migração. Este guia esclarece a relação entre essas duas APIs. A documentação do System.Text.Json destina-se a cobrir muitos dos mesmos problemas do Newtonsoft.Json, mas não se destina a substituir as bibliotecas JSON populares, nem a obter equivalência funcional com as bibliotecas JSON populares. Tentamos manter um equilíbrio entre desempenho e usabilidade e favorecer o desempenho em nossas escolhas de design.

Métodos de extensão HttpClient
Os métodos de extensão JsonSerializer agora são expostos no HttpClient e simplificam bastante o uso dessas duas APIs juntas. Esses métodos de extensão removem a complexidade e cuidam de uma variedade de cenários para você, incluindo manipulação do fluxo de conteúdo e validação do tipo de mídia de conteúdo. Steve Gordon faz um ótimo trabalho explicando os benefícios em Enviar e receber JSON usando HttpClient com System.Net.Http.Json.

O método de extensão JsonSerializer agora está exposto no HttpClient e simplifica bastante o uso dessas duas APIs juntas. Esses métodos de extensão removem a complexidade e lidam com vários cenários para você, incluindo manipulação de fluxos de conteúdo e validação de tipos de mídia de conteúdo. stevegordon tem uma boa explicação sobre os benefícios de enviar e receber JSON usando o arquivo HttpClient System.Net.Http.Json.

O exemplo a seguir desserializa os dados JSON de previsão do tempo em um registro Forecast, usando o novo

Desserialize os novos dados de previsão do tempo usando JSON no exemplo abaixo

Este código é compacto! Ele depende de programas e registros de nível superior do C# 9 e do novo método de extensão GetFromJsonAsync(). O uso de foreach e await tão próximos pode fazer você se perguntar se vamos adicionar suporte para streaming de objetos JSON. EU realmente espero.

Este código é compacto! Ele se baseia nos procedimentos e registros de nível superior do C#9 e no novo método de extensão GetFromJsonAsync(). Usar foreach e await tão próximos pode fazer você se perguntar se deseja adicionar suporte para objetos JSON de streaming. EU realmente espero.

Você pode tentar isso em sua própria máquina. Os comandos .NET SDK a seguir criarão um serviço de previsão do tempo usando o modelo WebAPI. Ele exporá o serviço no seguinte URL por padrão: https://localhost:5001/WeatherForecast. Este é o mesmo URL usado na amostra.

Você pode tentar isso em sua própria máquina. O comando .NETSDK a seguir criará um serviço de previsão do tempo usando o modelo WebAPI. Por padrão, ele exporá o serviço no seguinte URL: https://localhost:5001/weatherforecast. Este é o mesmo URL usado no exemplo.

rich@thundera ~ % dotnet new webapi -o webapi
rich@thundera ~ % cd webapi
rich@thundera webapi % dotnet run
Verifique se você executou dotnet dev-certs https --confie primeiro ou o aperto de mão entre cliente e servidor não acontecerá trabalhar. Se estiver com problemas, consulte Confiar no certificado de desenvolvimento HTTPS do ASP.NET Core.

Certifique-se de ter executado dotnet dev certs https --trust primeiro, caso contrário, o handshake entre o cliente e o servidor não funcionará. Se você tiver problemas, consulte Confiar no certificado de desenvolvimento HTTPS do ASP.NET Core.

Em seguida, você pode executar a amostra anterior.

Em seguida, o exemplo anterior pode ser executado.

rich@thundera ~ % git clone https://gist.github.com/3b41d7496f2d8533b2d88896bd31e764.git previsão do tempo
rich@thundera ~ % cd previsão do tempo
rich@thundera previsão do tempo % dotnet run
9/9/2020 12:09: 19 PM; 24C; Chilly9/10/2020 12:09:19 PM; 54C; Mild9/11/2020 12:09:19 PM; -2C; 13/2020 12:09:19 PM; 45C; Balmy Melhor suporte
para
tipos imutáveis

Existem vários padrões para definir tipos imutáveis. Os discos são apenas os mais novos. JsonSerializer agora tem suporte para tipos imutáveis.

Neste exemplo, você verá a serialização com uma estrutura imutável.

Existem vários padrões para definir tipos imutáveis. Os registros estão atualizados. JsonSerializer agora oferece suporte a tipos imutáveis.

Neste exemplo, você verá a serialização com estruturas imutáveis.

using System; using System.Text.Json; ,“temperaturaF”:31,“resumo”:“Escaldante”} ";
var opções = new JsonSerializerOptions(){ PropertyNameCaseInsensitive = verdadeiro, IncludeFields = verdadeiro, PropertyNamingPolicy = JsonNamingPolicy.CamelCase};var previsão = JsonSerializer.Deserialize(json, opções);Console.WriteLine(forecast.Date);Console.WriteLine(forecast. TemperatureC);Console.WriteLine(forecast.TemperatureF);Console.WriteLine(forecast.Summary);var roundTrippedJson = JsonSerializer.Serialize(previsão, opções);Console.WriteLine(roundTrippedJson);public struct Forecast{ public DateTime Date {get; } public int TemperaturaC {obter;}





public int TemperatureF {get;}
public string Summary {get;}
[JsonConstructor]
public Forecast(DateTime date, int temperatureC, int temperatureF, string summary) => (Data, TemperaturaC, TemperaturaF, Resumo) = (data, temperaturaC, temperaturaF , resumo);}
Nota: O atributo JsonConstructor é necessário para especificar o construtor a ser usado com structs. Com classes, se houver apenas um único construtor, o atributo não será necessário. O mesmo com os registros.

Nota: O atributo JsonConstructor é necessário para especificar o construtor a ser usado com o struct. Para classes, se houver apenas um construtor, as propriedades não são necessárias. O mesmo vale para os registros.

Ele produz a seguinte saída:

Ele produz a seguinte saída:

rich@thundera jsonserializerimmutabletypes % dotnet run
9/6/2020 11:31:01 AM
-131Scorching{“date”:“2020-09-06T11:31:01.923395-07:00”,“temperatureC”:-1,“temperatureF ”:31,“summary”:“Scorching”}
O suporte para registros/o
suporte JsonSerializer para registros é quase o mesmo que acabei de mostrar para tipos imutáveis. A diferença que quero mostrar aqui é a desserialização de um objeto JSON para um registro que expõe um construtor parametrizado e uma propriedade init opcional.

O suporte do JsonSerializer para registros é praticamente o mesmo dos tipos imutáveis ​​que acabei de mostrar. A diferença que quero mostrar aqui é a desserialização do objeto JSON em um registro que expõe um construtor parametrizado e uma propriedade init opcional.

Aqui está o programa, incluindo a definição do registro:

Aqui está o procedimento, incluindo a definição do registro:

Ele produz a seguinte saída:

Ele produz a seguinte saída:

rich@thundera jsonserializerrecords % dotnet run
{“Data”:“2020-09-12T18:24:47.053821-07:00”,“TemperaturaC”:40,“Resumo”:“Quente!”}Previsão { Data = 12/09 /2020 18:24:47, Temperatura C = 40, Resumo = Quente! }
Suporte aprimorado ao Dictionary<K,V>
JsonSerializer agora oferece suporte a dicionários com chaves não string. Você pode ver como isso se parece no exemplo a seguir. Com o .NET Core 3.0, esse código compila, mas lança uma NotSupportedException.

Suporte aprimorado ao Dictionary<K,V>

Agora dá suporte a chaves não JsonSerializer. Você pode ver como fica no exemplo abaixo. No .NETCore3.0, esse código compila, mas lança NotSupportedException.

Ele produz a seguinte saída.

Ele produz a seguinte saída.

rich@thundera jsondictionarykeys % dotnet run
{“0”:“zero”,“1”:“um”,“2”:“dois”,“3”:“três”,“5”:“cinco”,“8 ”:“oito”,“13”:“treze”,“21”:“vinte e um”,“34”:“trinta e quatro”,“55”:“cinquenta e cinco”} cinquenta e cinco Suporte para campos/对
字段
的
O JsonSerializer agora oferece suporte a campos. Esta mudança foi contribuída por @YohDeadfall. Obrigado!

JsonSerializer agora oferece suporte a campos. Essa alteração foi solicitada por @YohDeadfall. Obrigado!

Você pode ver como isso se parece no exemplo a seguir. Com o .NET Core 3.0, o JsonSerializer falha ao serializar ou desserializar com tipos que usam campos. Este é um problema para tipos existentes que possuem campos e não podem ser alterados. Com essa mudança, isso não é mais um problema.

Você pode ver como fica no exemplo abaixo. Para .NETCore3.0, JsonSerializer não pode serializar ou desserializar com tipos que usam campos. Este é um problema para tipos existentes que possuem campos que não podem ser alterados. Com essa mudança, isso não é mais um problema.

Produz a seguinte saída:

produz a seguinte saída:

rich@thundera jsonserializerfields % dotnet run
9/6/2020 11:31:01 AM
-131Scorching{“date”:“2020-09-06T11:31:01.923395-07:00”,“temperatureC”:-1,“temperatureF ”:31,“summary”:“Scorching”}
Preservando referências em gráficos de objetos JSON/在JSON对象图中保存引用
JsonSerializer adicionou suporte para preservar referências (circulares) em gráficos de objetos JSON. Ele faz isso armazenando IDs que podem ser reconstituídos quando uma string JSON é desserializada de volta para objetos.

JsonSerializer adiciona suporte para preservar referências (cíclicas) em gráficos de objetos JSON. Ele faz isso armazenando IDs que podem ser reconstruídos quando a string JSON é desserializada de volta em um objeto.

Performance/性能
O desempenho do JsonSerializer foi significativamente melhorado no .NET 5.0. Stephen Toub abordou algumas melhorias do JsonSerializer em seu post Performance Improvements in .NET 5. Também abordei o Json Performance com mais detalhes na postagem .NET 5.0 RC1.

O desempenho do JsonSerializer foi significativamente melhorado no .NET5.0. Stephen Toub apresentou algumas melhorias do JsonSerializer em seu artigo .NET5. Também abordei o desempenho do Json com mais detalhes no artigo .NET 5.0RC1.

Implementação de aplicativo/Aplicativo
Após escrever ou atualizar um aplicativo, você precisa implantá-lo para que seus usuários se beneficiem. Isso pode ser para um servidor Web, um serviço de nuvem ou máquina cliente e pode ser o resultado de um fluxo de CI/CD usando um serviço como Azure DevOps ou GitHub Actions.

Depois de escrever ou atualizar um aplicativo, você precisa implantá-lo para beneficiar seus usuários. Isso pode ser o resultado de um servidor Web, serviço de nuvem ou máquina cliente ou um fluxo de CI/CD usando um serviço como Azure DevOps ou GitHub Actions.

Nós nos esforçamos para fornecer recursos de implantação de primeira classe que se alinhem naturalmente com os tipos de aplicativos. Para o .NET 5.0, nos concentramos em melhorar os aplicativos de arquivo único, reduzindo o tamanho do contêiner para compilações de vários estágios do docker e fornecendo melhor suporte para a implantação de aplicativos ClickOnce com .NET Core.

Nós nos esforçamos para fornecer os melhores recursos de implantação que se alinham naturalmente com o tipo de aplicativo. Para o .NET 5.0, nos concentramos em melhorar os aplicativos de arquivo único, reduzindo os tamanhos dos contêineres para compilações de vários estágios do docker e fornecendo melhor suporte para a implantação de aplicativos ClickOnce com .NET Core.

Containers/容器
Consideramos os containers a mais importante tendência de cloud e temos investido bastante nessa modalidade. Estamos investindo em contêineres de várias maneiras, em vários níveis da pilha de software .NET. A primeira é nosso investimento em fundamentos, cada vez mais influenciados pelo cenário de contêineres e por desenvolvedores que implantam aplicativos em contêineres.

Acreditamos que os containers são a tendência mais importante da nuvem e temos investido fortemente nesse modelo. Estamos investindo em contêineres de várias maneiras em vários níveis da pilha de software .NET. A primeira é nosso investimento em fundamentos, cada vez mais influenciados pela cena de contêineres e pelos desenvolvedores que implantam aplicativos em contêineres.

Estamos facilitando o trabalho com orquestradores de contêiner. Adicionamos suporte a OpenTelemetry para que você possa capturar rastreamentos e métricas distribuídas de seu aplicativo. dotnet-monitor é uma nova ferramenta que se destina a ser a principal forma de acessar informações de diagnóstico de um processo .NET. Em particular, começamos a criar uma variante de contêiner do dotnet-monitor que você pode usar como um sidecar do aplicativo. Por último, estamos construindo dotnet/tye como forma de melhorar a produtividade do desenvolvedor de microsserviços, tanto para desenvolvimento quanto para implantação em um ambiente Kubernetes.

Estamos facilitando o trabalho com orquestradores de contêiner. Adicionamos suporte a OpenTelemetry para que você possa capturar rastreamentos e métricas distribuídas de seu aplicativo. dotnetmonitor é uma nova ferramenta principalmente para acessar informações de diagnóstico de processos .NET. Em particular, começamos a criar uma variante de contêiner do dotnetmonitor que você pode usar como um sidecar para seu aplicativo. Por fim, estamos construindo dotnet/tye para melhorar a produtividade do desenvolvedor de microsserviços, incluindo desenvolvimento e implantação em ambientes Kubernetes.

O tempo de execução .NET agora tem suporte para cgroup v2, que esperamos que se torne uma importante API relacionada a contêineres depois de 2020. O Docker atualmente usa cgroup v1 (que já é compatível com .NET). Em comparação, o cgroup v2 é mais simples, mais eficiente e mais seguro que o cgroup v1. Você pode aprender mais sobre os limites de recursos do cgroup e do Docker em nossa atualização do Docker de 2019. As distribuições do Linux e os tempos de execução dos contêineres estão em processo de adição de suporte para o cgroup v2. O .NET 5.0 funcionará corretamente em ambientes cgroup v2 quando eles se tornarem mais comuns. Crédito para Omair Majid, que suporta .NET na Red Hat.

Estamos facilitando o trabalho com orquestradores de contêiner. Adicionamos suporte a OpenTelemetry para que você possa capturar rastreamentos e métricas distribuídas de seu aplicativo. dotnetmonitor é uma nova ferramenta principalmente para acessar informações de diagnóstico de processos .NET. Em particular, começamos a criar uma variante de contêiner do dotnetmonitor que você pode usar como um sidecar para seu aplicativo. Por fim, estamos construindo dotnet/tye para melhorar a produtividade do desenvolvedor de microsserviços, incluindo desenvolvimento e implantação em ambientes Kubernetes.

Agora estamos publicando imagens do Windows Server Core, além do Nano Server. Adicionamos o Server Core porque ouvimos comentários de clientes que queriam uma imagem .NET totalmente compatível com o Windows Server. Se você precisa disso, então esta nova imagem é para você. É compatível com a combinação de: Windows Server 2019 Long-Term Servicing Channel (LTSC), .NET 5.0 e x64. Fizemos outras alterações que reduzem o tamanho das imagens do Windows Server Core. Essas melhorias fazem uma grande diferença, mas foram feitas após o lançamento do Windows Server 2019. Eles irão, no entanto, beneficiar a próxima versão do Windows Server LTSC.

Agora estamos distribuindo imagens principais do Windows Server, exceto para Nano Server. Adicionamos o Server Core porque ouvimos comentários dos clientes de que eles queriam uma imagem .NET totalmente compatível com o Windows Server. Se você precisa, então esta nova imagem é para você. Ele suporta: uma combinação do Windows Server 2019 Long Term Servicing Channel (LTSC), .NET 5.0 e x64. Fizemos outras alterações para reduzir o tamanho da imagem principal do Windows Server. Essas melhorias são bem diferentes, mas foram feitas desde o lançamento do Windows Server 2019. No entanto, eles se beneficiarão da próxima versão do Windows Server LTSC.

Como parte da mudança para “.NET” como o nome do produto, agora estamos publicando imagens .NET Core 2.1, 3.1 e .NET 5.0 na família de repositórios mcr.microsoft.com/dotnet, em vez de mcr.microsoft. com/dotnet/core. Continuaremos a publicação dupla do .NET Core 2.1 e 3.1 no local anterior enquanto houver suporte para essas versões. As imagens .NET 5.0 serão publicadas apenas nos novos locais. Atualize suas instruções e scripts FROM de acordo.

Como parte de trazer .NET para o nome do produto, agora estamos publicando imagens .NET Core 2.1, 3.1 e .NET 5.0 para a família de repo mcr.microsoft.com/dotnet em vez de mcr.microsoft.com/dotnet/core. Continuaremos com o lançamento duplo do .NET Core 2.1 e 3.1 para o local anterior, enquanto damos suporte a essas versões. As imagens NET5.0 serão publicadas apenas no novo local. Atualize sua instrução FROM e script adequadamente.

Como parte do .NET 5.0, rebaseamos a imagem do SDK na parte superior da imagem ASP.NET em vez de buildpack-deps para reduzir drasticamente o tamanho das imagens agregadas que você extrai em cenários de construção de vários estágios.

Essa alteração tem o seguinte benefício para compilações de vários estágios, com um Dockerfile de amostra:

Como parte do .NET 5.0, baseamos nossas imagens SDK em imagens ASP.NET em vez de dependências de buildpack para reduzir significativamente o tamanho de imagens agregadas extraídas em cenários de compilação de vários estágios.

Essa alteração traz os seguintes benefícios para compilações de vários estágios, das quais há um exemplo de Dockerfile:

Custos de compilação em vários estágios com o Ubuntu 20.04 Focal:

Custos de compilação em vários estágios para o Ubuntu 20.04 Focal:

Puxar imagem Antes Depois
sdk:5.0-focal 268 MB 232 MB
aspnet:5.0-focal 64 MB 10 KB (somente manifesto)
Economia líquida de download: 100 MB (-30%)

Economia líquida de download: 100 MB (-30%)

Custos de compilação em vários estágios com o Debian 10 Buster:

Custos de compilação em vários estágios para o Debian 10 Buster:

Puxar imagem Antes Depois
sdk:5.0 280 MB 218 MB
aspnet:5.0 84 MB 4 KB (somente manifesto)
Economia líquida de download: 146 MB (-40%)

Economia líquida de download: 146 MB (-40%)

Consulte dotnet/dotnet-docker nº 1814 para obter informações mais detalhadas.

Essa alteração ajuda compilações de vários estágios, em que o sdk e o aspnet ou a imagem de tempo de execução que você está direcionando são a mesma versão (esperamos que esse seja o caso comum). Com essa mudança, o pull aspnet (por exemplo), será um no-op, porque você terá puxado as camadas aspnet por meio do pull sdk inicial.

Consulte dotnet/dotnet-docker#1814 para obter detalhes.

Essa alteração facilita compilações de vários estágios em que SDK e ASPNET ou imagens de tempo de execução estão na mesma versão (esperamos que esse seja o caso comum). Com essa alteração, o pull aspnet (por exemplo) se torna um no-op, pois você estará puxando a camada aspnet por meio do pull sdk inicial.

Fizemos alterações semelhantes para Alpine e Nano Server. Não há imagem buildpack-deps para Alpine ou Nano Server. No entanto, as imagens sdk para Alpine e Nano Server não foram construídas anteriormente sobre a imagem ASP.NET. Nós consertamos isso. Você verá vitórias de tamanho significativas para Alpine e Nano Server, bem como com 5.0, para compilações de vários estágios.

Fizemos alterações semelhantes nos servidores Alpine e Nano. Não há imagens de buildpack deps para servidores Alpine ou Nano. No entanto, as imagens sdk para servidores Alpine e Nano não foram construídas anteriormente sobre a imagem NET.ASP. Nós consertamos. Você verá vitórias em grande escala para servidores Alpine e Nano e compilações de vários estágios 5.0.

Aplicativos de arquivo único/单文件应用程序
Aplicativos de arquivo único são publicados e implementados como um único arquivo. O aplicativo e suas dependências estão todos incluídos nesse arquivo. Quando o aplicativo é executado, as dependências são carregadas diretamente desse arquivo na memória (sem penalidade de desempenho).

Aplicativos de arquivo único são publicados e implantados como um único arquivo. O aplicativo e suas dependências estão incluídos neste arquivo. Quando o aplicativo é executado, as dependências são carregadas diretamente desse arquivo na memória (sem penalidade de desempenho).

No .NET 5.0, os aplicativos de arquivo único são focados principalmente no Linux (falaremos mais sobre isso posteriormente). Eles podem ser dependentes da estrutura ou independentes. Aplicativos de arquivo único dependentes de estrutura podem ser muito pequenos, dependendo de um tempo de execução .NET instalado globalmente. Aplicativos de arquivo único independentes são maiores (devido ao tempo de execução), mas não requerem a instalação do tempo de execução .NET como uma pré-etapa de instalação e funcionarão apenas como resultado. Em geral, o dependente de estrutura é bom para ambientes corporativos e de desenvolvimento, enquanto o autocontido costuma ser uma escolha melhor para ISVs.

No .NET 5.0, os aplicativos de arquivo único concentram-se principalmente no Linux (mais sobre isso posteriormente). Eles podem ser dependentes da estrutura ou independentes. Aplicativos de arquivo único dependentes de estrutura podem ser muito pequenos, contando com o tempo de execução .NET instalado globalmente. Aplicativos de arquivo único autocontidos são maiores (devido ao tempo de execução), mas não exigem que o tempo de execução .NET seja instalado como uma etapa de pré-instalação; portanto, funcionarão. Em geral, o desenvolvimento dependente de estrutura e os ambientes corporativos são adequados, enquanto o autocontido geralmente é uma escolha melhor para ISVs.

Produzimos uma versão de aplicativos de arquivo único com .NET Core 3.1. Ele empacota binários em um único arquivo para implantação e, em seguida, descompacta esses arquivos em um diretório temporário para carregá-los e executá-los. Pode haver alguns cenários em que essa abordagem seja melhor, mas esperamos que a solução que construímos para 5.0 seja a preferida e uma melhoria bem-vinda.

Fizemos uma versão de aplicativo de arquivo único com .NETCore3.1. Ele empacota binários em um arquivo para implantação e, em seguida, descompacta esses arquivos em um diretório temporário para carregá-los e executá-los. Essa abordagem pode ser melhor em alguns casos, mas esperamos que a solução que construímos para 5.0 seja preferida e uma melhoria bem-vinda.

Tínhamos vários obstáculos a superar para criar uma verdadeira solução de arquivo único. As principais tarefas eram criar um empacotador de aplicativos mais sofisticado e ensinar o tempo de execução a carregar assemblies a partir de recursos binários. Também nos deparamos com alguns obstáculos que não conseguimos superar.

Para criar uma verdadeira solução de arquivo único, precisamos superar vários obstáculos. A principal tarefa é criar um fichário de aplicativo mais complexo e ensinar o tempo de execução a carregar assemblies de recursos binários. Também encontramos alguns obstáculos que não conseguimos superar.

Em todas as plataformas, temos um componente chamado “apphost”. Este é o arquivo que se torna seu executável, por exemplo myapp.exe no Windows ou ./myapp em plataformas baseadas em Unix. Para aplicativos de arquivo único, criamos um novo apphost que chamamos de “superhost”. Ele tem a mesma função que o apphost regular, mas também inclui uma cópia vinculada estaticamente do tempo de execução. O superhost é um ponto de design fundamental da nossa abordagem de arquivo único. Este modelo é o que usamos no Linux com .NET 5.0. Não conseguimos implementar essa abordagem no Windows ou no macOS devido a várias restrições do sistema operacional. Não temos um superhost no Windows ou macOS. Nesses sistemas operacionais, os binários de tempo de execução nativos (cerca de 3 deles) ficam ao lado do aplicativo de arquivo único (resultando em “arquivo não único”). Revisitaremos essa situação no .NET 6.0, no entanto,

Em todas as plataformas temos um componente chamado "apphost". Por exemplo, isso se torna o arquivo executável myapp.exe no Windows ou ./myapp em plataformas baseadas em Unix. Para aplicativos de arquivo único, criamos um novo host de aplicativo, que chamamos de "superhost". Ele tem a mesma função de um apphost regular, mas também inclui uma cópia vinculada estaticamente do tempo de execução. O superhost é um ponto de design fundamental da nossa abordagem de arquivo único. Este modelo é o .NET5.0 que usamos no Linux. Devido a limitações de vários sistemas operacionais, não podemos implementar esse método no Windows ou macOS. Não temos um superhost no Windows ou macOS. Nesses sistemas operacionais, os binários de tempo de execução nativos (cerca de 3 deles) ficam ao lado de aplicativos de arquivo único (o resultado é "não é um único arquivo"). Estaremos revisitando esta situação no .NET 6.0, no entanto, esperamos que os problemas que encontramos continuem desafiadores.

Você pode usar os seguintes comandos para produzir aplicativos de arquivo único.

Você pode gerar um aplicativo de arquivo único com o seguinte comando.

Aplicativo de arquivo único dependente de estrutura:

dotnet publish -r linux-x64 --self-contained false /p:PublishSingleFile=true

Aplicativo de arquivo único independente:

dotnet publish -r linux-x64 --self-contained true /p:PublishSingleFile=true

Você também pode configurar a publicação de arquivo único com um arquivo de projeto.

A publicação de arquivo único também pode ser configurada usando arquivos de projeto.

Exe net5.0 linux-x64 true true Você pode experimentar o corte de montagem para reduzir o tamanho de seu aplicativo. Ele pode interromper os aplicativos, cortando demais, por isso é recomendável testar seu aplicativo completamente depois de usar esse recurso. O corte de assembly também remove o código nativo de leitura para execução compilado antecipadamente (para os assemblies que são cortados), que está lá principalmente para desempenho. Você vai querer testar o desempenho de seu aplicativo após o corte. Você pode compilar seu aplicativo pronto para executar após o corte usando a propriedade PublishReadyToRun (e definindo como true).

Você pode tentar usar a remoção de widget para reduzir o tamanho do seu aplicativo. Ele pode interromper os aplicativos por meio de podas excessivas, portanto, é recomendável testar seu aplicativo completamente após usar esse recurso. A remoção de assembly também remove as leituras compiladas antes do tempo para executar o código nativo (para assemblies removidos), principalmente para melhorar o desempenho. Você desejará testar o desempenho de seu aplicativo após a remoção. Você pode usar a propriedade PublishReadyToRun (e definir como true) para executar o aplicativo compilado após o corte.

Notas:

Os aplicativos são específicos do sistema operacional e da arquitetura. Você precisa publicar para cada configuração (Linux x64, Linux Arm64, Windows x64, …).

Arquivos de configuração (como *.runtimeconfig.json) estão incluídos em um único arquivo. Você pode colocar um arquivo de configuração adicional ao lado do arquivo único, se necessário (possivelmente para teste).

Os arquivos .pdb não são incluídos no arquivo único por padrão. Você pode habilitar a incorporação de PDB com a propriedade embed.

A propriedade IncludeNativeLibrariesForSelfExtract pode ser usada para incorporar binários de tempo de execução nativos, no Windows e macOS, no entanto, eles devem ser descompactados para armazenamento temporário em tempo de execução. Este recurso não é recomendado para uso geral.

notas:

Os aplicativos são específicos do sistema operacional e da arquitetura. Você precisa publicar para cada configuração (Linux x64, Linux Arm64, Windows x64...).

arquivo de configuração (como *). runtimeconfig.json) contido em um único arquivo. Um arquivo de configuração adicional pode ser colocado ao lado dos arquivos individuais, se desejado (talvez para teste).

Por padrão, nenhum arquivo .pdb é incluído nos arquivos individuais. A incorporação de PDB pode ser habilitada usando a propriedade embed.

O atributo IncludeNativeLibrariesForSelfExtract pode ser usado para incorporar binários de tempo de execução nativos no Windows e macOS, no entanto, eles devem ser extraídos para armazenamento temporário em tempo de execução. Geralmente não é recomendado usar esse recurso.

ClickOnce/一次点击
ClickOnce tem sido uma opção popular de implantação de .NET por muitos anos. Agora é compatível com aplicativos .NET Core 3.1 e .NET 5.0 do Windows. Sabíamos que muitas pessoas iriam querer usar o ClickOnce para implantação de aplicativos quando adicionamos Windows Forms e suporte WPF ao .NET Core 3.0. No ano passado, as equipes .NET e Visual Studio trabalharam juntas para habilitar a publicação ClickOnce, tanto na linha de comando quanto no Visual Studio.

ClickOnce tem sido uma opção popular de implantação de .NET por muitos anos. Agora é compatível com os aplicativos .NET Core 3.1 e .NET 5.0 do Windows. Sabemos que quando adicionamos Windows Forms e suporte WPF ao .NET Core 3.0, muitas pessoas queriam usar o ClickOnce para implantação de aplicativos. No ano passado, as equipes .NET e Visual Studio trabalharam juntas para permitir a publicação ClickOnce na linha de comando e no Visual Studio.

Tínhamos dois objetivos desde o início do projeto:

Iniciamos o projeto com dois objetivos:

Habilite uma experiência familiar para ClickOnce no Visual Studio.

Habilite um CI/CD moderno para publicação ClickOnce com fluxos de linha de comando, com o MSBuild ou a ferramenta Mage.

É mais fácil mostrar a experiência em fotos.

A maneira mais fácil de fazer isso é usar fotos para mostrar sua experiência.

Vamos começar com a experiência do Visual Studio, centrada na publicação do projeto.

Vamos começar com a experiência do Visual Studio, que se concentra na publicação do projeto.

O principal modelo de implantação ao qual oferecemos suporte atualmente são os aplicativos dependentes de estrutura. É fácil ter uma dependência do .NET Desktop Runtime (que é o que contém WPF e Windows Forms). O instalador do ClickOnce instalará o tempo de execução .NET nas máquinas dos usuários, se necessário. Também pretendemos dar suporte a aplicativos independentes e de arquivo único.

O principal modelo de implantação ao qual oferecemos suporte atualmente são os aplicativos dependentes de estrutura. Contar com o tempo de execução da área de trabalho .NET (que inclui os tempos de execução WPF e Windows Forms) é fácil. O instalador do ClickOnce instalará o tempo de execução .NET no computador do usuário, se necessário. Também pretendemos oferecer suporte a aplicativos independentes e de arquivo único.

Você pode se perguntar se ainda pode aproveitar os recursos off-line e de atualização do ClickOnce. Sim você pode.

Você pode estar se perguntando se ainda poderá aproveitar as vantagens do recurso ClickOnce Offline and Update. Sim você pode.

A grande mudança com o Mage é que agora é uma ferramenta .NET, distribuída no NuGet. Isso significa que você não precisa instalar nada especial em sua máquina. Você só precisa do .NET 5.0 SDK e então pode instalar o Mage como uma ferramenta .NET. Você também pode usá-lo para publicar aplicativos .NET Framework, no entanto, a assinatura SHA1 e o suporte de confiança parcial foram removidos.

A maior mudança no Mage é que ele agora é uma ferramenta .NET, distribuída no NuGet. Isso significa que você não precisa instalar nada especial em sua máquina. Você só precisa do .NET5.0SDK, então você pode instalar o Mage como uma ferramenta .NET. Você também pode usá-lo para publicar aplicativos .NET Framework, no entanto, a assinatura SHA1 e o suporte de confiança parcial foram removidos.

O comando de instalação do Mage segue:

Os comandos de instalação do Mage são os seguintes:

dotnet tool install -g Microsoft.DotNet.Mage
Depois de produzir e distribuir o instalador do ClickOnce, seus usuários verão as caixas de diálogo de instalação conhecidas do ClickOnce.

Depois de criar e distribuir um instalador do ClickOnce, os usuários verão o familiar diálogo de instalação do ClickOnce.

Seus usuários verão a caixa de diálogo de atualização quando você disponibilizar as atualizações.

Quando você disponibiliza uma atualização, seus usuários verão a caixa de diálogo de atualização.

Fechar
o .NET 5.0 é outro grande lançamento que deve melhorar muitos aspectos do seu uso com o .NET. Habilitamos um amplo conjunto de melhorias, desde aplicativos de arquivo único até desempenho, usabilidade de serialização Json e habilitação de Arm64. Embora hoje seja seu primeiro dia com o .NET 5.0, estamos executando o .NET 5.0 em produção na Microsoft há meses. Temos certeza de que ele está pronto para você usar, administrar seus negócios e potencializar seus aplicativos. As novas melhorias de linguagem em C# 9 e F# 5 devem tornar seu código mais expressivo e fácil de escrever. O .NET 5.0 também é uma ótima opção para seus aplicativos existentes. Em muitos casos, você pode atualizar sem muito esforço.

Se você está interessado em desempenho, pode estar interessado em nosso progresso com os benchmarks TechEmpower. Olhando para trás, você pode ver que o .NET Core 3.1 está indo muito bem na rodada 19, a última rodada. Estamos ansiosos para ver o .NET 5.0 na próxima rodada 20. A nova classificação será algo a ser observado quando a rodada 20 for finalizada e publicada.

As melhorias no .NET 5.0 são o resultado dos esforços de muitas pessoas, trabalhando de forma colaborativa em todo o mundo e em muitos fusos horários, no GitHub. Obrigado a todos que contribuíram para este lançamento. E não se preocupe, há muitas oportunidades para contribuir. A versão .NET 5.0 chegou ao fim, mas a próxima versão já começou.

O .NET 5.0 é outro grande lançamento que melhora muitas das coisas que você faz com o .NET. Implementamos uma ampla gama de melhorias, desde aplicativos de arquivo único até desempenho, desde disponibilidade de serialização Json até ativação de Arm64. Embora hoje seja seu primeiro dia com o .NET 5.0, estamos executando o .NET 5.0 em produção na Microsoft há vários meses. Temos certeza de que ele está pronto para você usar, administrar seus negócios e capacitar seus aplicativos. Novas melhorias de linguagem em C#9 e F#5 devem tornar seu código mais expressivo e fácil de escrever. NET 5.0 também é uma ótima opção para seus aplicativos existentes. Em muitos casos, você pode atualizar sem suar a camisa.

Se você estiver interessado em desempenho, talvez esteja interessado em saber como funcionam nossos benchmarks TechEmpower. Olhando para trás, você verá que o .NET Core 3.1 fez um bom trabalho com a última rodada, a rodada 19. Estamos ansiosos para ver o .NET 5.0 na próxima rodada 20. As novas classificações serão dignas de nota quando a Rodada 20 for finalizada e anunciada.

NET 5.0 são o resultado dos esforços de muitas pessoas, em todo o mundo e em muitos fusos horários, trabalhando juntas no GitHub. Obrigado a todos que contribuíram para este lançamento. Não se preocupe, há muitas oportunidades para contribuir. A versão .NET5.0 está quase concluída, mas a próxima versão já começou.

Autor: Ricardo

Traduzido por: Liu Haixin