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 16,3, Visual Studio pour Mac 8,3ou Visual Studio code avec l' C# extension.It's highly recommended that you use Visual Studio 2019 16.3, Visual Studio for Mac 8.3, or Visual Studio Code with the 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.

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.

C# 8.0C# 8.0

C#8,0 fait également partie de cette version, qui comprend la fonctionnalité de types de référence Nullable, les flux asynchrones et 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.

.NET Standard 2.1.NET Standard 2.1

Même si .NET Core 3,0 prend en charge .NET Standard 2,1, le modèle dotnet new classlib par défaut génère un projet qui cible toujours .NET standard 2,0.Even though .NET Core 3.0 supports .NET Standard 2.1, 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.

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. 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
//   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.

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.

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 ce que le code nécessite et 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 de manière plus adaptative le compilateur juste-à-temps (Just-In-Time ou JIT) pour obtenir de meilleures performances.This feature enables the runtime to more adaptively use the Just-In-Time (JIT) compiler to get better performance.

Le principal avantage de la compilation hiérarchisée est d’autoriser les méthode (re-) JIT avec un niveau de moins bonne qualité mais plus rapide, ou avec un niveau de meilleure qualité mais plus lent.The main benefit of TC is to enable (re-)jitting methods with a lower-quality-but-faster tier or a higher-quality-but-slower tier. Cela permet d’améliorer les performances d’une application quand elle passe par les différents stades de l’exécution, du démarrage à l’état stable.This helps increase performance of an application as it goes through various stages of execution, from startup through steady-state. Ceci contraste avec l’approche de la compilation non hiérarchisée, où chaque méthode est compilée d’une seule manière (la même que le niveau de qualité supérieure), qui privilégie la stabilité de l’état au détriment des performances au démarrage.This contrasts with the non-TC approach, where every method is compiled a single way (the same as the high-quality tier), which is biased to steady-state over startup performance.

Pour activer Quick JIT (code JIT de niveau 0), utilisez ce paramétrage dans votre fichier projet :To enable Quick JIT (tier 0 jitted code), use this setting in your project file:

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

Pour désactiver complètement la compilation hiérarchisée, utilisez ce paramétrage dans votre fichier projet :To disable TC completely, use this setting in your project file:

<TieredCompilation>false</TieredCompilation>

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 projetAdd 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 true
    

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.

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.

Restauration par progression d’une version majeureMajor-version 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 config du runtime : rollForwardRuntime 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.

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.

Composants appelables par COM : Windows DesktopCOM-callable components - Windows Desktop

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.

Déploiement MSIX : Windows DesktopMSIX Deployment - Windows Desktop

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>

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.

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.

Améliorations apportées à la virgule flottante IEEEIEEE Floating-point improvements

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. Par exemple, FusedMultiplyAdd(1e308, 2.0, -1e308) retourne 1e308.An example would be 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.

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

Les utilisateurs de .NET se sont largement appuyés sur Json.NET et d’autres bibliothèques JSON populaires, qui restent de bons choix..NET users have largely relied on Json.NET and other popular JSON libraries, which continue to be good choices. Json.NET utilise des chaînes .NET comme type de données de base, au format UTF-16.Json.NET uses .NET strings as its base datatype, which is UTF-16 under the hood.

La nouvelle prise en charge JSON intégrée offre des hautes performances et une allocation faible, et elle est basée sur Span<byte>.The new built-in JSON support is high-performance, low allocation, and based on Span<byte>. Trois nouveaux types principaux liés à JSON ont été ajoutés à l’espace de noms System.Text.Json de .NET Core 3.0.Three new main JSON-related types have been added to .NET Core 3.0 the System.Text.Json namespace. Ces types ne prennent pas encore en charge la sérialisation et la désérialisation des objets CLR traditionnels (OCT).These types don't yet support plain old CLR object (POCO) serialization and deserialization.

Utf8JsonReaderUtf8JsonReader

