Partager via

Nouveautés de .NET Core 2.2

.NET Core 2.2 inclut des améliorations dans le déploiement d’applications, la gestion des événements pour les services d’exécution, l’authentification auprès des bases de données Azure SQL, les performances du compilateur JIT et l’injection de code avant l’exécution de la Main méthode.

Nouveau mode de déploiement

À compter de .NET Core 2.2, vous pouvez déployer des exécutables dépendants du framework, qui sont .exe fichiers au lieu de .dll fichiers. Comme les déploiements dépendants du framework, les exécutables dépendants du framework dépendent toujours de la présence d’une version de .NET Core partagée à l’échelle du système pour s’exécuter. Votre application contient uniquement votre code et toutes les dépendances tierces. Contrairement aux déploiements dépendants de l’infrastructure, les FDE sont spécifiques à la plateforme.

Ce nouveau mode de déploiement présente l’avantage distinct de créer un exécutable au lieu d’une bibliothèque, ce qui signifie que vous pouvez exécuter votre application directement sans avoir à invoquer dotnet au préalable.

Cœur

Gestion des événements dans les services d’exécution

Vous pouvez souvent surveiller l’utilisation des services d’exécution de votre application, tels que gc, JIT et ThreadPool, pour comprendre comment elles ont un impact sur votre application. Sur les systèmes Windows, cela est généralement effectué en surveillant les événements ETW du processus actuel. Bien que cela continue de fonctionner correctement, il n’est pas toujours possible d’utiliser ETW si vous exécutez dans un environnement à faible privilège ou sur Linux ou macOS.

À compter de .NET Core 2.2, les événements CoreCLR peuvent désormais être consommés à l’aide de la System.Diagnostics.Tracing.EventListener classe. Ces événements décrivent le comportement de ces services d’exécution tels que GC, JIT, ThreadPool et interopérabilité. Il s’agit des mêmes événements qui sont exposés dans le cadre du fournisseur ETW CoreCLR.  Cela permet aux applications de consommer ces événements ou d’utiliser un mécanisme de transport pour les envoyer à un service d’agrégation de télémétrie. Vous pouvez voir comment vous abonner à des événements dans l’exemple de code suivant :

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");
    }
}

De plus, .NET Core 2.2 ajoute les deux propriétés suivantes à la EventWrittenEventArgs classe pour fournir des informations supplémentaires sur les événements ETW :

Données

Authentification AAD auprès des bases de données Azure SQL avec la propriété SqlConnection.AccessToken

À compter de .NET Core 2.2, un jeton d’accès émis par Azure Active Directory peut être utilisé pour s’authentifier auprès d’une base de données Azure SQL. Pour prendre en charge les jetons d’accès, la AccessToken propriété a été ajoutée à la SqlConnection classe. Pour tirer parti de l’authentification AAD, téléchargez la version 4.6 du package NuGet System.Data.SqlClient. Pour utiliser la fonctionnalité, vous pouvez obtenir la valeur du jeton d’accès à l’aide de la bibliothèque d’authentification Active Directory pour .NET contenue dans le Microsoft.IdentityModel.Clients.ActiveDirectory package NuGet.

Améliorations apportées au compilateur JIT

La compilation hiérarchisée reste une fonctionnalité à activation volontaire

Dans .NET Core 2.1, le compilateur JIT a implémenté une nouvelle technologie de compilateur, la compilation hiérarchisée, en tant que fonctionnalité optionnelle. L’objectif de la compilation hiérarchisée est d’améliorer les performances. L’une des tâches importantes effectuées par le compilateur JIT optimise l’exécution du code. Toutefois, pour les chemins de code peu utilisés, le compilateur peut passer plus de temps à optimiser le code que le runtime passe à exécuter du code non optimisé. La compilation hiérarchisée introduit deux étapes dans la compilation JIT :

  • Un premier niveau, qui génère le code le plus rapidement possible.
  • Un deuxième niveau, qui génère du code optimisé pour ces méthodes qui sont exécutées fréquemment. Le deuxième niveau de compilation est effectué en parallèle pour améliorer les performances.

Pour plus d’informations sur l’amélioration des performances qui peut résulter de la compilation hiérarchisé, consultez Annonce de .NET Core 2.2 Preview 2.

Pour plus d’informations sur l’inscription à la compilation hiérarchisé, consultez les améliorations apportées au compilateur Jitdans What’s new in .NET Core 2.1.

Temps d'exécution

Injection de code avant l’exécution de la méthode Main

À compter de .NET Core 2.2, vous pouvez utiliser un hook de démarrage pour injecter du code avant d’exécuter la méthode Main d’une application. Les hooks de démarrage permettent à un hôte de personnaliser le comportement des applications après leur déploiement sans avoir à recompiler ou à modifier l’application.

Nous nous attendons à ce que les fournisseurs d'hébergement définissent une configuration et une stratégie personnalisées, y compris les paramètres susceptibles d'influencer le comportement de charge du point d'entrée principal, tel que le comportement du System.Runtime.Loader.AssemblyLoadContext. Le hook peut être utilisé pour configurer l’injection de suivi ou de télémétrie, pour configurer des rappels pour la gestion ou pour définir d’autres comportements dépendants de l’environnement. Le hook est séparé du point d’entrée, de sorte que le code utilisateur n’a pas besoin d’être modifié.

Pour plus d’informations, voir Hook de démarrage hôte.

Voir aussi