Neuerungen in .NET Core 3.0What's new in .NET Core 3.0

In diesem Artikel werden Neuerungen in .NET Core 3.0 beschrieben.This article describes what is new in .NET Core 3.0. 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. Es wird dringend empfohlen, Visual Studio 2019 Version 16.3 oder höher, Visual Studio für Mac 8.3 oder höher oder Visual Studio Code mit der neuesten C#-Erweiterung zu verwenden.It's highly recommended that you use Visual Studio 2019 version 16.3 or newer, Visual Studio for Mac 8.3 or newer, or Visual Studio Code with the latest C# extension.

Sie können .NET Core 3.0 jetzt für Windows, macOS oder Linux herunterladen und sofort starten.Download and get started with .NET Core 3.0 right now on Windows, macOS, or Linux.

Weitere Informationen zu diesem Release finden Sie unter Ankündigung von .NET Core 3.0.For more information about the release, see the .NET Core 3.0 announcement.

.NET Core RC1 wurde von Microsoft als produktionsbereit betrachtet und vollständig unterstützt..NET Core RC1 was considered production ready by Microsoft and was fully supported. Wenn Sie eine Vorschauversion verwenden, müssen Sie für die weitere Unterstützung zur Version RTM wechseln.If you're using a preview release, you must move to the RTM version for continued support.

Sprachverbesserungen in C# 8.0Language improvements C# 8.0

C# 8.0 ist ebenfalls Teil dieses Releases, welches das Feature mit Referenztypen, die NULL-Werte zulassen, asynchrone Datenströme und weitere Muster enthält.C# 8.0 is also part of this release, which includes the nullable reference types feature, async streams, and more patterns. 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.

Es wurden Spracherweiterungen hinzugefügt, um die folgenden API-Features zu unterstützen:Language enhancements were added to support the following API features detailed below:

.NET Standard 2.1.NET Standard 2.1

.NET Core 3.0 implementiert .NET Standard 2.1..NET Core 3.0 implements .NET Standard 2.1. Dennoch generiert die Standardvorlage dotnet new classlib weiterhin ein Projekt für .NET Standard 2.0.However, the default dotnet new classlib template generates a project that still 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.

Kompilieren/bereitstellenCompile/Deploy

Standardmäßig ausführbare DateienDefault executables

.NET Core erstellt nun standardmäßig Runtime-abhängige ausführbare Dateien..NET Core now builds runtime-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 (appHost) erstellt, die der Umgebung und Plattform des von Ihnen verwendeten SDKs entspricht.During dotnet build or dotnet publish, an executable (known as the appHost) 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.

macOS-appHost und -NotarisierungmacOS appHost and notarization

nur unter macOSmacOS only

Ab dem notarisierten .NET Core SDK 3.0 für macOS ist die Einstellung zum Erstellen einer ausführbaren Standarddatei („appHost“) standardmäßig deaktiviert.Starting with the notarized .NET Core SDK 3.0 for macOS, the setting to produce a default executable (known as the appHost) is disabled by default. Weitere Informationen finden Sie unter macOS Catalina-Notarisierung und die Auswirkungen auf .NET Core-Downloads und -Projekte.For more information, see macOS Catalina Notarization and the impact on .NET Core downloads and projects.

Wenn die appHost-Einstellung aktiviert ist, erzeugt .NET Core eine native ausführbare Mach-O-Datei, wenn Sie einen Build- oder Veröffentlichungsprozess ausführen.When the appHost setting is enabled, .NET Core generates a native Mach-O executable when you build or publish. Ihre App wird im Kontext von appHost ausgeführt, wenn sie mit dem Befehl dotnet run über den Quellcode oder durch direktes Starten der ausführbaren Mach-O-Datei ausgeführt wird.Your app runs in the context of the appHost when it is run from source code with the dotnet run command, or by starting the Mach-O executable directly.

Ohne die appHost-Datei können Benutzer eine Runtime-abhängige App nur mit dem Befehl dotnet <filename.dll> starten.Without the appHost, the only way a user can start a runtime-dependent app is with the dotnet <filename.dll> command. Es wird immer eine appHost-Datei erstellt, wenn Sie Ihre App eigenständig veröffentlichen.An appHost is always created when you publish your app self-contained.

Sie können die appHost-Datei entweder auf Projektebene konfigurieren oder für einen spezifischen dotnet-Befehl mit dem -p:UseAppHost-Parameter aktivieren:You can either configure the appHost at the project level, or toggle the appHost for a specific dotnet command with the -p:UseAppHost parameter:

  • ProjektdateiProject file

    <PropertyGroup>
      <UseAppHost>true</UseAppHost>
    </PropertyGroup>
    
  • BefehlszeilenparameterCommand-line parameter

    dotnet run -p:UseAppHost=true
    

Weitere Informationen über die UseAppHost-Einstellung finden Sie unter MSBuild-Eigenschaften für Microsoft.NET.Sdk.For more information about the UseAppHost setting, see MSBuild properties for Microsoft.NET.Sdk.

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 erforderlich ist, 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 achieve better performance.