System.Text.Json.Utf8JsonReader est un lecteur hautes performances et à faible allocation de type forward-only pour le texte JSON codé au format UTF-8 et lu à partir de ReadOnlySpan<byte>.System.Text.Json.Utf8JsonReader is a high-performance, low allocation, forward-only reader for UTF-8 encoded JSON text, read from a ReadOnlySpan<byte>. Utf8JsonReader est un type fondamental de bas niveau, permettant de générer des analyseurs et des désérialiseurs personnalisés.The Utf8JsonReader is a foundational, low-level type, that can be used to build custom parsers and deserializers. La lecture d’une charge utile JSON à l’aide du nouveau Utf8JsonReader est 2 fois plus rapide qu’avec le lecteur proposé par Json.NET.Reading through a JSON payload using the new Utf8JsonReader is 2x faster than using the reader from Json.NET. Aucune allocation n’a lieu tant que vous n’avez pas besoin d’actualiser des jetons JSON sous forme de chaînes (UTF-16).It doesn't allocate until you need to actualize JSON tokens as (UTF-16) strings.

Voici un exemple de lecture par le biais du fichier launch.json créé par Visual Studio Code :Here is an example of reading through the launch.json file created by Visual Studio Code:

public static void PrintJson(ReadOnlySpan<byte> dataUtf8)
{
    var json = new Utf8JsonReader(dataUtf8, isFinalBlock: true, state: default);
    
    while (json.Read())
    {
        JsonTokenType tokenType = json.TokenType;
        ReadOnlySpan<byte> valueSpan = json.ValueSpan;
        switch (tokenType)
        {
            case JsonTokenType.StartObject:
            case JsonTokenType.EndObject:
                break;
            case JsonTokenType.StartArray:
            case JsonTokenType.EndArray:
                break;
            case JsonTokenType.PropertyName:
                break;
            case JsonTokenType.String:
                Console.WriteLine($"STRING: {json.GetString()}");
                break;
            case JsonTokenType.Number:
                if (!json.TryGetInt32(out int valueInteger))
                {
                    throw new FormatException();
                }
                break;
            case JsonTokenType.True:
            case JsonTokenType.False:
                Console.WriteLine($"BOOL: {json.GetBoolean()}");
                break;
            case JsonTokenType.Null:
                break;
            default:
                throw new ArgumentException();
        }
    }

    dataUtf8 = dataUtf8.Slice((int)json.BytesConsumed);
    JsonReaderState state = json.CurrentState;
}
// Calling code
Console.WriteLine("Read with Utf8JsonReader");
PrintJson(File.ReadAllBytes("launch.json").AsSpan());

Utf8JsonWriterUtf8JsonWriter

System.Text.Json.Utf8JsonWriter fournit un moyen d’écrire du texte JSON encodé en UTF-8 partir de types .NET courants, comme String, Int32, et DateTime, avec des hautes performances, sans mise en cache et vers l’avant uniquement.System.Text.Json.Utf8JsonWriter provides a high-performance, non-cached, forward-only way to write UTF-8 encoded JSON text from common .NET types like String, Int32, and DateTime. Comme le lecteur, l’enregistreur (writer) est un type fondamental de bas niveau, permettant de générer des sérialiseurs personnalisés.Like the reader, the writer is a foundational, low-level type, that can be used to build custom serializers. L’écriture d’une charge utile JSON avec le nouveau Utf8JsonWriter est de 30 à 80 % plus rapide qu’avec l’enregistreur (writer) de Json.NET et elle n’effectue pas d’allocation.Writing a JSON payload using the new Utf8JsonWriter is 30-80% faster than using the writer from Json.NET and doesn't allocate.

JsonDocumentJsonDocument

