Neuerungen in .NET Core 3.0 (Preview 6)What's new in .NET Core 3.0 (Preview 6)

In diesem Artikel werden Neuerungen in .NET Core 3.0 (in Preview 6) beschrieben.This article describes what is new in .NET Core 3.0 (through preview 6). Eine der wichtigsten Verbesserungen ist die Unterstützung für Windows-Desktopanwendungen (nur Windows).One of the biggest enhancements is support for Windows desktop applications (Windows only). Mit der .NET Core 3.0 SDK-Komponente Windows Desktop können Sie Ihre Windows Forms- und WPF-Anwendungen (Windows Presentation Foundation) portieren.By using the .NET Core 3.0 SDK component Windows Desktop, you can port your Windows Forms and Windows Presentation Foundation (WPF) applications. Die Windows Desktop-Komponente wird ausdrücklich nur für Windows unterstützt und ist nur unter Windows enthalten.To be clear, the Windows Desktop component is only supported and included on Windows. Weitere Informationen finden Sie im Abschnitt Windows-Desktop weiter unten in diesem Artikel.For more information, see the Windows desktop section later in this article.

.NET Core 3.0 bietet Unterstützung für C# 8.0..NET Core 3.0 adds support for C# 8.0. Verwenden Sie unbedingt die neueste Vorschauversion von Visual Studio oder Visual Studio Code mit der OmniSharp-Erweiterung.It's highly recommended that you use the latest release of Visual Studio Preview, or Visual Studio Code with the OmniSharp extension.

Sie können .NET Core 3.0 Vorschauversion 6 jetzt für Windows, Mac und Linux herunterladen und sofort starten.Download and get started with .NET Core 3.0 Preview 6 right now on Windows, Mac, and Linux.

Weitere Informationen zu den einzelnen Vorschauversionen finden Sie in den folgenden Ankündigungen:For more information about each preview release, see the following announcements:

Windows Installer von .NET Core SDK.NET Core SDK Windows Installer

Das MSI-Installationsprogramm für Windows wurde ab .NET Core 3.0 geändert.The MSI installer for Windows has changed starting with .NET Core 3.0. Die SDK-Installer aktualisieren nun vorhandene Releases von SDK-Featuregruppen.The SDK installers will now upgrade SDK feature-band releases in place. Featuregruppen werden in den Hundertergruppen des Patchabschnitts der Versionsnummer definiert.Feature bands are defined in the hundreds groups in the patch section of the version number. 3.0.*101* und 3.0.*201* sind z.B. Versionen in zwei verschiedenen Featuregruppen, während 3.0.*101* und 3.0.*199* sich in derselben Featuregruppe befinden.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. Wenn .NET Core SDK 3.0.*101* installiert wird, wird .NET Core SDK 3.0.*100* – sofern vorhanden – vom Computer entfernt.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. Wenn .NET Core SDK 3.0.*200* installiert wird, wird ein ggf. auf dem gleichen Computer vorhandenes .NET Core SDK 3.0.*101* nicht entfernt.When .NET Core SDK 3.0.*200* is installed on the same machine, .NET Core SDK 3.0.*101* won't be removed.

Weitere Informationen zur Versionsverwaltung finden Sie unter Übersicht über die .NET Core-Versionsverwaltung.For more information about versioning, see Overview of how .NET Core is versioned.

C# 8.0 VorschauversionC# 8.0 preview

.NET Core 3.0 unterstützt C# 8 Vorschauversion..NET Core 3.0 supports C# 8 preview. Weitere Informationen zu Features von C# 8.0 finden Sie unter Neues in 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

Obwohl .NET Core 3.0 .NET Standard 2.1 unterstützt, generiert die Standardvorlage dotnet new classlib ein Projekt für .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 targets .NET Standard 2.0. Ändern Sie für .NET Standard 2.1 in Ihrer Projektdatei die TargetFramework-Eigenschaft in 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>

Wenn Sie Visual Studio verwenden, benötigen Sie Visual Studio 2019, da Visual Studio 2017 .NET Standard 2.1 und .NET Core 3.0 nicht unterstützt.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.

Verbesserte .NET Core-Versions-APIsImproved .NET Core Version APIs

Ab .NET Core 3.0 geben die mit .NET Core gelieferten Versions-APIs jetzt die Informationen zurück, die Sie erwarten.Starting with .NET Core 3.0, the version APIs provided with .NET Core now return the information you expect. Beispiel: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

Warnung

Entscheidende Änderung.Breaking change. Dies ist technisch gesehen eine entscheidende Änderung, da das Schema der Versionsverwaltung sich geändert hat.This is technically a breaking change because the versioning scheme has changed.

Von der .NET-Plattform abhängige systeminterne Funktionen.NET Platform-Dependent Intrinsics

Mit neuen APIs kann auf bestimmte leistungsorientierte CPU-Anweisungen wie SIMD oder Bit Manipulation Instruction Sets zugegriffen werden.APIs have been added that allow access to certain perf-oriented CPU instructions, such as the SIMD or Bit Manipulation instruction sets. Diese Anweisungen können in bestimmten Szenarios wie der effizienten parallelen Datenverarbeitung zu deutlichen Leistungssteigerungen führen.These instructions can help achieve significant performance improvements in certain scenarios, such as processing data efficiently in parallel.

Wo möglich, haben die .NET-Bibliotheken begonnen, mithilfe dieser Anweisungen die Leistung zu verbessern.Where appropriate, the .NET libraries have begun using these instructions to improve performance.

Weitere Informationen finden Sie unter .NET Platform Dependent Intrinsics (Von der .NET-Plattform abhängige systeminterne Funktionen).For more information, see .NET Platform Dependent Intrinsics.

Standardmäßig ausführbare DateienDefault executables

.NET Core erstellt die frameworkabhängigen ausführbaren Dateien jetzt standardmäßig..NET Core now builds framework-dependent executables by default. Dieses Verhalten ist neu für Anwendungen, die eine global installierte Version von .NET Core verwenden.This behavior is new for applications that use a globally installed version of .NET Core. Vorher produzierten nur eigenständige Bereitstellungen eine ausführbare Datei.Previously, only self-contained deployments would produce an executable.

Während dotnet build oder dotnet publish wird eine ausführbare Datei erstellt, die der Umgebung und Plattform des von Ihnen verwendeten SDKs entspricht.During dotnet build or dotnet publish, an executable is created that matches the environment and platform of the SDK you're using. Diese ausführbaren Dateien bieten Ihnen die gleichen Möglichkeiten wie andere native ausführbare Dateien, wie z.B.:You can expect the same things with these executables as you would other native executables, such as:

  • Sie können die ausführbare Datei doppelklicken.You can double-click on the executable.
  • Sie können die Anwendung direkt aus einer Eingabeaufforderung starten, z.B. myapp.exe unter Windows und ./myapp unter Linux und MacOS.You can launch the application from a command prompt directly, such as myapp.exe on Windows, and ./myapp on Linux and macOS.