Der Hauptvorteil der mehrstufigen Kompilierung (TC, Tiered Compilation) besteht darin, dass sie zwei Methoden zur Just-in-Time-Kompilierung bietet: in einer Stufe mit geringerer Qualität, die aber schneller ist, oder in einer Stufe mit höherer Qualität, die aber langsamer ist.The main benefit of tiered compilation is to provide two ways of jitting methods: in a lower-quality-but-faster tier or a higher-quality-but-slower tier. Die Qualität bezieht sich darauf, wie gut die Methode optimiert ist.The quality refers to how well the method is optimized. Die TC verbessert die Leistung einer Anwendung, während sie verschiedene Phasen der Ausführung vom Start bis zum stabilen Zustand durchläuft.TC helps to improve the performance of an application as it goes through various stages of execution, from startup through steady state. Wenn die TC deaktiviert ist, wird jede Methode auf eine einzige Weise kompiliert, die auf eine stabile Leistung gegenüber der Startleistung ausgerichtet ist.When tiered compilation is disabled, every method is compiled in a single way that's biased to steady-state performance over startup performance.

Wenn TC aktiviert ist, gilt beim Start einer App das folgende Verhalten für die Methodenkompilierung:When TC is enabled, the following behavior applies for method compilation when an app starts up:

  • Wenn die Methode über AOT-kompilierten Code oder ReadyToRun verfügt, wird der zuvor generierte Code verwendet.If the method has ahead-of-time-compiled code, or ReadyToRun, the pregenerated code is used.
  • Andernfalls wird die Methode mit JIT kompiliert.Otherwise, the method is jitted. In der Regel sind diese Methoden Generics über Werttypen.Typically, these methods are generics over value types.
    • Quick JIT erzeugt schneller Code geringerer Qualität (oder weniger optimiert).Quick JIT produces lower-quality (or less optimized) code more quickly. In .NET Core 3.0 ist Quick JIT standardmäßig für Methoden aktiviert, die keine Schleifen enthalten. Während des Starts wird dies bevorzugt.In .NET Core 3.0, Quick JIT is enabled by default for methods that don't contain loops and is preferred during startup.
    • Die vollständig optimierte Just-In-Time-Kompilierung erzeugt Code höherer Qualität (oder besser optimierten Code), ist aber langsamer.The fully optimizing JIT produces higher-quality (or more optimized) code more slowly. Für Methoden, bei denen die schnelle JIT-Kompilierung nicht verwendet werden würde (beispielsweise dann, wenn die Methode das Attribut MethodImplOptions.AggressiveOptimization aufweist), wird die vollständig optimierte JIT-Kompilierung verwendet.For methods where Quick JIT would not be used (for example, if the method is attributed with MethodImplOptions.AggressiveOptimization), the fully optimizing JIT is used.

Bei häufig aufgerufenen Methoden erzeugt der Just-in-Time-Compiler schließlich vollständig optimierten Code im Hintergrund.For frequently called methods, the just-in-time compiler eventually creates fully optimized code in the background. Der optimierte Code ersetzt dann den vorkompilierten Code für diese Methode.The optimized code then replaces the pre-compiled code for that method.

Code, der von der schnellen JIT-Kompilierung generiert wurde, wird möglicherweise langsamer ausgeführt, belegt mehr Arbeitsspeicher oder nutzt mehr Stapelspeicher.Code generated by Quick JIT may run slower, allocate more memory, or use more stack space. Wenn es Probleme gibt, können Sie Quick JIT mit dieser MSBuild-Eigenschaft in der Projektdatei deaktivieren:If there are issues, you can disabled Quick JIT using this MSBuild property in the project file:

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

Verwenden Sie diese MSBuild-Eigenschaft in der Projektdatei, um die TC vollständig zu deaktivieren:To disable TC completely, use this MSBuild property in your project file:

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

Tipp

Wenn Sie diese Einstellungen in der Projektdatei ändern, müssen Sie möglicherweise einen bereinigten Build durchführen, damit die neuen Einstellungen reflektiert werden. (Löschen Sie die Verzeichnisse obj und bin, und erstellen Sie diese neu).If you change these settings in the project file, you may need to perform a clean build for the new settings to be reflected (delete the obj and bin directories and rebuild).

Weitere Informationen zum Konfigurieren der Kompilierung zur Laufzeit finden Sie unter Laufzeitkonfigurationsoptionen für die Kompilierung.For more information about configuring compilation at run time, see Run-time configuration options for compilation.

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 jedoch größer, da sie sowohl IL-Code (Intermediate Language, Zwischensprache), der für einige Szenarios noch benötigt wird, als auch die native Version des gleichen Codes enthalten.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 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 specific runtime environments (RID) such as Linux x64 or Windows x64.