System.Text.Json.JsonDocument est basé sur le Utf8JsonReader.System.Text.Json.JsonDocument is built on top of the Utf8JsonReader. Le JsonDocument fournit la possibilité d’analyser les données JSON et de générer un modèle DOM (Document Object Model) qui peut être interrogé, et prendre en charge l’accès aléatoire et l’énumération.The JsonDocument provides the ability to parse JSON data and build a read-only Document Object Model (DOM) that can be queried to support random access and enumeration. Les éléments JSON qui composent les données sont accessibles via le type JsonElement qui est exposé par le JsonDocument comme propriété appelée RootElement.The JSON elements that compose the data can be accessed via the JsonElement type that is exposed by the JsonDocument as a property called RootElement. Le JsonElement contient le tableau et les énumérateurs d’objets JSON, ainsi que des API pour convertir le texte JSON en types .NET courants.The JsonElement contains the JSON array and object enumerators along with APIs to convert JSON text to common .NET types. L’analyse d’une charge utile JSON classique et l’accès à tous ses membres avec le JsonDocument est de 2 à 3 fois plus rapide que Json.NET, avec peu d’allocations pour les données de dimension raisonnable (c’est-à-dire, < 1 Mo).Parsing a typical JSON payload and accessing all its members using the JsonDocument is 2-3x faster than Json.NET with little allocations for data that is reasonably sized (that is, < 1 MB).

Voici un exemple d’utilisation de JsonDocument et de JsonElement, qui peut être utilisé comme point de départ :Here is a sample usage of the JsonDocument and JsonElement that can be used as a starting point:

public static void ReadJson(string jsonString)
{
    using var document = JsonDocument.Parse(jsonString);

    var root = document.RootElement;
    var version = root.GetProperty("version").GetString();
    var configurations = root.GetProperty("configurations");

    Console.WriteLine($"Launch Version: {version}");

    foreach (var config in configurations.EnumerateArray())
    {
        var name = config.GetProperty("name").GetString();
        Console.WriteLine($"Config: {name}");
    }
}

Voici un exemple C# 8.0 de lecture par le biais du fichier launch.json créé par Visual Studio Code :Here is a C# 8.0 example of reading through the launch.json file created by Visual Studio Code:

// Calling code
Console.WriteLine("Read with JsonDocument");
ReadJson(File.ReadAllText("launch.json"));

JsonSerializerJsonSerializer

System.Text.Json.JsonSerializer s’appuie sur Utf8JsonReader et Utf8JsonWriter pour fournir une option de sérialisation rapide à faible consommation de mémoire quand vous utilisez des fragments et des documents JSON.System.Text.Json.JsonSerializer is built on top of Utf8JsonReader and Utf8JsonWriter to provide a fast, low-memory serialization option when working with JSON documents and fragments.

Voici un exemple de sérialisation d’un objet dans le format JSON :Here is an example of serializing an object to JSON:

var instance = new
{
    FirstName = "John",
    LastName = "Smith",
    Age = 18
};

System.Console.WriteLine(System.Text.Json.JsonSerializer.Serialize(instance));

Voici un exemple de désérialisation d’une chaîne JSON en un objet.Here is an example of deserializing a JSON string to an object. Vous pouvez utiliser la chaîne JSON produite par l’exemple précédent :You can use the JSON string produced by the previous example:

public class JsonPerson
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public int Age { get; set; }

    public static JsonPerson Parse(string json) =>
        System.Text.Json.JsonSerializer.Deserialize<JsonPerson>(json);
}

Améliorations de l’interopérabilitéInterop improvements

.NET Core 3.0 améliore l’interopérabilité des API natives..NET Core 3.0 improves native API interop.

Type : NativeLibraryType: NativeLibrary

System.Runtime.InteropServices.NativeLibrary fournit une encapsulation pour le chargement d’une bibliothèque native (à l’aide de la même logique de chargement que .NET Core P/Invoke) et la fourniture des fonctions d’assistance pertinentes telles que getSymbol.System.Runtime.InteropServices.NativeLibrary provides an encapsulation for loading a native library (using the same load logic as .NET Core P/Invoke) and providing the relevant helper functions such as getSymbol. Pour obtenir un exemple de code, consultez la démonstration DLLMap.For a code example, see the DLLMap 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.

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

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.

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.

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.

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.