Nouveautés de .NET Core 3.0What's new in .NET Core 3.0

Cet article décrit les nouveautés de .NET Core 3.0.This article describes what is new in .NET Core 3.0. Une des principales améliorations est la prise en charge des applications de bureau Windows (Windows uniquement).One of the biggest enhancements is support for Windows desktop applications (Windows only). En utilisant le composant du SDK .NET Core 3.0 Windows Desktop, vous pouvez porter vos applications Windows Forms et Windows Presentation Foundation (WPF).By using the .NET Core 3.0 SDK component Windows Desktop, you can port your Windows Forms and Windows Presentation Foundation (WPF) applications. Pour être clair, le composant Windows Desktop est pris en charge et inclus seulement sur Windows.To be clear, the Windows Desktop component is only supported and included on Windows. Pour plus d’informations, consultez la section Bureau Windows plus loin dans cet article.For more information, see the Windows desktop section later in this article.

.NET Core 3.0 prend en charge C# 8.0..NET Core 3.0 adds support for C# 8.0. Il est fortement recommandé d’utiliser Visual Studio 2019 version 16,3 ou ultérieure, Visual Studio pour Mac 8,3 ou version ultérieure, ou Visual Studio code avec l' C# extensionla plus récente.It's highly recommended that you use Visual Studio 2019 version 16.3 or newer, Visual Studio for Mac 8.3 or newer, or Visual Studio Code with the latest C# extension.

Téléchargez et commencez à utiliser .NET Core 3.0 pour le moment sur Windows, MacOS ou Linux.Download and get started with .NET Core 3.0 right now on Windows, macOS, or Linux.

Pour plus d’informations sur la version, consultez l' annonce de .NET Core 3.0.For more information about the release, see the .NET Core 3.0 announcement.

.NET Core RC1 a été considéré comme une production prête par Microsoft et a été entièrement pris en charge..NET Core RC1 was considered production ready by Microsoft and was fully supported. Si vous utilisez une version préliminaire, vous devez passer à la version RTM pour une prise en charge continue.If you're using a preview release, you must move to the RTM version for continued support.

Améliorations C# du langage 8,0Language improvements C# 8.0

C#8,0 fait également partie de cette version, qui comprend la fonctionnalité de types de référence Nullable , les flux asynchroneset plus de modèles.C# 8.0 is also part of this release, which includes the nullable reference types feature, async streams, and more patterns. Pour plus d’informations sur les fonctionnalités de C# 8.0, consultez Nouveautés de C# 8.0.For more information about C# 8.0 features, see What's new in C# 8.0.

Des améliorations ont été apportées au langage pour prendre en charge les fonctionnalités d’API suivantes, détaillées ci-dessous :Language enhancements were added to support the following API features detailed below:

.NET Standard 2.1.NET Standard 2.1

.NET Core 3,0 implémente .NET Standard 2,1..NET Core 3.0 implements .NET Standard 2.1. Toutefois, le modèle de dotnet new classlib par défaut génère un projet qui cible toujours .NET Standard 2,0.However, the default dotnet new classlib template generates a project that still targets .NET Standard 2.0. Pour cibler .NET Standard 2.1, modifiez votre fichier projet et définissez la propriété TargetFramework sur netstandard2.1 :To target .NET Standard 2.1, edit your project file and change the TargetFramework property to netstandard2.1:

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

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

</Project>

Si vous utilisez Visual Studio, vous avez besoin de Visual Studio 2019, car Visual Studio 2017 ne prend pas en charge .NET Standard 2.1 ou .NET Core 3.0.If you're using Visual Studio, you need Visual Studio 2019, as Visual Studio 2017 doesn't support .NET Standard 2.1 or .NET Core 3.0.

Compiler/déployerCompile/Deploy

Exécutables par défautDefault executables

.NET Core génère désormais des exécutables dépendant du framework par défaut..NET Core now builds framework-dependent executables by default. Ce comportement est nouveau pour les applications qui utilisent une version .NET Core installée de façon globale.This behavior is new for applications that use a globally installed version of .NET Core. Auparavant, seuls les déploiements autonomes produisaient un exécutable.Previously, only self-contained deployments would produce an executable.

Lors de l’étape dotnet build ou dotnet publish, un exécutable est créé, qui correspond à l’environnement et à la plateforme du Kit de développement que vous utilisez.During dotnet build or dotnet publish, an executable is created that matches the environment and platform of the SDK you're using. Vous pouvez obtenir le même résultat avec ces exécutables, comme vous le feriez avec d’autres exécutables natifs comme :You can expect the same things with these executables as you would other native executables, such as:

  • Vous pouvez double-cliquer sur l’exécutable.You can double-click on the executable.
  • Vous pouvez lancer l’application directement à partir d’une invite de commandes, par exemple myapp.exe sous Windows, et ./myapp sous Linux et macOS.You can launch the application from a command prompt directly, such as myapp.exe on Windows, and ./myapp on Linux and macOS.

Exécutable monofichierSingle-file executables

La commande dotnet publish prend en charge l’empaquetage de votre application dans un exécutable monofichier spécifique de la plateforme.The dotnet publish command supports packaging your app into a platform-specific single-file executable. L’exécutable est auto-extractible et contient toutes les dépendances (y compris natives) nécessaires à l’exécution de votre application.The executable is self-extracting and contains all dependencies (including native) that are required to run your app. Lors de la première exécution de l’application, celle-ci est extraite d’un répertoire basé sur le nom de l’application et l’identificateur de la build.When the app is first run, the application is extracted to a directory based on the app name and build identifier. Le démarrage est plus rapide quand l’application est réexécutée.Startup is faster when the application is run again. L’application n’a pas besoin de s’extraire elle-même une deuxième fois, sauf si une nouvelle version a été utilisée.The application doesn't need to extract itself a second time unless a new version was used.

Pour publier un exécutable monofichier, définissez PublishSingleFile dans votre projet ou sur la ligne de commande avec la commande dotnet publish :To publish a single-file executable, set the PublishSingleFile in your project or on the command line with the dotnet publish command:

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

- ou --or-

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

Pour plus d’informations sur la publication monofichier, consultez le document conceptuel sur l’outil de regroupement monofichier.For more information about single-file publishing, see the single-file bundler design document.

Liaison d’assemblysAssembly linking

Le SDK .NET Core 3.0 est fourni avec un outil qui peut réduire la taille des applications en analysant le langage intermédiaire et en supprimant les assemblys inutilisés.The .NET core 3.0 SDK comes with a tool that can reduce the size of apps by analyzing IL and trimming unused assemblies.