Gehen Sie folgendermaßen vor, um Ihr Projekt als „ReadyToRun“ (Bereit zur Ausführung) zu kompilieren:To compile your project as ReadyToRun, do the following:

  1. Fügen Sie die <PublishReadyToRun>-Einstellung in Ihr Projekt ein.Add the <PublishReadyToRun> setting to your project:

    <PropertyGroup>
      <PublishReadyToRun>true</PublishReadyToRun>
    </PropertyGroup>
    
  2. 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
    

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.

Runtime/SDKRuntime/SDK

Runtimerollforward der HauptversionMajor-version runtime 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
  • Eigenschaft der Runtimekonfigurationsdatei: rollForwardRun-time 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.

Wenn die angeforderte Version (wie in .runtimeconfig.json für die Anwendung angegeben) eine endgültige Produktversion ist, werden standardmäßig nur endgültige Produktversionen für das Rollforward berücksichtigt.By default, if the requested version (as specified in .runtimeconfig.json for the application) is a release version, only release versions are considered for roll forward. Vorabversionen werden ignoriert.Any pre-release versions are ignored. Wenn keine passende endgültige Produktversion vorhanden ist, werden Vorabversionen berücksichtigt.If there is no matching release version, then pre-release versions are taken into account. Dieses Verhalten kann durch Festlegen von DOTNET_ROLL_FORWARD_TO_PRERELEASE=1 geändert werden. In diesem Fall werden immer alle Versionen berücksichtigt.This behavior can be changed by setting DOTNET_ROLL_FORWARD_TO_PRERELEASE=1, in which case all versions are always considered.

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.

Neue global.json-OptionenNew global.json options

Die Datei global.json verfügt über neue Optionen, die mehr Flexibilität bei der Definition der verwendeten .NET Core SDK-Version bieten.The global.json file has new options that provide more flexibility when you're trying to define which version of the .NET Core SDK is used. Folgende neue Optionen sind verfügbar:The new options are:

  • allowPrerelease: Gibt an, ob der SDK-Resolver bei der Auswahl der zu verwendenden SDK-Version Vorabversionen berücksichtigen soll.allowPrerelease: Indicates whether the SDK resolver should consider prerelease versions when selecting the SDK version to use.
  • rollForward: Gibt die Rollforwardrichtlinie an, die beim Auswählen einer SDK-Version verwendet werden soll, entweder als Fallback, wenn eine bestimmte SDK-Version fehlt, oder als Anweisung, damit eine höhere Version verwendet wird.rollForward: Indicates the roll-forward policy to use when selecting an SDK version, either as a fallback when a specific SDK version is missing or as a directive to use a higher version.

Weitere Informationen zu den Änderungen, einschließlich Standardwerten, unterstützten Werten und neuen Abgleichsregeln, finden Sie unter global.json: Übersicht.For more information about the changes including default values, supported values, and new matching rules, see global.json overview.

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.

Windows Desktop und COMWindows Desktop & COM

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 beispielsweise Versionen in zwei verschiedenen Featuregruppen, während sich 3.0.101 und 3.0.199 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 auf demselben Computer installiert ist, wird .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.

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.

WinForms mit hohem DPI-WertWinForms high DPI

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

Erstellen von COM-KomponentenCreate COM components

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.

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.

MSIX-BereitstellungMSIX Deployment

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>

Verbesserungen für LinuxLinux improvements

SerialPort für LinuxSerialPort for Linux

.NET Core 3.0 bietet grundlegende Unterstützung für System.IO.Ports.SerialPort unter Linux..NET Core 3.0 provides basic support for 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.

Weitere Informationen zur eingeschränkten Unterstützung für den seriellen Anschluss unter Linux finden Sie unter GitHub-Issue 33146.For more information about the limited support for the serial port on Linux, see GitHub issue #33146.

Arbeitsspeicherlimits bei Docker und CgroupDocker and cgroup memory Limits

Die Ausführung von .NET Core 3.0 unter Linux mit Docker funktioniert besser mit Cgroup-Arbeitsspeicherlimits.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.

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.

SicherheitSecurity

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.

Änderungen der .NET Core 3.0-API.NET Core 3.0 API changes

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.

IEEE-GleitkommaIEEE Floating-point

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, thereby minimizing the rounding error. Ein Beispiel hierfür ist FusedMultiplyAdd(1e308, 2.0, -1e308), diese gibt 1e308 zurück.An example is 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.

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 Von der .NET-Plattform abhängige intrinsische Funktionen.For more information, see .NET Platform-Dependent Intrinsics.

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. Zum 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 (notice the value includes any preview release information)
//   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.

Schneller integrierter JSON-SupportFast built-in JSON support

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

Die neue integrierte JSON-Unterstützung ist überaus leistungsfähig mit geringer Zuteilung und funktioniert mit UTF-8-codiertem JSON-Text.The new built-in JSON support is high-performance, low allocation, and works with UTF-8 encoded JSON text. Weitere Informationen zum Namespace System.Text.Json und den Typen finden Sie in den folgenden Artikeln:For more information about the System.Text.Json namespace and types, see the following articles:

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

Nächste SchritteNext steps