Novidades no .NET Core 2.2

O .NET Core 2.2 inclui aprimoramentos na implantação de aplicativos, manipulação de eventos para serviços de runtime, autenticação para bancos de dados SQL do Azure, desempenho do compilador JIT e injeção de código antes da execução do Main método.

Novo modo de implantação

A partir do .NET Core 2.2, você pode implantar executáveis dependentes da estrutura, que são arquivos.exe em vez de arquivos.dll . Funcionalmente semelhante às implantações dependentes da estrutura, os executáveis dependentes da estrutura (FDE) ainda dependem da presença de uma versão compartilhada em todo o sistema do .NET Core para execução. Seu aplicativo contém apenas seu código e quaisquer dependências de terceiros. Ao contrário das implantações dependentes da estrutura, os FDEs são específicos da plataforma.

Esse novo modo de implantação tem a vantagem distinta de criar um executável em vez de uma biblioteca, o que significa que você pode executar seu aplicativo diretamente sem invocar dotnet primeiro.

Núcleo

Manipulando eventos em serviços de runtime

Geralmente, você pode querer monitorar o uso de serviços de runtime do aplicativo, como o GC, o JIT e o ThreadPool, para entender como eles afetam seu aplicativo. Em sistemas Windows, isso geralmente é feito monitorando os eventos ETW do processo atual. Embora isso continue funcionando bem, nem sempre é possível usar o ETW se você estiver executando em um ambiente de baixo privilégio ou no Linux ou macOS.

A partir do .NET Core 2.2, os eventos CoreCLR agora podem ser consumidos usando a System.Diagnostics.Tracing.EventListener classe. Esses eventos descrevem o comportamento de serviços de runtime como GC, JIT, ThreadPool e interoperabilidade. Esses são os mesmos eventos são expostos como parte do provedor ETW CoreCLR.  Isso permite que os aplicativos consumam esses eventos ou usem um mecanismo de transporte para enviá-los a um serviço de agregação de telemetria. Você pode ver como assinar eventos no seguinte exemplo de código:

internal sealed class SimpleEventListener : EventListener
{
    // Called whenever an EventSource is created.
    protected override void OnEventSourceCreated(EventSource eventSource)
    {
        // Watch for the .NET runtime EventSource and enable all of its events.
        if (eventSource.Name.Equals("Microsoft-Windows-DotNETRuntime"))
        {
            EnableEvents(eventSource, EventLevel.Verbose, (EventKeywords)(-1));
        }
    }

    // Called whenever an event is written.
    protected override void OnEventWritten(EventWrittenEventArgs eventData)
    {
        // Write the contents of the event to the console.
        Console.WriteLine($"ThreadID = {eventData.OSThreadId} ID = {eventData.EventId} Name = {eventData.EventName}");
        for (int i = 0; i < eventData.Payload.Count; i++)
        {
            string payloadString = eventData.Payload[i]?.ToString() ?? string.Empty;
            Console.WriteLine($"\tName = \"{eventData.PayloadNames[i]}\" Value = \"{payloadString}\"");
        }
        Console.WriteLine("\n");
    }
}

Além disso, o .NET Core 2.2 adiciona as seguintes duas propriedades à classe EventWrittenEventArgs para fornecer informações adicionais sobre eventos ETW:

Dados

Autenticação do AAD para bancos de dados SQL do Azure com a propriedade SqlConnection.AccessToken

A partir do .NET Core 2.2, um token de acesso emitido pelo Azure Active Directory pode ser usado para autenticar em um banco de dados SQL do Azure. Para dar suporte a tokens de acesso, a AccessToken propriedade foi adicionada à SqlConnection classe. Para aproveitar a autenticação do AAD, baixe a versão 4.6 do pacote NuGet System.Data.SqlClient. Para usar o recurso, você pode obter o valor do token de acesso usando a Biblioteca de Autenticação do Active Directory para .NET contida no Microsoft.IdentityModel.Clients.ActiveDirectory pacote NuGet.

Melhorias do compilador JIT

A compilação em camadas continua sendo um recurso de aceitação

No .NET Core 2.1, o compilador JIT implementou uma nova tecnologia de compilador, compilação em camadas, como um recurso de aceitação. A meta da compilação em camadas é melhorar o desempenho. Uma das tarefas importantes executadas pelo compilador JIT é otimizar a execução de código. ** No entanto, para caminhos de código pouco usados, o compilador pode gastar mais tempo otimizando o código do que o tempo de execução gasta executando código não otimizado. A compilação em camadas apresenta dois estágios na compilação JIT:

  • Uma primeira camada, que gera o código o mais rápido possível.
  • Uma segunda camada, que gera código otimizado para os métodos executados com frequência. A segunda camada de compilação é executada em paralelo para melhorar o desempenho.

Para obter informações sobre a melhoria de desempenho que pode resultar da compilação em camadas, consulte Anúncio do .NET Core 2.2 Versão Prévia 2.

Para obter informações sobre como aceitar a compilação em camadas, consulte as melhorias do compilador Jit no What's new no .NET Core 2.1.

Tempo de execução

Injetando código antes de executar o método Main

A partir do .NET Core 2.2, você pode usar um gancho de inicialização para injetar código antes de executar o método Main de um aplicativo. Os ganchos de inicialização possibilitam que um host personalize o comportamento dos aplicativos depois que eles tiverem sido implantados sem a necessidade de recompilar ou alterar o aplicativo.

Esperamos que os provedores de hospedagem definam a configuração e a política personalizada, incluindo configurações que potencialmente influenciam o comportamento de carga do ponto de entrada principal, como o comportamento de System.Runtime.Loader.AssemblyLoadContext. O gancho pode ser usado para configurar a injeção de rastreamento ou de telemetria, para configurar os retornos de chamada para tratamento ou para definir outro comportamento dependente do ambiente. O gancho é separado do ponto de entrada, para que o código do usuário não precise ser modificado.

Consulte o gancho de inicialização do host para obter mais informações.

Consulte também

  • Last updated on