Ausführbare EinzeldateienSingle-file executables

Der dotnet publish-Befehl unterstützt das Verpacken der App in einer plattformspezifischen ausführbaren Einzeldatei.The dotnet publish command supports packaging your app into a platform-specific single-file executable. Die ausführbare Datei ist selbstextrahierend und enthält alle Abhängigkeiten (einschließlich der nativen), die zum Ausführen der App erforderlich sind.The executable is self-extracting and contains all dependencies (including native) that are required to run your app. Beim ersten Ausführen der App wird die Anwendung in ein Verzeichnis extrahiert, das auf dem Namen und dem Buildbezeichner der App basiert.When the app is first run, the application is extracted to a directory based on the app name and build identifier. Der Start ist beim erneuten Ausführen der App schneller.Startup is faster when the application is run again. Die Anwendung muss sich nicht selbst ein zweites Mal extrahieren, sofern keine neue Version verwendet wird.The application doesn't need to extract itself a second time unless a new version was used.

Legen Sie zum Veröffentlichen einer einzelnen ausführbaren Datei PublishSingleFile in Ihrem Projekt oder in der Befehlszeile mit dem dotnet publish-Befehl fest: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>

Oder-or-

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

Weitere Informationen zum Veröffentlichen einzelner Dateien finden Sie im Einzeldatei-Bundler-Entwurfsdokument.For more information about single-file publishing, see the single-file bundler design document.

Verknüpfen von AssemblysAssembly linking

Das.NET Core 3.0 SDK bietet ein Tool, das die Größe von Apps reduzieren kann, indem es IL analysiert und ungenutzte Assemblys trimmt.The .NET core 3.0 SDK comes with a tool that can reduce the size of apps by analyzing IL and trimming unused assemblies.

Eigenständige Apps enthalten alles, was zum Ausführen Ihres Codes benötigt wird, ohne dass .NET auf dem Hostcomputer installiert sein muss.Self-contained apps include everything needed to run your code, without requiring .NET to be installed on the host computer. Allerdings benötigt die App oft nur eine kleine Teilmenge des Frameworks, um zu funktionieren, sodass andere ungenutzte Bibliotheken entfernt werden können.However, many times the app only requires a small subset of the framework to function, and other unused libraries could be removed.

.NET Core bietet nun eine Einstellung, die das Tool IL linker verwendet, um die IL Ihrer App zu untersuchen..NET Core now includes a setting that will use the IL linker tool to scan the IL of your app. Dieses Tool erkennt, welcher Code benötigt wird, und trimmt dann ungenutzte Bibliotheken.this tool detects what code is required, and then trims unused libraries. Es kann die Bereitstellungsgröße einiger Apps deutlich reduzieren.This tool can significantly reduce the deployment size of some apps.

Fügen Sie die Einstellung <PublishTrimmed> zu Ihrem Projekt hinzu, und veröffentlichen Sie eine eigenständige App, um dieses Tool zu aktivieren: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

Als Beispiel erreicht die inbegriffene Standardvorlage für neue Konsolenprojekte „hello world“ bei ihrer Veröffentlichung eine Größe von ca.70 MB.As an example, the basic "hello world" new console project template that is included, when published, hits about 70 MB in size. Mithilfe von <PublishTrimmed> wird diese Größe auf ca. 30 MB reduziert.By using <PublishTrimmed>, that size is reduced to about 30 MB.

Wichtig ist die Tatsache, dass Anwendungen oder Frameworks (einschließlich ASP.NET Core und WPF), die Reflektion oder verwandte dynamische Funktionen verwenden, nach dem Trimmen oft nicht mehr funktionieren.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. Dies ist der Fall, weil der Linker von diesem dynamischen Verhalten nichts weiß und nicht bestimmen kann, welche Frameworktypen für die Reflektion benötigt werden.This breakage occurs because the linker doesn't know about this dynamic behavior and can't determine which framework types are required for reflection. Das Tool IL Linker kann so konfiguriert werden, dass es sich dieses Szenarios bewusst ist.The IL Linker tool can be configured to be aware of this scenario.

Nach dem Trimmen müssen Sie Ihre App unbedingt testen.Above all else, be sure to test your app after trimming.

Weitere Informationen zum Tool IL Linker finden Sie in der Dokumentation, oder besuchen Sie das Repository mono/linker.For more information about the IL Linker tool, see the documentation or visit the mono/linker repo.

Mehrstufig KompilierungTiered compilation

Die mehrstufige Kompilierung (Tiered Compilation, TC) ist bei .NET Core 3.0 standardmäßig aktiviert.Tiered compilation (TC) is on by default with .NET Core 3.0. Dieses Feature ermöglicht der Runtime, den Just-In-Time-Compiler (JIT) adaptiver zu nutzen, um eine bessere Leistung zu erzielen.This feature enables the runtime to more adaptively use the Just-In-Time (JIT) compiler to get better performance.

Der Hauptvorteil von TC ist, Methoden zur (erneuten) Just-in-Time-Kompilierung mit „Slower-but-faster“- oder „Higher-Quality-but-slower“-Verfahren zum Erzeugen von Code zu ermöglichen.The main benefit of TC is to enable (re-)jitting methods with slower-but-faster to produce code or higher-quality-but-slower to produce code. Dies steigert die Leistung einer Anwendung, während sie verschiedene Phasen der Ausführung vom Start bis zum stabilen Zustand durchläuft.This helps increase performance of an application as it goes through various stages of execution, from startup through steady-state. Dies steht im Gegensatz zum Nicht-TC-Ansatz, wo jede Methode auf eine einzelne Art kompiliert wird (identisch mit der Hochwertigkeitsstufe) und der Trend eher zum stabilen Zustand als zur Startleistung geht.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.

Um schnelle Just-in-Time-Kompilierung (auf Stufe 0 Just-in-Time-kompilierter Code) zu aktivieren, verwenden Sie diese Einstellung in Ihrer Projektdatei:To enable Quick JIT (tier 0 jitted code), use this setting in your project file:

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

Um TC vollständig zu deaktivieren, verwenden Sie diese Einstellung in Ihrer Projektdatei:To disable TC completely, use this setting in your project file:

<TieredCompilation>false</TieredCompilation>

ReadyToRun-ImagesReadyToRun images