Les applications autonomes incluent tous les éléments nécessaires pour exécuter votre code, sans nécessiter que .NET soit installé sur la machine hôte.Self-contained apps include everything needed to run your code, without requiring .NET to be installed on the host computer. Toutefois, il arrive souvent que l’application nécessite seulement un petit sous-ensemble de l’infrastructure pour fonctionner, et que les autres bibliothèques inutilisées puissent être supprimées.However, many times the app only requires a small subset of the framework to function, and other unused libraries could be removed.

.NET Core inclut désormais un paramètre qui utilisera l’outil Éditeur de liens de langage intermédiaire analyser le langage intermédiaire de votre application..NET Core now includes a setting that will use the IL linker tool to scan the IL of your app. Cet outil détecte le code requis, puis supprime les bibliothèques inutilisées.This tool detects what code is required, and then trims unused libraries. Cet outil peut réduire considérablement la taille de déploiement de certaines applications.This tool can significantly reduce the deployment size of some apps.

Pour activer cet outil, ajoutez le paramètre <PublishTrimmed> dans votre projet et publiez une application autonome :To enable this tool, add the <PublishTrimmed> setting in your project and publish a self-contained app:

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

Par exemple, le nouveau modèle de projet de console de base « hello world » inclus, lors de sa publication, atteint la taille d’environ 70 Mo.As an example, the basic "hello world" new console project template that is included, when published, hits about 70 MB in size. Avec <PublishTrimmed>, sa taille est réduite à environ 30 Mo.By using <PublishTrimmed>, that size is reduced to about 30 MB.

Il est important de prendre en compte le fait que les applications ou infrastructures (dont ASP.NET Core et WPF) qui utilisent la réflexion ou des fonctionnalités dynamiques associées cesseront souvent de fonctionner après cette troncature.It's important to consider that applications or frameworks (including ASP.NET Core and WPF) that use reflection or related dynamic features, will often break when trimmed. Cette rupture se produit car l’éditeur de liens ne connaît pas ce comportement dynamique et ne peut pas déterminer les types de framework nécessaires pour la réflexion.This breakage occurs because the linker doesn't know about this dynamic behavior and can't determine which framework types are required for reflection. L’outil d’éditeur de liens de langage intermédiaire peut être configuré pour être conscient de ce scénario.The IL Linker tool can be configured to be aware of this scenario.

Avant toute chose, veillez à tester votre application après réduction.Above all else, be sure to test your app after trimming.

Pour plus d’informations sur l’outil d’éditeur de liens de langage intermédiaire, consultez la documentation ou visitez le référentiel mono/linker.For more information about the IL Linker tool, see the documentation or visit the mono/linker repo.

Compilation hiérarchiséeTiered compilation

La compilation hiérarchisée est activée par défaut avec .NET Core 3.0.Tiered compilation (TC) is on by default with .NET Core 3.0. Cette fonctionnalité permet au runtime d’utiliser plus de manière adaptative le compilateur juste-à-temps (JIT) pour obtenir de meilleures performances.This feature enables the runtime to more adaptively use the just-in-time (JIT) compiler to achieve better performance.

Le principal avantage de la compilation à plusieurs niveaux est de fournir deux méthodes de jitting : dans un niveau de qualité inférieure mais plus rapide ou un niveau de qualité supérieure, mais plus faible.The main benefit of tiered compilation is to provide two ways of jitting methods: in a lower-quality-but-faster tier or a higher-quality-but-slower tier. La qualité fait référence à la manière dont la méthode est optimisée.The quality refers to how well the method is optimized. TC permet d’améliorer les performances d’une application à mesure qu’elle passe par différentes étapes d’exécution, du démarrage à l’état stable.TC helps to improve the performance of an application as it goes through various stages of execution, from startup through steady state. Lorsque la compilation à plusieurs niveaux est désactivée, chaque méthode est compilée d’une manière unique, avec des performances d’état stable sur les performances de démarrage.When tiered compilation is disabled, every method is compiled in a single way that's biased to steady-state performance over startup performance.

Lorsque TC est activé, le comportement suivant s’applique à la compilation de méthode au démarrage d’une application :When TC is enabled, the following behavior applies for method compilation when an app starts up:

  • Si la méthode a un code compilé à l’avance, ou ReadyToRun, le code prégénéré est utilisé.If the method has ahead-of-time-compiled code, or ReadyToRun, the pregenerated code is used.
  • Sinon, la méthode est avec JIT.Otherwise, the method is jitted. En règle générale, ces méthodes sont des génériques sur les types valeur.Typically, these methods are generics over value types.
    • Le JIT rapide génère plus rapidement du code de qualité inférieure (ou moins optimisée).Quick JIT produces lower-quality (or less optimized) code more quickly. Dans .NET Core 3,0, le JIT rapide est activé par défaut pour les méthodes qui ne contiennent pas de boucles et est préférable au démarrage.In .NET Core 3.0, Quick JIT is enabled by default for methods that don't contain loops and is preferred during startup.
    • L’optimisation complète de JIT génère plus lentement un code de qualité supérieure (ou optimisée).The fully optimizing JIT produces higher-quality (or more optimized) code more slowly. Pour les méthodes où le JIT rapide ne doit pas être utilisé (par exemple, si la méthode est attribuée avec MethodImplOptions.AggressiveOptimization), le JIT entièrement optimisé est utilisé.For methods where Quick JIT would not be used (for example, if the method is attributed with MethodImplOptions.AggressiveOptimization), the fully optimizing JIT is used.

Pour les méthodes fréquemment appelées, le compilateur juste-à-temps finit par créer un code entièrement optimisé en arrière-plan.For frequently called methods, the just-in-time compiler eventually creates fully optimized code in the background. Le code optimisé remplace ensuite le code précompilé pour cette méthode.The optimized code then replaces the pre-compiled code for that method.

Le code généré par JIT rapide peut s’exécuter plus lentement, allouer davantage de mémoire ou utiliser plus d’espace de pile.Code generated by Quick JIT may run slower, allocate more memory, or use more stack space. En cas de problème, vous pouvez désactiver le JIT rapide à l’aide de cette propriété MSBuild dans le fichier projet :If there are issues, you can disabled Quick JIT using this MSBuild property in the project file:

<PropertyGroup>
  <TieredCompilationQuickJit>false</TieredCompilationQuickJit>
</PropertyGroup>

Pour désactiver complètement TC, utilisez cette propriété MSBuild dans votre fichier projet :To disable TC completely, use this MSBuild property in your project file:

<PropertyGroup>
  <TieredCompilation>false</TieredCompilation>
</PropertyGroup>

Conseil

Si vous modifiez ces paramètres dans le fichier projet, vous devrez peut-être effectuer une génération propre pour que les nouveaux paramètres soient reflétés (supprimez le obj et bin répertoires et Rebuild).If you change these settings in the project file, you may need to perform a clean build for the new settings to be reflected (delete the obj and bin directories and rebuild).

Pour plus d’informations sur la configuration de la compilation au moment de l’exécution, consultez options de configuration au moment de l’exécution pour la compilation.For more information about configuring compilation at run time, see Run-time configuration options for compilation.

Images ReadyToRunReadyToRun images

Vous pouvez améliorer le temps de démarrage de votre application .NET Core en compilant les assemblys de votre application au format ReadyToRun (R2R).You can improve the startup time of your .NET Core application by compiling your application assemblies as ReadyToRun (R2R) format. R2R est une forme de compilation ahead-of-time (AOT).R2R is a form of ahead-of-time (AOT) compilation.

Les fichiers binaires R2R améliorent les performances de démarrage en réduisant la quantité de travail que le compilateur juste-à-temps (JIT) doit faire lorsque votre application est chargée.R2R binaries improve startup performance by reducing the amount of work the just-in-time (JIT) compiler needs to do as your application loads. Les fichiers binaires contiennent du code natif similaire à ce que la compilation JIT produirait.The binaries contain similar native code compared to what the JIT would produce. Cependant, les fichiers binaires R2R sont plus grands, car ils contiennent à la fois le code du langage intermédiaire (IL), qui est toujours nécessaire pour certains scénarios, et la version native du même code.However, R2R binaries are larger because they contain both intermediate language (IL) code, which is still needed for some scenarios, and the native version of the same code. R2R est disponible seulement quand vous publiez une application autonome qui cible des environnements d’exécution spécifiques (RID), comme Linux x64 ou Windows x64.R2R is only available when you publish a self-contained app that targets specific runtime environments (RID) such as Linux x64 or Windows x64.

Pour compiler votre projet en ReadyToRun, procédez comme suit :To compile your project as ReadyToRun, do the following:

  1. Ajoutez le paramètre <PublishReadyToRun> à votre projet :Add the <PublishReadyToRun> setting to your project:

    <PropertyGroup>
      <PublishReadyToRun>true</PublishReadyToRun>
    </PropertyGroup>
    
  2. Publiez une application autonome.Publish a self-contained app. Par exemple, cette commande crée une application autonome pour la version 64 bits de Windows :For example, this command creates a self-contained app for the 64-bit version of Windows:

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

Restrictions d’architecture/de multiplateformeCross platform/architecture restrictions

Le compilateur ReadyToRun ne prend actuellement pas en charge le ciblage croisé.The ReadyToRun compiler doesn't currently support cross-targeting. Vous devez compiler sur une cible donnée.You must compile on a given target. Par exemple, si vous souhaitez avoir des images R2R Windows x64, vous devez exécuter la commande de publication sur cet environnement.For example, if you want R2R images for Windows x64, you need to run the publish command on that environment.

Exceptions au ciblage croisé :Exceptions to cross-targeting:

  • Windows x64 peut être utilisé pour compiler des images Windows ARM32, ARM64 et x86.Windows x64 can be used to compile Windows ARM32, ARM64, and x86 images.
  • Windows x86 peut être utilisé pour compiler des images Windows ARM32.Windows x86 can be used to compile Windows ARM32 images.
  • Linux x64 peut être utilisé pour compiler des images Linux ARM32 et ARM64.Linux x64 can be used to compile Linux ARM32 and ARM64 images.

Runtime/SDKRuntime/SDK

Restauration par progression du runtime de version majeureMajor-version runtime roll forward

.NET Core 3.0 introduit une fonctionnalité que vous pouvez choisir d’utiliser et qui permet de restaurer par progression votre application vers la dernière version majeure de .NET Core..NET Core 3.0 introduces an opt-in feature that allows your app to roll forward to the latest major version of .NET Core. En outre, un nouveau paramètre a été ajouté pour contrôler la façon dont la restauration par progression est appliquée à votre application.Additionally, a new setting has been added to control how roll forward is applied to your app. Ce paramètre peut être configuré des façons suivantes :This can be configured in the following ways:

  • Propriété du fichier projet : RollForwardProject file property: RollForward
  • Propriété du fichier de configuration au moment de l’exécution : rollForwardRun-time configuration file property: rollForward
  • Variable d’environnement : DOTNET_ROLL_FORWARDEnvironment variable: DOTNET_ROLL_FORWARD
  • Argument de ligne de commande : --roll-forwardCommand-line argument: --roll-forward

L’une des valeurs suivantes doit être spécifiée.One of the following values must be specified. Si le paramètre est omis, Minor est la valeur par défaut.If the setting is omitted, Minor is the default.

  • LatestPatchLatestPatch
    Restauration par progression vers la version de correctif la plus élevée.Roll forward to the highest patch version. Cette valeur désactive la restauration par progression d’une version mineure.This disables minor version roll forward.
  • MinorMinor
    Restauration par progression vers la version mineure supérieure la plus basse, si la version mineure demandée est manquante.Roll forward to the lowest higher minor version, if requested minor version is missing. Si la version mineure demandée est présente, la stratégie LatestPatch est utilisée.If the requested minor version is present, then the LatestPatch policy is used.
  • MajorMajor
    Restauration par progression vers la version majeure supérieure la plus basse, et la version mineure la plus basse, si la version majeure demandée est manquante.Roll forward to lowest higher major version, and lowest minor version, if requested major version is missing. Si la version majeure demandée est présente, la stratégie Minor est utilisée.If the requested major version is present, then the Minor policy is used.
  • LatestMinorLatestMinor
    Restauration par progression vers la version mineure la plus élevée, si la version mineure demandée est présente.Roll forward to highest minor version, even if requested minor version is present. Conçu pour les scénarios d’hébergement de composant.Intended for component hosting scenarios.
  • LatestMajorLatestMajor
    Restauration par progression vers la version majeure la plus élevée et la version mineure la plus élevée, si la version majeure demandée est présente.Roll forward to highest major and highest minor version, even if requested major is present. Conçu pour les scénarios d’hébergement de composant.Intended for component hosting scenarios.
  • DisableDisable
    Ne pas effectuer de restauration par progression.Don't roll forward. Lier uniquement à la version spécifiée.Only bind to specified version. Cette stratégie n’est pas recommandée pour une utilisation générale, car elle désactive la possibilité d’effectuer une restauration par progression vers les derniers correctifs.This policy isn't recommended for general use because it disables the ability to roll forward to the latest patches. Cette valeur est recommandée uniquement à des fins de test.This value is only recommended for testing.

Outre le paramètre Disable, tous les paramètres utilisent la version de correctif disponible la plus élevée.Besides the Disable setting, all settings will use the highest available patch version.

Dépendances de copies de buildBuild copies dependencies

La commande dotnet build copie maintenant les dépendances NuGet pour votre application à partir du cache NuGet vers le dossier de sortie de build.The dotnet build command now copies NuGet dependencies for your application from the NuGet cache to the build output folder. Auparavant, les dépendances étaient copiées uniquement dans le cadre de dotnet publish.Previously, dependencies were only copied as part of dotnet publish.

Certaines opérations, par exemple la liaison et la publication d’une page de type Razor, nécessiteront toujours une publication.There are some operations, like linking and razor page publishing that will still require publishing.

Outils locauxLocal tools

.NET Core 3.0 introduit des outils locaux..NET Core 3.0 introduces local tools. Les outils locaux sont similaires aux outils globaux, mais ils sont associés à un emplacement particulier sur le disque.Local tools are similar to global tools but are associated with a particular location on disk. Les outils locaux ne sont pas disponibles globalement et sont distribués en tant que packages NuGet.Local tools aren't available globally and are distributed as NuGet packages.

Avertissement

Si vous avez essayé des outils locaux dans .NET Core 3.0 Preview 1, par exemple pour exécuter dotnet tool restore ou dotnet tool install, supprimez le dossier de cache des outils locaux.If you tried local tools in .NET Core 3.0 Preview 1, such as running dotnet tool restore or dotnet tool install, delete the local tools cache folder. Sinon, les outils locaux ne fonctionneront sur aucune nouvelle version.Otherwise, local tools won't work on any newer release. Ce dossier se trouve à ces emplacements :This folder is located at:

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

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

Les outils locaux s’appuient sur un nom de fichier manifeste dotnet-tools.json dans votre répertoire actuel.Local tools rely on a manifest file name dotnet-tools.json in your current directory. Ce fichier manifeste définit les outils qui doivent être disponibles dans ce dossier et sous-celui-ci.This manifest file defines the tools to be available at that folder and below. Vous pouvez distribuer le fichier manifeste avec votre code pour que toute personne qui utilise votre code puisse restaurer et utiliser les mêmes outils.You can distribute the manifest file with your code to ensure that anyone who works with your code can restore and use the same tools.

Pour les outils locaux et globaux, une version compatible du runtime est requise.For both global and local tools, a compatible version of the runtime is required. De nombreux outils actuellement sur NuGet.org ciblent le runtime .NET Core 2.1.Many tools currently on NuGet.org target .NET Core Runtime 2.1. Pour installer ces outils de façon locale ou globale, vous devez toujours installer le runtime NET Core 2.1.To install these tools globally or locally, you would still need to install the NET Core 2.1 Runtime.

Nouvelles options global. JSONNew global.json options

Le fichier global. JSON présente de nouvelles options qui offrent plus de flexibilité lorsque vous essayez de définir la version de la kit SDK .net Core utilisée.The global.json file has new options that provide more flexibility when you're trying to define which version of the .NET Core SDK is used. Les nouvelles options sont les suivantes :The new options are:

  • allowPrerelease: indique si le programme de résolution du SDK doit prendre en compte les versions préliminaires lorsque vous sélectionnez la version du kit de développement logiciel (SDK) à utiliser.allowPrerelease: Indicates whether the SDK resolver should consider prerelease versions when selecting the SDK version to use.
  • rollForward: indique la stratégie de restauration par progression à utiliser lors de la sélection d’une version du kit de développement logiciel (SDK), en tant que solution de secours quand une version spécifique du kit de développement logiciel est manquante ou en tant que directive pour utiliser une version plus récente.rollForward: Indicates the roll-forward policy to use when selecting an SDK version, either as a fallback when a specific SDK version is missing or as a directive to use a higher version.

Pour plus d’informations sur les modifications, y compris les valeurs par défaut, les valeurs prises en charge et les nouvelles règles de correspondance, consultez vue d’ensemble de Global. JSON.For more information about the changes including default values, supported values, and new matching rules, see global.json overview.

Tailles de tas de garbage collection plus petitesSmaller Garbage Collection heap sizes

La taille de tas par défaut du récupérateur de mémoire a été réduite, aboutissant à une diminution de la quantité de mémoire utilisée par .NET Core.The Garbage Collector's default heap size has been reduced resulting in .NET Core using less memory. Ce changement est plus conforme au budget d’allocation de génération 0 avec les tailles des caches des processeurs modernes.This change better aligns with the generation 0 allocation budget with modern processor cache sizes.

Prise en charge de grandes pages du garbage collectionGarbage Collection Large Page support

Les grandes pages (également appelées HugePages sur Linux) sont une fonctionnalité qui permet au système d’exploitation d’établir des régions de mémoire plus grandes que la taille de page native (souvent 4 Ko) pour améliorer les performances de l’application qui demande ces grandes pages.Large Pages (also known as Huge Pages on Linux) is a feature where the operating system is able to establish memory regions larger than the native page size (often 4K) to improve performance of the application requesting these large pages.

Vous pouvez maintenant configurer le récupérateur de mémoire avec la définition GCLargePages en tant que fonctionnalité que vous pouvez choisir d’utiliser et qui permet d’allouer de grandes pages sur Windows.The Garbage Collector can now be configured with the GCLargePages setting as an opt-in feature to choose to allocate large pages on Windows.

Windows Desktop & COMWindows Desktop & COM

Windows Installer pour le kit SDK .NET Core.NET Core SDK Windows Installer