Sie können die Startzeit Ihrer.NET Core-Anwendung beschleunigen, indem Sie Ihre Anwendungsassemblys im R2R-Format (ReadyToRun) kompilieren.You can improve the startup time of your .NET Core application by compiling your application assemblies as ReadyToRun (R2R) format. R2R ist eine Form der AOT-Kompilierung (Ahead-Of-Time).R2R is a form of ahead-of-time (AOT) compilation.

R2R-Binärdateien verbessern die Startleistung, indem sie den Arbeitsaufwand des JIT-Compilers (Just-in-time) reduzieren, der anfällt, wenn Ihre Anwendung geladen wird.R2R binaries improve startup performance by reducing the amount of work the just-in-time (JIT) compiler needs to do as your application loads. Die Binärdateien enthalten ähnlichen nativen Code im Vergleich zu dem, was der JIT-Compiler produzieren würde.The binaries contain similar native code compared to what the JIT would produce.

R2R-Binärdateien sind größer, da sie sowohl IL-Code (Intermediate Language, Zwischensprache), der für einige Szenarien noch benötigt wird, als auch die native Version des gleichen Codes enthalten.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 ist nur verfügbar, wenn Sie eine eigenständige Anwendung veröffentlichen, die eine bestimmte Laufzeitumgebung (RID) wie Linux x64 oder Windows x64 als Ziel hat.R2R is only available when you publish a self-contained app that targets a specific runtime environments (RID) such as Linux x64 or Windows x64.

Um Ihre App als R2R zu kompilieren, fügen Sie die Einstellung <PublishReadyToRun> hinzu:To compile your app as R2R, add the <PublishReadyToRun> setting:

<PropertyGroup>
  <PublishReadyToRun>true</PublishReadyToRun>
</PropertyGroup>

Veröffentlichen Sie eine eigenständige App.Publish a self-contained app. Dieser Befehl erstellt beispielsweise eine eigenständige App für die 64-Bit-Version von 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

Plattformübergreifende bzw. architekturbezogene EinschränkungenCross platform/architecture restrictions

Der ReadyToRun-Compiler unterstützt derzeit nicht die versionsübergreifende Angabe von Zielen.The ReadyToRun compiler doesn't currently support cross-targeting. Die Kompilierung muss für ein bestimmtes Ziel erfolgen.You must compile on a given target. Wenn Sie beispielsweise R2R-Images für Windows x64 benötigen, müssen Sie den Veröffentlichungsbefehl in dieser Umgebung ausführen.For example, if you want R2R images for Windows x64, you need to run the publish command on that environment.

Ausnahmen für die versionsübergreifende Angabe von Zielen:Exceptions to cross-targeting:

  • Windows x64 kann verwendet werden, um Windows ARM32-, ARM64- und x86-Images zu kompilieren.Windows x64 can be used to compile Windows ARM32, ARM64, and x86 images.
  • Windows x86 kann verwendet werden, um Windows ARM32-Images zu kompilieren.Windows x86 can be used to compile Windows ARM32 images.
  • Linux X64 kann verwendet werden, um Linux ARM32- und -ARM64-Images zu kompilieren.Linux x64 can be used to compile Linux ARM32 and ARM64 images.

Build kopiert AbhängigkeitenBuild copies dependencies

Der dotnet build-Befehl kopiert jetzt NuGet-Abhängigkeiten für Ihre Anwendung aus dem NuGet-Cache in den Buildausgabeordner.The dotnet build command now copies NuGet dependencies for your application from the NuGet cache to the build output folder. Bisher wurde Abhängigkeiten nur als Teil von dotnet publish kopiert.Previously, dependencies were only copied as part of dotnet publish.

Es gibt einige Vorgänge, wie das Verlinken und das Veröffentlichen von Razor-Seiten, die noch veröffentlicht werden müssen.There are some operations, like linking and razor page publishing that will still require publishing.

Lokale ToolsLocal tools

Mit .NET Core 3.0 werden lokale Tools eingeführt..NET Core 3.0 introduces local tools. Lokale Tools ähneln globalen Tools, sind aber mit einem bestimmten Speicherort auf dem Datenträger verknüpft.Local tools are similar to global tools but are associated with a particular location on disk. Lokale Tools sind nicht global verfügbar und werden als NuGet-Pakete verteilt.Local tools aren't available globally and are distributed as NuGet packages.

Warnung

Wenn Sie lokale Tools in .NET Core 3.0 Preview 1 ausprobiert haben, z.B. Ausführung von dotnet tool restore oder dotnet tool install, löschen Sie den Cacheordner der lokalen Tools.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. Andernfalls funktionieren die lokalen Tools nicht in einem neueren Release.Otherwise, local tools won't work on any newer release. Je nach Betriebssystem werden die Ordnerpfade wie folgt gelöscht:This folder is located at:

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

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

Lokale Tools basieren auf einer Manifestdatei dotnet-tools.json in Ihrem aktuellen Verzeichnis.Local tools rely on a manifest file name dotnet-tools.json in your current directory. In dieser Manifestdatei werden die Tools festgelegt, die im Verzeichnis und in den Unterverzeichnissen verfügbar sind.This manifest file defines the tools to be available at that folder and below. Sie können die Manifestdatei mit dem Code verteilen, um sicherzustellen, dass jeder Benutzer, der mit Ihrem Code arbeitet, dieselben Tools wiederherstellen und verwenden kann.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.

Für sowohl globale als auch lokale Tools ist eine kompatible Version der Runtime erforderlich.For both global and local tools, a compatible version of the runtime is required. Die meisten Tools führen derzeit NuGet.org target .NET Core Runtime 2.1 aus.Many tools currently on NuGet.org target .NET Core Runtime 2.1. Um diese Tools global oder lokal zu installieren, müssten Sie weiterhin die NET Core 2.1-Runtime installieren.To install these tools globally or locally, you would still need to install the NET Core 2.1 Runtime.

Rollforward der HauptversionMajor-version Roll Forward

Mit .NET Core 3.0 wird ein Aktivierungsfeature eingeführt, das Ihrer App ein Rollforward auf die neueste Hauptversion von .NET Core ermöglicht..NET Core 3.0 introduces an opt-in feature that allows your app to roll forward to the latest major version of .NET Core. Darüber hinaus wurde eine neue Einstellung hinzugefügt, um zu steuern, wie ein Rollforward auf Ihre App angewendet wird.Additionally, a new setting has been added to control how roll forward is applied to your app. Diese kann folgendermaßen konfiguriert werden:This can be configured in the following ways:

  • Projektdateieigenschaft: RollForwardProject file property: RollForward
  • Runtimekonfigurationsdatei-Eigenschaft: rollForwardRuntime configuration file property: rollForward
  • Umgebungsvariable: DOTNET_ROLL_FORWARDEnvironment variable: DOTNET_ROLL_FORWARD
  • Befehlszeilenargument: --roll-forwardCommand-line argument: --roll-forward