Le programme d’installation MSI pour Windows a changé à compter de .NET Core 3.0.The MSI installer for Windows has changed starting with .NET Core 3.0. Les programmes d’installation du SDK mettent désormais à niveau les versions des plages de fonctionnalités du SDK.The SDK installers will now upgrade SDK feature-band releases in place. Les plages de fonctionnalités sont définies dans les groupes hundreds de la section patch du numéro de version.Feature bands are defined in the hundreds groups in the patch section of the version number. Par exemple, 3.0.101 et 3.0.201 sont des versions dans deux plages de fonctionnalités différentes, tandis que 3.0.101 et 3.0.199 se trouvent dans la même plages de fonctionnalités.For example, 3.0.101 and 3.0.201 are versions in two different feature bands while 3.0.101 and 3.0.199 are in the same feature band. En outre, quand le SDK .NET Core 3.0.101 est installé, le SDK .NET Core 3.0.100 est supprimé de la machine s’il existe.And, when .NET Core SDK 3.0.101 is installed, .NET Core SDK 3.0.100 will be removed from the machine if it exists. Quand le SDK .NET Core 3.0.200 est installé sur la même machine, le SDK .NET Core 3.0.101 n’est pas supprimé.When .NET Core SDK 3.0.200 is installed on the same machine, .NET Core SDK 3.0.101 won't be removed.

Pour plus d’informations sur la gestion des versions, consultez Vue d’ensemble de la gestion des versions .NET Core.For more information about versioning, see Overview of how .NET Core is versioned.

Bureau WindowsWindows desktop

.NET Core 3.0 prend en charge les applications de bureau Windows utilisant Windows Presentation Foundation (WPF) et Windows Forms..NET Core 3.0 supports Windows desktop applications using Windows Presentation Foundation (WPF) and Windows Forms. Ces infrastructures prennent également en charge l’utilisation de contrôles modernes et le style Fluent à partir de la bibliothèque XAML de l’interface utilisateur Windows (WinUI) via des îles XAML.These frameworks also support using modern controls and Fluent styling from the Windows UI XAML Library (WinUI) via XAML islands.

Le composant Bureau Windows fait partie du SDK .NET Core 3.0 Windows.The Windows Desktop component is part of the Windows .NET Core 3.0 SDK.

Vous pouvez créer une nouvelle application WPF ou Windows Forms à l’aide des commandes dotnet suivantes :You can create a new WPF or Windows Forms app with the following dotnet commands:

dotnet new wpf
dotnet new winforms

Visual Studio 2019 ajoute des modèles Nouveau projet pour Windows Forms et WPF .NET Core 3.0.Visual Studio 2019 adds New Project templates for .NET Core 3.0 Windows Forms and WPF.

Pour plus d’informations sur la façon de porter une application .NET Framework existante, consultez Porter des projets WPF et Porter des projets Windows Forms.For more information about how to port an existing .NET Framework application, see Port WPF projects and Port Windows Forms projects.

Haute résolution WinFormsWinForms high DPI

Les applications Windows Forms .NET Core peuvent définir le mode de haute résolution avec Application.SetHighDpiMode(HighDpiMode)..NET Core Windows Forms applications can set high DPI mode with Application.SetHighDpiMode(HighDpiMode). La méthode SetHighDpiMode définit le mode de haute résolution correspondant, sauf si le paramètre a été défini par d’autres moyens, comme App.Manifest ou P/Invoke avant Application.Run.The SetHighDpiMode method sets the corresponding high DPI mode unless the setting has been set by other means like App.Manifest or P/Invoke before Application.Run.

Les valeurs highDpiMode possibles, telles qu’exprimées par l’enum System.Windows.Forms.HighDpiMode, sont les suivantes :The possible highDpiMode values, as expressed by the System.Windows.Forms.HighDpiMode enum are:

  • DpiUnaware
  • SystemAware
  • PerMonitor
  • PerMonitorV2
  • DpiUnawareGdiScaled

Pour plus d’informations sur les modes de haute résolution, consultez High DPI Desktop Application Development on Windows (Développement d’applications de bureau haute résolution sur Windows).For more information about high DPI modes, see High DPI Desktop Application Development on Windows.

Créer des composants COMCreate COM components

Sur Windows, vous pouvez maintenant créer des composants gérés appelables par COM.On Windows, you can now create COM-callable managed components. Cette fonctionnalité est essentielle pour utiliser .NET Core avec les modèles de compléments COM et également pour assurer la parité avec .NET Framework.This capability is critical to use .NET Core with COM add-in models and also to provide parity with .NET Framework.

Contrairement à .NET Framework, où mscoree.dll était utilisé comme serveur COM, .NET Core ajoute une dll de lanceur natif au répertoire bin quand vous générez votre composant COM.Unlike .NET Framework where the mscoree.dll was used as the COM server, .NET Core will add a native launcher dll to the bin directory when you build your COM component.

Pour obtenir un exemple montrant comment créer un composant COM et le consommer, consultez la démonstration COM.For an example of how to create a COM component and consume it, see the COM Demo.

Interopérabilité native WindowsWindows Native Interop

Windows offre une API native riche sous la forme d’API C plates, de COM et de WinRT.Windows offers a rich native API in the form of flat C APIs, COM, and WinRT. Tandis que .NET Core prend en charge P/Invoke, .NET Core 3.0 ajoute la possibilité de cocréer des API COM et d’activer des API WinRT.While .NET Core supports P/Invoke, .NET Core 3.0 adds the ability to CoCreate COM APIs and Activate WinRT APIs. Pour obtenir un exemple de code, consultez la démonstration Excel.For a code example, see the Excel Demo.

Déploiement de MSIXMSIX Deployment

MSIX est un nouveau format de package d’application Windows.MSIX is a new Windows application package format. Il peut être utilisé pour déployer des applications de poste de travail .NET Core 3.0 pour Windows 10.It can be used to deploy .NET Core 3.0 desktop applications to Windows 10.

Le projet de package d’application Windows, disponible dans Visual Studio 2019, vous permet de créer des packages MSIX avec des applications .NET Core autonomes.The Windows Application Packaging Project, available in Visual Studio 2019, allows you to create MSIX packages with self-contained .NET Core applications.

Le fichier projet .NET Core doit spécifier les runtimes pris en charge dans la propriété <RuntimeIdentifiers> :The .NET Core project file must specify the supported runtimes in the <RuntimeIdentifiers> property:

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

Améliorations de LinuxLinux improvements

SerialPort pour LinuxSerialPort for Linux

.NET Core 3.0 offre une prise en charge de base de System.IO.Ports.SerialPort sur Linux..NET Core 3.0 provides basic support for System.IO.Ports.SerialPort on Linux.

Auparavant, .NET Core était uniquement pris en charge au moyen de SerialPort sur Windows.Previously, .NET Core only supported using SerialPort on Windows.

Pour plus d’informations sur la prise en charge limitée du port série sur Linux, consultez GitHub issue #33146.For more information about the limited support for the serial port on Linux, see GitHub issue #33146.

Docker et limites de mémoire cgroupDocker and cgroup memory Limits

L’exécution de .NET Core 3,0 sur Linux avec l’arrimeur fonctionne mieux avec les limites de mémoire cgroup.Running .NET Core 3.0 on Linux with Docker works better with cgroup memory limits. L’exécution d’un conteneur Docker avec des limites de mémoire, par exemple avec docker run -m, change le comportement de .NET Core.Running a Docker container with memory limits, such as with docker run -m, changes how .NET Core behaves.

  • Taille de tas par défaut du récupérateur de mémoire (GC) : au maximum 20 Mo ou 75 % de la limite de mémoire sur le conteneur.Default Garbage Collector (GC) heap size: maximum of 20 mb or 75% of the memory limit on the container.
  • Une taille explicite peut être définie sous forme de nombre absolu ou de pourcentage de la limite cgroup.Explicit size can be set as an absolute number or percentage of cgroup limit.
  • La taille de segment réservée minimale par tas GC est de 16 Mo.Minimum reserved segment size per GC heap is 16 mb. Cette taille réduit le nombre de segments de mémoire qui sont créés sur les machines.This size reduces the number of heaps that are created on machines.

Prise en charge de GPIO pour Raspberry PiGPIO Support for Raspberry Pi

Deux packages ont été publiés sur NuGet, que vous pouvez utiliser pour la programmation de GPIO :Two packages have been released to NuGet that you can use for GPIO programming:

Les packages GPIO incluent des API pour les appareils GPIO, SPI, I2C et PWM.The GPIO packages include APIs for GPIO, SPI, I2C, and PWM devices. Le package de liaisons IoT comprend des liaisons d’appareil.The IoT bindings package includes device bindings. Pour plus d’informations, consultez le dépôt GitHub devices.For more information, see the devices GitHub repo.

Support ARM64 LinuxARM64 Linux support

.NET Core 3.0 prend en charge ARM64 pour Linux..NET Core 3.0 adds support for ARM64 for Linux. Actuellement, ARM64 est principallement utilisé dans des scénarios IoT.The primary use case for ARM64 is currently with IoT scenarios. Pour plus d’informations, consultez .NET Core ARM64 Status.For more information, see .NET Core ARM64 Status.

Des images Docker pour .NET Core sur ARM64 sont disponibles pour Alpine, Debian et Ubuntu.Docker images for .NET Core on ARM64 are available for Alpine, Debian, and Ubuntu.

Notes

La prise en charge d’ARM64 sous Windows n’est pas encore disponible.ARM64 Windows support isn't yet available.

SécuritéSecurity

TLS 1.3 et OpenSSL 1.1.1 sous LinuxTLS 1.3 & OpenSSL 1.1.1 on Linux

.NET Core tire désormais parti de la prise en charge de TLS 1.3 dans OpenSSL 1.1.1, si disponible dans un environnement donné..NET Core now takes advantage of TLS 1.3 support in OpenSSL 1.1.1, when it's available in a given environment. Avec TLS 1.3 :With TLS 1.3:

  • Les délais de connexion sont améliorés grâce à une réduction des allers-retours requis entre le client et le serveur.Connection times are improved with reduced round trips required between the client and server.
  • La sécurité est améliorée en raison de la suppression de différents algorithmes de chiffrement obsolètes et non sécurisés.Improved security because of the removal of various obsolete and insecure cryptographic algorithms.

.NET Core 3.0 utilise OpenSSL 1.1.1, OpenSSL 1.1.0 ou OpenSSL 1.0.2 sur un système Linux s’ils sont disponibles.When available, .NET Core 3.0 uses OpenSSL 1.1.1, OpenSSL 1.1.0, or OpenSSL 1.0.2 on a Linux system. Quand OpenSSL 1.1.1 est disponible, les types System.Net.Security.SslStream et System.Net.Http.HttpClient utilisent TLS 1.3 (sous réserve que le client et le serveur prennent en charge TLS 1.3).When OpenSSL 1.1.1 is available, both System.Net.Security.SslStream and System.Net.Http.HttpClient types will use TLS 1.3 (assuming both the client and server support TLS 1.3).

Important

Windows et macOS ne prennent pas encore en charge TLS 1.3.Windows and macOS do not yet support TLS 1.3. .NET Core 3.0 prendra en charge TLS 1.3 sur ces systèmes d’exploitation dès que de la prise en charge sera disponible..NET Core 3.0 will support TLS 1.3 on these operating systems when support becomes available.

L’exemple C# 8.0 suivant montre comment .NET Core 3.0 sur Ubuntu 18.10 se connecte à https://www.cloudflare.com :The following C# 8.0 example demonstrates .NET Core 3.0 on Ubuntu 18.10 connecting to https://www.cloudflare.com:

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

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

            using TcpClient tcpClient = new TcpClient();

            await tcpClient.ConnectAsync(targetHost, 443);

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

ChiffrementsCryptography ciphers

.NET 3.0 prend en charge les chiffrements AES-GCM et AES-CCM, implémentés avec System.Security.Cryptography.AesGcm et System.Security.Cryptography.AesCcm respectivement..NET 3.0 adds support for AES-GCM and AES-CCM ciphers, implemented with System.Security.Cryptography.AesGcm and System.Security.Cryptography.AesCcm respectively. Ces algorithmes sont tous deux des algorithmes AEAD (Authenticated Encryption with Association Data).These algorithms are both Authenticated Encryption with Association Data (AEAD) algorithms.

Le code suivant montre l’utilisation du chiffrement AesGcm pour chiffrer et déchiffrer des données aléatoires.The following code demonstrates using AesGcm cipher to encrypt and decrypt random data.

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

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

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

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

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

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

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

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

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

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

Importation/exportation d’une clé de chiffrementCryptographic Key Import/Export

.NET Core 3.0 prend en charge l’importation et l’exportation de clés publiques et privées asymétriques aux formats standard..NET Core 3.0 supports the import and export of asymmetric public and private keys from standard formats. Vous n’avez pas besoin d’utiliser un certificat X.509.You don't need to use an X.509 certificate.

Tous les types de clés, tels que RSA, DSA, ECDsa et ECDiffieHellman, prennent en charge les formats suivants :All key types, such as RSA, DSA, ECDsa, and ECDiffieHellman, support the following formats:

  • Clé publiquePublic Key

    • X.509 SubjectPublicKeyInfoX.509 SubjectPublicKeyInfo
  • Clé privéePrivate key

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

Les clés RSA prennent également en charge :RSA keys also support:

  • Clé publiquePublic Key

    • PKCS#1 RSAPublicKeyPKCS#1 RSAPublicKey
  • Clé privéePrivate key

    • PKCS#1 RSAPrivateKeyPKCS#1 RSAPrivateKey