Einer der folgenden Werte muss angegeben werden.One of the following values must be specified. Wenn die Einstellung ausgelassen wird, ist Minor die Standardeinstellung.If the setting is omitted, Minor is the default.

  • LatestPatchLatestPatch
    Rollforward zur höchsten Patchversion.Roll forward to the highest patch version. Dies deaktiviert ein Rollforward zur Nebenversion.This disables minor version roll forward.
  • MinorMinor
    Rollforward zur niedrigsten höheren Nebenversion, wenn die angeforderte Nebenversion nicht vorhanden ist.Roll forward to the lowest higher minor version, if requested minor version is missing. Wenn die angeforderte Nebenversion vorhanden ist, wird die LatestPatch-Richtlinie verwendet.If the requested minor version is present, then the LatestPatch policy is used.
  • MajorMajor
    Rollforward zur niedrigsten höheren Hauptversion – und niedrigsten Nebenversion, wenn die angeforderte Hauptversion nicht vorhanden ist.Roll forward to lowest higher major version, and lowest minor version, if requested major version is missing. Wenn die angeforderte Hauptversion vorhanden ist, wird die Minor-Richtlinie verwendet.If the requested major version is present, then the Minor policy is used.
  • LatestMinorLatestMinor
    Rollforward zur höchsten Nebenversion – auch dann, wenn die angeforderte Nebenversion vorhanden ist.Roll forward to highest minor version, even if requested minor version is present. Für Komponentenhostingszenarien vorgesehen.Intended for component hosting scenarios.
  • LatestMajorLatestMajor
    Rollforward zur höchsten Hauptversion und höchsten Nebenversion – auch dann, wenn die angeforderte Hauptversion vorhanden ist.Roll forward to highest major and highest minor version, even if requested major is present. Für Komponentenhostingszenarien vorgesehen.Intended for component hosting scenarios.
  • DisableDisable
    Kein Rollforward.Don't roll forward. Nur Binden an angegebene Version.Only bind to specified version. Diese Richtlinie wird nicht zur allgemeinen Verwendung empfohlen, da sie die Möglichkeit eines Rollforwards zu den neuesten Patches ausschließt.This policy isn't recommended for general use because it disables the ability to roll forward to the latest patches. Dieser Wert wird nur zu Testzwecken empfohlen.This value is only recommended for testing.

Abgesehen von der Disable-Einstellung verwenden alle Einstellungen die höchste verfügbare Patchversion.Besides the Disable setting, all settings will use the highest available patch version.

Windows-DesktopWindows desktop

.NET Core 3.0 unterstützt die Windows-Desktopanwendungen mit Windows Presentation Foundation (WPF) und Windows Forms..NET Core 3.0 supports Windows desktop applications using Windows Presentation Foundation (WPF) and Windows Forms. Diese Frameworks unterstützt auch die Verwendung moderner Steuerelemente und des Fluent-Stils aus der Windows-UI-XAML-Bibliothek (WinUI) über XAML-Inseln.These frameworks also support using modern controls and Fluent styling from the Windows UI XAML Library (WinUI) via XAML islands.

Die Windows Desktop-Komponente ist Teil des Windows .NET Core 3.0 SDK.The Windows Desktop component is part of the Windows .NET Core 3.0 SDK.

Mit dem folgenden dotnet-Befehl können Sie eine neue WPF- oder Windows Forms-Anwendung erstellen:You can create a new WPF or Windows Forms app with the following dotnet commands:

dotnet new wpf
dotnet new winforms

Neu in Visual Studio 2019 sind Vorlagen für die Option Neues Projekt für Windows Forms und WPF in .NET Core 3.0.Visual Studio 2019 adds New Project templates for .NET Core 3.0 Windows Forms and WPF.

Weitere Informationen zum Portieren einer vorhandenen .NET Framework-Anwendung finden Sie unter Portieren von WPF-Projekten und Portieren von Windows Forms-Projekten.For more information about how to port an existing .NET Framework application, see Port WPF projects and Port Windows Forms projects.

COM-aufrufbare Komponenten – Windows-DesktopCOM-callable components - Windows Desktop

Unter Windows können Sie jetzt COM-aufrufbare verwaltete Komponenten erstellen.On Windows, you can now create COM-callable managed components. Diese Funktion ist für die Verwendung von .NET Core mit COM-Add-in-Modellen und auch zur Parität mit .NET Framework wichtig.This capability is critical to use .NET Core with COM add-in models and also to provide parity with .NET Framework.

Im Gegensatz zu .NET Framework, wo mscoree.dll als COM-Server verwendet wurde, fügt .NET Core dem bin-Verzeichnis eine native Startprogramm-DLL hinzu, wenn Sie Ihre COM-Komponente erstellen.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.

Ein Beispiel für das Erstellen einer COM‑Komponente und ihre Verwendung finden Sie in der COM-Demo.For an example of how to create a COM component and consume it, see the COM Demo.

MSIX-Bereitstellung – Windows-DesktopMSIX Deployment - Windows Desktop

MSIX ist ein neues Windows-Anwendungspaketformat.MSIX is a new Windows application package format. Es kann zum Bereitstellen von .NET Core 3.0-Desktopanwendungen auf Windows 10 verwendet werden.It can be used to deploy .NET Core 3.0 desktop applications to Windows 10.

In Visual Studio 2019 können mit dem enthaltenen Paketerstellungsprojekt für Windows-Anwendungen MSIX-Pakete mit eigenständigen .NET Core-Anwendungen erstellt werden.The Windows Application Packaging Project, available in Visual Studio 2019, allows you to create MSIX packages with self-contained .NET Core applications.

Die unterstützten Laufzeiten müssen in der <RuntimeIdentifiers>-Eigenschaft der .NET Core-Projektdatei angegeben werden:The .NET Core project file must specify the supported runtimes in the <RuntimeIdentifiers> property:

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

WinForms – hohe DPI-WerteWinForms HighDPI

.NET Core-Windows Forms-Anwendungen können den Modus für hohe DPI-Werte mit Application.SetHighDpiMode(HighDpiMode) festlegen..NET Core Windows Forms applications can set High DPI mode with Application.SetHighDpiMode(HighDpiMode). Die SetHighDpiMode-Methode legt den entsprechenden Modus für hohe DPI-Werte fest, sofern er nicht mit anderen Mitteln wie App.Manifest oder „P/Invoke“ vor dem Application.Run festgelegt wurde.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.

Die möglichen highDpiMode-Werte, wie durch die System.Windows.Forms.HighDpiMode-Enumeration ausgedrückt, sind:The possible highDpiMode values, as expressed by the System.Windows.Forms.HighDpiMode enum are:

  • DpiUnaware
  • SystemAware
  • PerMonitor
  • PerMonitorV2
  • DpiUnawareGdiScaled

Weitere Informationen zu hohen DPI-Werten finden Sie unter Entwicklung von Desktopanwendungen mit hohen DPI-Werten unter Windows.For more information about High DPI modes, see High DPI Desktop Application Development on Windows.

Bereiche und IndizesRanges and indices

Der neue System.Index-Typ kann für die Indizierung verwendet werden.The new System.Index type can be used for indexing. Sie können einen aus einem int erstellen, der vom Anfang aus zählt, oder mit einem Präfix-^-Operator (C#), der vom Ende aus zählt: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"

Es gibt auch einen System.Range-Typ, der aus zwei Index-Werten besteht, einen für den Anfang und einen für das Ende, und mit einem x..y-Bereichsausdruck (C#) geschrieben werden kann.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#). Sie können dann mit einem Range indizieren, der ein Segment erzeugt:You can then index with a Range, which produces a slice:

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

Weitere Informationen finden Sie im Tutorial Bereiche und Indizes.For more information, see the ranges and indices tutorial.

Asynchrone DatenströmeAsync streams

Die IAsyncEnumerable<T>-Typ ist eine neue asynchrone Version von IEnumerable<T>.The IAsyncEnumerable<T> type is a new asynchronous version of IEnumerable<T>. In C# 8.0 können Sie await foreach zur Verarbeitung der IAsyncEnumerable<T>-Elemente nutzen und anschließend yield return zum Erstellen von Elementen verwenden.The language lets you await foreach over IAsyncEnumerable<T> to consume their elements, and use yield return to them to produce elements.

Das folgende Beispiel zeigt sowohl die Produktion als auch die Nutzung von asynchronen Datenströmen.The following example demonstrates both production and consumption of async streams. Die foreach-Anweisung ist asynchron und verwendet yield return, um einen asynchronen Datenstrom für Anrufer zu erstellen.The foreach statement is async and itself uses yield return to produce an async stream for callers. Dieses Muster (mit yield return) ist das empfohlene Modell zum Erstellen von asynchronen Datenströmen.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; 
    }
}

Zusätzlich zu await foreach können Sie auch asynchrone Iteratoren erstellen, z.B. einen Iterator, der IAsyncEnumerable/IAsyncEnumerator zurückgibt, in den Sie sowohl await als auch yield einfügen können.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. Für Objekte, die gelöscht werden müssen, können Sie IAsyncDisposable verwenden, das von verschiedenen BCL-Typen implementiert wird, wie beispielsweise Stream und Timer.For objects that need to be disposed, you can use IAsyncDisposable, which various BCL types implement, such as Stream and Timer.

Weitere Informationen finden Sie im Tutorial Generieren und Nutzen asynchroner Datenströme mit C# 8.0 und .NET Core 3.0.For more information, see the async streams tutorial.

Verbesserungen bei Gleitkommazahlen gemäß IEEE-SpezifikationIEEE Floating-point improvements

APIs für Gleitkommazahlen werden aktuell der Revision des Standards IEEE 754-2008 angepasst.Floating point APIs are being updated to comply with IEEE 754-2008 revision. Ziel dieser Änderungen ist, alle erforderlichen Operationen verfügbar zu machen und sicherzustellen, dass sie mit dem in der IEEE-Spezifikation beschriebenen Verhalten kompatibel sind. Weitere Informationen über Gleitkommaverbesserungen finden Sie im Blogbeitrag Floating-Point Parsing and Formatting improvements in .NET Core 3.0 (Verbesserungen zu Gleitkommaanalyse und Formatierung in .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.

Zu den Korrekturen für Analyse und Formatierung zählen:Parsing and formatting fixes include:

  • Eingaben mit beliebiger Länge werden richtig analysiert und gerundet.Correctly parse and round inputs of any length.
  • Die negative Null wird richtig analysiert und formatiert.Correctly parse and format negative zero.
  • Infinity- und NaN-Werte werden mithilfe einer Überprüfung, bei der nicht zwischen Groß-/Kleinbuchstaben unterschieden wird, richtig analysiert. Außerdem ist, falls erforderlich, optional das vorangestellte +-Zeichen zulässig.Correctly parse Infinity and NaN by doing a case-insensitive check and allowing an optional preceding + where applicable.

Zu den neuen System.Math-APIs zählen:New System.Math APIs include:

  • BitIncrement(Double) und BitDecrement(Double)BitIncrement(Double) and BitDecrement(Double)
    entspricht den IEEE-Operationen nextUp und nextDown.Corresponds to the nextUp and nextDown IEEE operations. Diese geben jeweils die kleinste Gleitkommazahl zurück, die größer oder kleiner als der Eingabewert ist.They return the smallest floating-point number that compares greater or lesser than the input (respectively). Math.BitIncrement(0.0) gibt beispielsweise double.Epsilon zurück.For example, Math.BitIncrement(0.0) would return double.Epsilon.

  • MaxMagnitude(Double, Double) und MinMagnitude(Double, Double)MaxMagnitude(Double, Double) and MinMagnitude(Double, Double)
    entspricht den IEEE-Operationen maxNumMag und minNumMag. Diese geben für zwei Eingabewerte jeweils den Wert zurück, für den ein größerer oder kleinerer Absolutbetrag ermittelt wird.Corresponds to the maxNumMag and minNumMag IEEE operations, they return the value that is greater or lesser in magnitude of the two inputs (respectively). Math.MaxMagnitude(2.0, -3.0) gibt beispielsweise -3.0 zurück.For example, Math.MaxMagnitude(2.0, -3.0) would return -3.0.

  • ILogB(Double)
    Entspricht der IEEE-Operation logB, die einen integralen Wert zurückgibt. Der Rückgabewert ist der integrale Wert des Logarithmus zur Basis 2 des Eingabeparameters.Corresponds to the logB IEEE operation that returns an integral value, it returns the integral base-2 log of the input parameter. Diese Methode entspricht im Wesentlichen floor(log2(x)), jedoch ist der Rundungsfehler minimal.This method is effectively the same as floor(log2(x)), but done with minimal rounding error.

  • ScaleB(Double, Int32)
    Entspricht der IEEE-Operation scaleB, der ein integraler Wert übergeben wird. Zurückgegeben wird im Wesentlichen x * pow(2, n), jedoch ist der Rundungsfehler minimal.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)
    entspricht der IEEE-Operation log2, die den Logarithmus zur Basis 2 zurückgibt.Corresponds to the log2 IEEE operation, it returns the base-2 logarithm. Diese Operation minimiert den Rundungsfehler.It minimizes rounding error.

  • FusedMultiplyAdd(Double, Double, Double)
    entspricht der IEEE-Operation fma, die eine Fused-Multiply-Add-Operation durchführt.Corresponds to the fma IEEE operation, it performs a fused multiply add. Dabei wird (x * y) + z als einzelne Operation ausgeführt, wodurch der Rundungsfehler minimiert wird.That is, it does (x * y) + z as a single operation, there-by minimizing the rounding error. FusedMultiplyAdd(1e308, 2.0, -1e308) gibt beispielsweise 1e308 zurück.An example would be FusedMultiplyAdd(1e308, 2.0, -1e308) which returns 1e308. Die reguläre Operation (1e308 * 2.0) - 1e308 gibt double.PositiveInfinity zurück.The regular (1e308 * 2.0) - 1e308 returns double.PositiveInfinity.

  • CopySign(Double, Double)
    entspricht der IEEE-Operation copySign. Diese gibt den Wert von x mit dem Vorzeichen von y zurück.Corresponds to the copySign IEEE operation, it returns the value of x, but with the sign of y.