Les méthodes d’exportation produisent des données binaires encodées au format DER, tout comme les méthodes d’importation.The export methods produce DER-encoded binary data, and the import methods expect the same. Si une clé est stockée au format PEM compatible avec le texte, l’appelant devra décoder le contenu au format base64 avant d’appeler une méthode d’importation.If a key is stored in the text-friendly PEM format, the caller will need to base64-decode the content before calling an import method.

using System;
using System.Security.Cryptography;

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

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

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

Les fichiers PKCS#8 peuvent être inspectés avec System.Security.Cryptography.Pkcs.Pkcs8PrivateKeyInfo, tandis que les fichiers PFX/PKCS#12 peuvent être inspectés avec System.Security.Cryptography.Pkcs.Pkcs12Info.PKCS#8 files can be inspected with System.Security.Cryptography.Pkcs.Pkcs8PrivateKeyInfo and PFX/PKCS#12 files can be inspected with System.Security.Cryptography.Pkcs.Pkcs12Info. Les fichiers PFX/PKCS#12 peuvent être manipulés avec System.Security.Cryptography.Pkcs.Pkcs12Builder.PFX/PKCS#12 files can be manipulated with System.Security.Cryptography.Pkcs.Pkcs12Builder.

Modifications de l’API .NET Core 3,0.NET Core 3.0 API changes

Plages et indexRanges and indices

Le nouveau type System.Index peut être utilisé pour l’indexation.The new System.Index type can be used for indexing. Vous pouvez en créer un à partir d’un int qui compte à partir du début, ou avec un opérateur (C#) ^ préfixé qui compte à partir de la fin :You can create one from an int that counts from the beginning, or with a prefix ^ operator (C#) that counts from the end:

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

Il existe également le type System.Range, composé de deux valeurs Index, une pour le début et une pour la fin, et qui peut être écrit avec une expression de plage (C#) x..y.There's also the System.Range type, which consists of two Index values, one for the start and one for the end, and can be written with a x..y range expression (C#). Vous pouvez indexer ensuite avec un Range, ce qui génère une tranche :You can then index with a Range, which produces a slice:

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

Pour plus d’informations, consultez le tutoriel sur les plages et les index.For more information, see the ranges and indices tutorial.

Flux asynchronesAsync streams

Le type IAsyncEnumerable<T> est une nouvelle version asynchrone de IEnumerable<T>.The IAsyncEnumerable<T> type is a new asynchronous version of IEnumerable<T>. Le langage vous permet d’utiliser await foreach sur IAsyncEnumerable<T> pour consommer ses éléments, et yield return sur ceux-ci pour produire des éléments.The language lets you await foreach over IAsyncEnumerable<T> to consume their elements, and use yield return to them to produce elements.

L’exemple suivant montre la production et la consommation de flux de données asynchrones.The following example demonstrates both production and consumption of async streams. L’instruction foreach est asynchrone et utilise elle-même yield return afin de produire un flux asynchrone pour les appelants.The foreach statement is async and itself uses yield return to produce an async stream for callers. Ce modèle (qui utilise yield return) est le modèle recommandé pour produire des flux de données asynchrones.This pattern (using yield return) is the recommended model for producing async streams.

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

Outre la possibilité d’effectuer une opération await foreach, vous pouvez également créer des itérateurs asynchrones, par exemple un itérateur qui retourne un objet IAsyncEnumerable/IAsyncEnumerator auquel vous pouvez à la fois appliquer des opérations await et yield.In addition to being able to await foreach, you can also create async iterators, for example, an iterator that returns an IAsyncEnumerable/IAsyncEnumerator that you can both await and yield in. Pour les objets qui doivent être supprimés, vous pouvez utiliser IAsyncDisposable, qui implémentent différents types BCL, notamment Stream et Timer.For objects that need to be disposed, you can use IAsyncDisposable, which various BCL types implement, such as Stream and Timer.

Pour plus d’informations, consultez le tutoriel sur les flux asynchrones.For more information, see the async streams tutorial.

Virgule flottante IEEEIEEE Floating-point

Les API de virgule flottante sont en cours de mise à jour pour devenir conformes à la révision 754-2008 d’IEEE.Floating point APIs are being updated to comply with IEEE 754-2008 revision. L’objectif de ces modifications est d’exposer toutes les opérations requises et de s’assurer qu’elles sont conformes au comportement des spécifications IEEE. Pour plus d’informations sur les améliorations de la virgule flottante, consultez le billet de blog améliorations de la mise en forme et de l’analyse de la virgule flottante dans .net Core 3,0 .The goal of these changes is to expose all required operations and ensure that they're behaviorally compliant with the IEEE spec. For more information about floating-point improvements, see the Floating-Point Parsing and Formatting improvements in .NET Core 3.0 blog post.

Les correctifs de l’analyse et de la mise en forme comprennent :Parsing and formatting fixes include:

  • Analyse et arrondi corrects des entrées, quelle que soit leur longueur.Correctly parse and round inputs of any length.
  • Analyse et mise en forme correctes des zéros négatifs.Correctly parse and format negative zero.
  • Analyse correcte de Infinity et NaN en effectuant une vérification sans tenir compte de la casse et en autorisant un signe + facultatif de début là où c’est applicable.Correctly parse Infinity and NaN by doing a case-insensitive check and allowing an optional preceding + where applicable.

Les nouvelles API System.Math incluent :New System.Math APIs include:

  • BitIncrement(Double) et BitDecrement(Double)BitIncrement(Double) and BitDecrement(Double)
    Correspond aux opérations IEEE nextUp et nextDown.Corresponds to the nextUp and nextDown IEEE operations. Elles retournent le plus petit nombre à virgule flottante dont la valeur est supérieure ou inférieure à l’entrée (respectivement).They return the smallest floating-point number that compares greater or lesser than the input (respectively). Par exemple, Math.BitIncrement(0.0) retourne double.Epsilon.For example, Math.BitIncrement(0.0) would return double.Epsilon.

  • MaxMagnitude(Double, Double) et MinMagnitude(Double, Double)MaxMagnitude(Double, Double) and MinMagnitude(Double, Double)
    Correspond aux opérations IEEE maxNumMag et minNumMag. Elles retournent la valeur la plus grande ou la plus petite des deux entrées (respectivement).Corresponds to the maxNumMag and minNumMag IEEE operations, they return the value that is greater or lesser in magnitude of the two inputs (respectively). Par exemple, Math.MaxMagnitude(2.0, -3.0) retourne -3.0.For example, Math.MaxMagnitude(2.0, -3.0) would return -3.0.

  • ILogB(Double)
    Correspond à l’opération IEEE logB qui retourne une valeur intégrale ; elle retourne le logarithme de base 2 intégral du paramètre d’entrée.Corresponds to the logB IEEE operation that returns an integral value, it returns the integral base-2 log of the input parameter. Cette méthode est identique à floor(log2(x)), mais effectuée avec une erreur d’arrondi minimale.This method is effectively the same as floor(log2(x)), but done with minimal rounding error.

  • ScaleB(Double, Int32)
    Correspond à l’opération IEEE scaleB qui prend une valeur intégrale ; elle retourne x * pow(2, n), mais est effectuée avec une erreur d’arrondi minimale.Corresponds to the scaleB IEEE operation that takes an integral value, it returns effectively x * pow(2, n), but is done with minimal rounding error.

  • Log2(Double)
    Correspond à l’opération IEEE log2 ; elle retourne le logarithme de base 2.Corresponds to the log2 IEEE operation, it returns the base-2 logarithm. Son erreur d’arrondi est minimale.It minimizes rounding error.

  • FusedMultiplyAdd(Double, Double, Double)
    Correspond à l’opération IEEE fma ; elle effectue une multiplication-addition fusionnée.Corresponds to the fma IEEE operation, it performs a fused multiply add. Elle effectue (x * y) + z comme une seule opération, avec une erreur d’arrondi minimale.That is, it does (x * y) + z as a single operation, thereby minimizing the rounding error. Un exemple est FusedMultiplyAdd(1e308, 2.0, -1e308), qui retourne 1e308.An example is FusedMultiplyAdd(1e308, 2.0, -1e308), which returns 1e308. L’opération régulière (1e308 * 2.0) - 1e308 retourne double.PositiveInfinity.The regular (1e308 * 2.0) - 1e308 returns double.PositiveInfinity.

  • CopySign(Double, Double)
    Correspond à l’opération IEEE copySign ; elle retourne la valeur de x, mais avec le signe de y.Corresponds to the copySign IEEE operation, it returns the value of x, but with the sign of y.

Intrinsèques dépendant de la plateforme .NET.NET Platform-Dependent Intrinsics

Des API ont été ajoutées, qui permettent d’accéder à certaines instructions de l’UC orientées performances, comme les ensembles SIMD ou les ensembles d’instructions de manipulation de bits.APIs have been added that allow access to certain perf-oriented CPU instructions, such as the SIMD or Bit Manipulation instruction sets. Ces instructions peuvent améliorer les performances dans certains scénarios de matière significative, comme le traitement efficace de données en parallèle.These instructions can help achieve significant performance improvements in certain scenarios, such as processing data efficiently in parallel.

Le cas échéant, les bibliothèques .NET ont commencé à utiliser ces instructions pour améliorer les performances.Where appropriate, the .NET libraries have begun using these instructions to improve performance.

Pour plus d’informations, consultez Intrinsèques dépendant de la plateforme .NET.For more information, see .NET Platform Dependent Intrinsics.

API de version de .NET Core amélioréesImproved .NET Core Version APIs

À compter de .NET Core 3.0, les API de version fournies avec .NET Core retournent les informations souhaitées.Starting with .NET Core 3.0, the version APIs provided with .NET Core now return the information you expect. Par exemple :For example:

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

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

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

Avertissement

Modification avec rupture.Breaking change. Il s’agit techniquement d’une modification avec rupture, car le schéma de gestion de version a changé.This is technically a breaking change because the versioning scheme has changed.

Prise en charge JSON intégrée rapideFast built-in JSON support

Les utilisateurs .NET ont largement utilisé Newtonsoft. JSON et d’autres bibliothèques JSON populaires, qui continuent d’être de bons choix..NET users have largely relied on Newtonsoft.Json and other popular JSON libraries, which continue to be good choices. Newtonsoft.Json utilise des chaînes .NET comme type de données de base, UTF-16 en coulisse.Newtonsoft.Json uses .NET strings as its base datatype, which is UTF-16 under the hood.

La nouvelle prise en charge de JSON intégrée est la haute performance, une faible allocation et fonctionne avec du texte JSON encodé en UTF-8.The new built-in JSON support is high-performance, low allocation, and works with UTF-8 encoded JSON text. Pour plus d’informations sur l’espace de noms et les types de System.Text.Json, consultez les articles suivants :For more information about the System.Text.Json namespace and types, see the following articles:

Prise en charge de HTTP/2HTTP/2 support

Le type System.Net.Http.HttpClient prend en charge le protocole HTTP/2.The System.Net.Http.HttpClient type supports the HTTP/2 protocol. Si HTTP/2 est activé, la version du protocole HTTP est négociée par le biais de TLS/ALPN, et HTTP/2 n’est utilisée que si le serveur le choisit.If HTTP/2 is enabled, the HTTP protocol version is negotiated via TLS/ALPN, and HTTP/2 is used if the server elects to use it.

Le protocole par défaut reste HTTP/1.1, mais HTTP/2 peut être activé de deux manières différentes.The default protocol remains HTTP/1.1, but HTTP/2 can be enabled in two different ways. Tout d’abord, vous pouvez définir le message de requête HTTP de sorte à utiliser HTTP/2 :First, you can set the HTTP request message to use HTTP/2:

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

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

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

Ensuite, vous pouvez modifier HttpClient pour utiliser HTTP/2 par défaut :Second, you can change HttpClient to use HTTP/2 by default:

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

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

Souvent, lorsque vous développez une application, vous souhaiterez utiliser une connexion non chiffrée.Many times when you're developing an application, you want to use an unencrypted connection. Si vous savez que le point de terminaison cible utilisera HTTP/2, vous pouvez activer les connexions non chiffrées pour HTTP/2.If you know the target endpoint will be using HTTP/2, you can turn on unencrypted connections for HTTP/2. Vous pouvez activer cela en définissant la variable d’environnement DOTNET_SYSTEM_NET_HTTP_SOCKETSHTTPHANDLER_HTTP2UNENCRYPTEDSUPPORT sur 1 ou en l’activant dans le contexte de l’application :You can turn it on by setting the DOTNET_SYSTEM_NET_HTTP_SOCKETSHTTPHANDLER_HTTP2UNENCRYPTEDSUPPORT environment variable to 1 or by enabling it in the app context:

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

Étapes suivantes :Next steps