Schneller integrierter JSON-SupportFast built-in JSON support

.NET-Benutzer haben sich weitgehend auf Json.NET und andere beliebte JSON-Bibliotheken verlassen, die weiterhin eine gute Wahl sind..NET users have largely relied on Json.NET and other popular JSON libraries, which continue to be good choices. Json.NET verwendet als Basisdatentyp .NET-Zeichenfolgen, die intern in UTF-16 codiert sind.Json.NET uses .NET strings as its base datatype, which is UTF-16 under the hood.

Die neue integrierte JSON-Unterstützung ist überaus leistungsfähig und basiert auf Span<byte>. Außerdem wird damit nur wenig Speicher belegt.The new built-in JSON support is high-performance, low allocation, and based on Span<byte>. In .NET Core 3.0 wurden dem Namespace System.Text.Json drei neue JSON-bezogene Typen hinzugefügt.Three new main JSON-related types have been added to .NET Core 3.0 the System.Text.Json namespace. Diese Typen unterstützen die POCO-Serialisierung und Deserialisierung (Plain Old CLR Object) noch nicht.These types don't yet support plain old CLR object (POCO) serialization and deserialization.

Utf8JsonReaderUtf8JsonReader

System.Text.Json.Utf8JsonReader ist ein leistungsstarker, reiner Vorwärtsleser mit geringer Zuordnung für UTF-8-kodierten JSON-Text, der von einem ReadOnlySpan<byte> gelesen wird.System.Text.Json.Utf8JsonReader is a high-performance, low allocation, forward-only reader for UTF-8 encoded JSON text, read from a ReadOnlySpan<byte>. Der Utf8JsonReader ist ein grundlegender, Low-Level-Typ, der zum Erstellen von benutzerdefinierten Parsern und Deserialisierungsprogrammen genutzt werden kann.The Utf8JsonReader is a foundational, low-level type, that can be used to build custom parsers and deserializers. Das Durchlesen einer JSON-Nutzlast mit dem neuen Utf8JsonReader ist 2x schneller als mit dem Leser von Json.NET.Reading through a JSON payload using the new Utf8JsonReader is 2x faster than using the reader from Json.NET. Die Zuweisung erfolgt erst, wenn Sie JSON-Token als (UTF-16-)Zeichenfolgen aktualisieren müssen.It doesn't allocate until you need to actualize JSON tokens as (UTF-16) strings.

Es folgt ein Beispiel des Lesens der von Visual Studio Code erstellten Datei launch.json: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

Mit System.Text.Json.Utf8JsonWriter lassen sich in UTF-8 codierte JSON-Texte aus gängigen .NET-Typen wie String, Int32 und DateTime schnell, vorwärtsgerichtet und ohne Zwischenspeichern schreiben.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. Der Writer ist ebenso wie der Reader ein grundlegender Low-Level-Typ, der zum Erstellen von benutzerdefinierten Serialisierungsmodulen verwendet werden kann.Like the reader, the writer is a foundational, low-level type, that can be used to build custom serializers. Mit der neuen Utf8JsonWriter-Klasse werden JSON-Nutzlasten 30 bis 80% schneller geschrieben als mit dem Json.NET-Writer. Außerdem findet keine Speicherbelegung statt.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 basiert auf Utf8JsonReader.System.Text.Json.JsonDocument is built on top of the Utf8JsonReader. Mit JsonDocument können JSON-Daten analysiert werden. Zusätzlich kann damit ein schreibgeschütztes Dokumentobjektmodell (DOM) erstellt werden, das zur Unterstützung von zufälligen Zugriffen und Enumerationen abgefragt werden kann.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. Auf die JSON-Elemente, aus denen sich die Daten zusammensetzen, kann über den Typ JsonElement zugegriffen werden, der von JsonDocument als RootElement-Eigenschaft verfügbar gemacht wird.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. JsonElement enthält das JSON-Array und Objektenumeratoren sowie APIs zum Konvertieren von JSON-Text in gängige .NET-Typen.The JsonElement contains the JSON array and object enumerators along with APIs to convert JSON text to common .NET types. Die Analyse einer typischen JSON-Nutzlast und der Zugriff auf alle zugehörigen Member mithilfe von JsonDocument wird zwei- bis dreimal so schnell durchgeführt wie mit Json.NET. Dabei wird für eine überschaubare Datengröße (d.h. < 1MB) nur wenig Speicher belegt.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).

Das folgende Beispiel enthält für JsonDocument und JsonElement ein Anwendungsszenario, das als Ausgangspunkt verwendet werden kann:Here is a sample usage of the JsonDocument and JsonElement that can be used as a starting point:

Es folgt ein Beispiel für C# 8.0 des Lesens der von Visual Studio Code erstellten Datei launch.json:Here is a C# 8.0 example of reading through the launch.json file created by Visual Studio Code:

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}");
    }
}
// Calling code
Console.WriteLine("Read with JsonDocument");
ReadJson(File.ReadAllText("launch.json"));

JsonSerializerJsonSerializer

System.Text.Json.Serialization.JsonSerializer ist auf der Basis von Utf8JsonReader und Utf8JsonWriter erstellt, um eine schnelle Serialisierungsoption mit geringer Arbeitsspeicherzuweisung zur Arbeit mit JSON-Dokumenten und -Fragmenten bereitzustellen.System.Text.Json.Serialization.JsonSerializer is built on top of Utf8JsonReader and Utf8JsonWriter to provide a fast low-memory serialization option when working with JSON documents and fragments.

UNTERSUCHEN: https://github.com/dotnet/corefx/blob/master/src/System.Text.Json/docs/SerializerProgrammingModel.md auf ein Beispiel zum Portieren in diesen ArtikelEXAMINE: https://github.com/dotnet/corefx/blob/master/src/System.Text.Json/docs/SerializerProgrammingModel.md for an example to port to this article

Hier ist ein Beispiel für die Serialisierung eines Objekts in 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.Serialization.JsonSerializer.ToString(instance));

Hier ist ein Beispiel für die Deserialisierung einer JSON-Zeichenfolge in ein Objekt.Here is an example of deserializing a JSON string to an object. Sie können die im vorherigen Beispiel erzeugte JSON-Zeichenfolge verwenden: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.Serialization.JsonSerializer.Parse<JsonPerson>(json);
}

InteropverbesserungenInterop improvements

.NET Core 3.0 verbessert natives API-Interop..NET Core 3.0 improves native API interop.

Typ: NativeLibraryType: NativeLibrary

System.Runtime.InteropServices.NativeLibrary bietet eine Kapselung zum Laden einer nativen Bibliothek (mit derselben Lastlogik wie .NET Core P/Invoke) und Bereitstellen der relevanten Hilfsfunktionen wie z.B. 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. Ein Codebeispiel finden Sie in der DLLMap-Demo.For a code example, see the DLLMap Demo.

Native Windows-Interop-APIWindows Native Interop

Windows stellt eine umfassende native API mit grundlegenden C-APIs (ohne C++-Features), COM und WinRT bereit.Windows offers a rich native API in the form of flat C APIs, COM, and WinRT. Während .NET Core P/Invoke unterstützt, fügt .NET Core 3.0 die Fähigkeit zum CoCreate von COM-APIs und Aktivieren von WinRT-APIs hinzu.While .NET Core supports P/Invoke, .NET Core 3.0 adds the ability to CoCreate COM APIs and Activate WinRT APIs. Ein Codebeispiel finden Sie in der Excel-Demo.For a code example, see the Excel Demo.

HTTP/2-UnterstützungHTTP/2 support

Der System.Net.Http.HttpClient-Typ unterstützt das HTTP/2-Protokoll.The System.Net.Http.HttpClient type supports the HTTP/2 protocol. Wenn HTTP/2 aktiviert ist, wird die HTTP-Protokollversion über TLS/ALPN ausgehandelt, und HTTP/2 wird bei Auswahl durch den Server verwendet.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.

Das Standardprotokoll bleibt HTTP/1.1, aber HTTP/2 kann auf zwei verschiedene Arten aktiviert werden.The default protocol remains HTTP/1.1, but HTTP/2 can be enabled in two different ways. Erstens können Sie die HTTP-Anforderungsnachricht so festlegen, dass HTTP/2 verwendet wird: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);

Zweitens können Sie HttpClient so ändern, dass HTTP/2 standardmäßig verwendet wird: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);

Oftmals möchten Sie bei der Entwicklung einer Anwendung eine unverschlüsselte Verbindung verwenden.Many times when you're developing an application, you want to use an unencrypted connection. Wenn Sie wissen, dass der Zielendpunkt HTTP/2 verwendet, können Sie unverschlüsselte Verbindungen für HTTP/2 aktivieren.If you know the target endpoint will be using HTTP/2, you can turn on unencrypted connections for HTTP/2. Sie können sie aktivieren, indem Sie die Umgebungsvariable DOTNET_SYSTEM_NET_HTTP_SOCKETSHTTPHANDLER_HTTP2UNENCRYPTEDSUPPORT auf 1 festlegen oder sie im App-Kontext aktivieren: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 & OpenSSL 1.1.1 auf LinuxTLS 1.3 & OpenSSL 1.1.1 on Linux

.NET Core nutzt nun die Unterstützung von TLS 1.3 in OpenSSL 1.1.1.1, wenn es in einer bestimmten Umgebung verfügbar ist..NET Core now takes advantage of TLS 1.3 support in OpenSSL 1.1.1, when it's available in a given environment. Mit TLS 1.3:With TLS 1.3:

  • Verbindungszeiten werden durch Reduzierung der erforderlichen Roundtrips zwischen Client und Server verbessert.Connection times are improved with reduced round trips required between the client and server.
  • Verbesserte Sicherheit wg. Entfernen verschiedener veralteter und unsicherer kryptografischer Algorithmen.Improved security because of the removal of various obsolete and insecure cryptographic algorithms.

Sofern verfügbar, verwendet .NET Core 3.0 OpenSSL 1.1.1, OpenSSL 1.1.0 oder OpenSSL 1.0.2 auf einem Linuxsystem.When available, .NET Core 3.0 uses OpenSSL 1.1.1, OpenSSL 1.1.0, or OpenSSL 1.0.2 on a Linux system. Wenn OpenSSL 1.1.1 verfügbar ist, verwendet sowohl der System.Net.Security.SslStream- als auch System.Net.Http.HttpClient-Typ TLS 1.3 (vorausgesetzt, dass Client und Server TLS 1.3 unterstützen).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).

Wichtig

Windows und macOS unterstützen TLS 1.3 noch nicht.Windows and macOS do not yet support TLS 1.3. .NET Core 3.0 unterstützt TLS 1.3 auf diesen Betriebssystemen, wenn entsprechender Support verfügbar ist..NET Core 3.0 will support TLS 1.3 on these operating systems when support becomes available.

Das folgende Beispiel für C# 8.0 veranschaulicht das Herstellen der Verbindung von .NET Core 3.0 auf Ubuntu 18.10 mit 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}");
        }
    }
}

KryptografieverschlüsselungenCryptography ciphers

.NET 3.0 fügt Unterstützung für AES-GCM- und AES-CCM- -Verschlüsselungen hinzu, implementiert mit System.Security.Cryptography.AesGcm bzw. System.Security.Cryptography.AesCcm..NET 3.0 adds support for AES-GCM and AES-CCM ciphers, implemented with System.Security.Cryptography.AesGcm and System.Security.Cryptography.AesCcm respectively. Beide Algorithmen sind AEAD-Algorithmen (Authenticated Encryption with Association Data).These algorithms are both Authenticated Encryption with Association Data (AEAD) algorithms.

Der folgende Code veranschaulicht die Verwendung der AesGcm-Verschlüsselung zum Verschlüsseln und Entschlüsseln von Zufallsdaten.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.");
        }
    }
}

Importieren/Exportieren kryptografischer SchlüsselCryptographic Key Import/Export

.NET Core 3.0 unterstützt das Importieren und Exportieren der asymmetrischen öffentlichen und privaten Schlüssel aus den Standardformaten..NET Core 3.0 supports the import and export of asymmetric public and private keys from standard formats. Sie müssen kein X.509-Zertifikat verwenden.You don't need to use an X.509 certificate.

Alle Schlüsseltypen wie RSA, DSA, ECDsa und ECDiffieHellman unterstützen die folgenden Formate:All key types, such as RSA, DSA, ECDsa, and ECDiffieHellman, support the following formats:

  • Öffentlicher SchlüsselPublic Key

    • X.509 SubjectPublicKeyInfoX.509 SubjectPublicKeyInfo
  • Privater SchlüsselPrivate key

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

RSA-Schlüsseln unterstützen auch:RSA keys also support:

  • Öffentlicher SchlüsselPublic Key

    • PKCS#1 RSAPublicKeyPKCS#1 RSAPublicKey
  • Privater SchlüsselPrivate key

    • PKCS#1 RSAPrivateKeyPKCS#1 RSAPrivateKey

Die Exportmethoden erstellen DER-kodierte Binärdaten, und die Importmethoden erwarten dasselbe.The export methods produce DER-encoded binary data, and the import methods expect the same. Wenn ein Schlüssel im textfreundlichen PEM-Format gespeichert ist, muss der Anrufer den Inhalt base64-dekodieren, bevor er eine Importmethode aufruft.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));
        }
    }
}

PKCS#8-Dateien können mit System.Security.Cryptography.Pkcs.Pkcs8PrivateKeyInfo überprüft werden, und PFX/PKCS#12-Dateien mit 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. PFX/PKCS#12-Dateien können mit System.Security.Cryptography.Pkcs.Pkcs12Builder bearbeitet werden.PFX/PKCS#12 files can be manipulated with System.Security.Cryptography.Pkcs.Pkcs12Builder.

SerialPort für LinuxSerialPort for Linux

.NET Core 3.0 unterstützt System.IO.Ports.SerialPort auf Linux..NET Core 3.0 supports System.IO.Ports.SerialPort on Linux.

Bisher unterstützte .NET Core nur die Verwendung von SerialPort auf Windows.Previously, .NET Core only supported using SerialPort on Windows.

Arbeitsspeicherlimits bei Docker und CgroupDocker and cgroup memory Limits

Ab Vorschauversion 3 funktioniert die Ausführung von .NET Core 3.0 unter Linux mit Docker besser mit Cgroup-Arbeitsspeicherlimits.Starting with Preview 3, running .NET Core 3.0 on Linux with Docker works better with cgroup memory limits. Das Ausführen eines Docker-Containers mit Arbeitsspeicherlimits, z.B. mit docker run -m, ändert das Verhalten von .NET Core.Running a Docker container with memory limits, such as with docker run -m, changes how .NET Core behaves.

  • Standardmäßige Heapgröße des Garbage Collectors (GC): maximal 20MB oder 75% des Arbeitsspeicherlimits für den Container.Default Garbage Collector (GC) heap size: maximum of 20 mb or 75% of the memory limit on the container.
  • Die explizite Größe kann als absolute Anzahl oder Prozentsatz des Cgroup-Limits festgelegt werden.Explicit size can be set as an absolute number or percentage of cgroup limit.
  • Die minimale reservierte Segmentgröße pro GC-Heap beträgt 16MB.Minimum reserved segment size per GC heap is 16 mb. Diese Größe reduziert die Anzahl der Heaps, die auf Computern erstellt werden.This size reduces the number of heaps that are created on machines.

Kleinere Garbage Collection-HeapgrößenSmaller Garbage Collection heap sizes

Die Standardheapgröße des Garbage Collectors wurde reduziert, sodass .NET Core weniger Arbeitsspeicher benötigt.The Garbage Collector's default heap size has been reduced resulting in .NET Core using less memory. Diese Änderung entspricht eher dem Zuordnungsbudget von Generation 0 mit modernen Prozessorcachegrößen.This change better aligns with the generation 0 allocation budget with modern processor cache sizes.

Garbage Collection: Unterstützung von „Large Pages“Garbage Collection Large Page support

„Large Pages“ (umfangreiche Seiten, unter Linux auch als „Huge Pages“ bekannt) ist eine Funktion, die dem Betriebssystem ermöglicht, Speicherbereiche einzurichten, die die native Seitengröße (häufig 4KB) überschreiten, um die Leistung der Anwendung zu verbessern, die diese große Seiten anfordert.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.

Der Garbage Collector kann nun mit der Einstellung GCLargePages als Aktivierungsfeature zum Auswählen der Zuordnung großer Seiten auf Windows konfiguriert werden.The Garbage Collector can now be configured with the GCLargePages setting as an opt-in feature to choose to allocate large pages on Windows.

GPIO-Unterstützung für Raspberry PiGPIO Support for Raspberry Pi

Über NuGet können nun zwei Pakete für die GPIO-Programmierung bezogen werden:Two packages have been released to NuGet that you can use for GPIO programming:

Die GPIO-Pakete enthalten APIs für GPIO-, SPI-, I2C- und PWM-Geräte.The GPIO packages include APIs for GPIO, SPI, I2C, and PWM devices. Das IoT-Bindungenpaket enthält Gerätebindungen.The IoT bindings package includes device bindings. Weitere Informationen finden Sie im GitHub-Repository zu Geräten.For more information, see the devices GitHub repo.

ARM64-Linux-SupportARM64 Linux support

.NET Core 3.0 fügt Unterstützung für ARM64 für Linux hinzu..NET Core 3.0 adds support for ARM64 for Linux. Der primäre Anwendungsfall für ARM64 sind derzeit IoT-Szenarien.The primary use case for ARM64 is currently with IoT scenarios. Weitere Informationen finden Sie unter .NET Core Runtime ARM64 Status (.NET Core-Runtime-ARM64-Status).For more information, see .NET Core ARM64 Status.

Dockerimages für .NET Core unter ARM64 sind für Alpine, Debian und Ubuntu verfügbar.Docker images for .NET Core on ARM64 are available for Alpine, Debian, and Ubuntu.

Hinweis

ARM64 wird von Windows noch nicht unterstützt.ARM64 Windows support isn't yet available.