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

In diesem Artikel werden Neuerungen in .NET Core 3.0 (Vorschauversion 2) beschrieben.This article describes what is new in .NET Core 3.0 (preview 2). 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 utilizing a .NET Core 3.0 SDK component called 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 unten im Abschnitt Windows Desktop.For more information, see the section Windows desktop below.

.NET Core 3.0 bietet Unterstützung für C# 8.0..NET Core 3.0 adds support for C# 8.0.

Sie können .NET Core 3.0 Preview 2 jetzt für Windows, Mac und Linux herunterladen und sofort starten.Download and get started with .NET Core 3.0 Preview 2 right now on Windows, Mac and Linux. Alle Details zu diesem Release finden Sie in den Versionshinweisen zu .NET Core 3.0 Preview 2.You can see complete details of the release in the .NET Core 3.0 Preview 2 release notes.

Weitere Informationen zu den Inhalten der einzelnen Versionen finden Sie in den folgenden Ankündigungen:For more information about what was released with each version, see the following announcements:

C# 8.0C# 8

.NET Core 3.0 unterstützt C# 8.0. Ab der Vorschauversion 2 von NET Core 3.0 werden neue Features unterstützt, die weiter unten aufgeführt sind..NET Core 3.0 supports C# 8, and as of .NET Core 3.0 Preview 2, supports these new features. Weitere Informationen zu Features von C# 8.0 finden Sie in den folgenden Blogbeiträgen:For more information about C# 8.0 features, see the following blog posts:

Bereiche und IndizesRanges and indices

Der neue Index-Typ kann für die Indizierung verwendet werden.The new 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 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 is also a 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, um einen Slice zu erzeugen:You can then index with a Range in order to produce a slice:

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

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.

Hinweis

Sie benötigen zur Nutzung asynchroner Datenströme die Vorschauversion 2 von .NET Core 3.0, wenn Sie mit Visual Studio 2019 oder mit der aktuellen Vorschauversion der C#-Erweiterung für Visual Studio Code entwickeln möchten.You need .NET Core 3.0 Preview 2 to use async streams if you want to develop with either Visual Studio 2019 or the latest preview of the C# extension for Visual Studio Code. Wenn Sie die Vorschauversion 2 von .NET Core 3.0 über die Befehlszeile nutzen, entstehen keine Probleme.If you are using .NET Core 3.0 Preview 2 at the command line, then everything will work as expected.

using-DeklarationenUsing Declarations

using-Deklarationen sind ein neues Feature, mit dem sichergestellt werden kann, dass ein Objekt wie erwartet verworfen wird.Using declarations are a new way to ensure your object is properly disposed. Mit einer using-Deklaration wird für das Objekt Speicher belegt, solange es sich im Geltungsbereich befindet.A using declaration keeps the object alive while it is still in scope. Verlässt das Objekt diesen Bereich, wird es automatisch verworfen.Once the object becomes out of scope, it is automatically disposed. Dadurch müssen weniger geschachtelte using-Anweisungen verwendet werden, was zu übersichtlicherem Code führt.This will reduce nested using statements and make your code cleaner.

static void Main(string[] args)
{
    using var options = Parse(args);
    if (options["verbose"]) { WriteLine("Logging..."); }

} // options disposed here

switch-AusdrückeSwitch Expressions

switch-Ausdrücke stellen eine übersichtlichere Variante von switch-Anweisungen dar. Da es sich aber um Ausdrücke handelt, wird ein Wert zurückgegeben.Switch expressions are a cleaner way of doing a switch statement but, since it's an expression, returns a value. switch-Ausdrücke lassen sich außerdem uneingeschränkt mit Musterabgleichen verwenden und nutzen das Ausschussmuster _ zur Darstellung des default-Werts.Switch expressions are also fully integrated with pattern matching, and use the discard pattern, _, to represent the default value.

Die Syntax von switch-Ausdrücken wird im folgenden Beispiel gezeigt:You can see the syntax for switch expressions in the following example:

static string Display(object o) => o switch
{
    Point { X: 0, Y: 0 }         => "origin",
    Point { X: var x, Y: var y } => $"({x}, {y})",
    _                            => "unknown"
};

In diesem Beispiel werden zwei Muster verwendet.There are two patterns at play in this example. o wird für Point zuerst mit dem Typmuster und anschließend mit dem Eigenschaftenmuster innerhalb der {geschweiften Klammern} abgeglichen.o first matches with the Point type pattern and then with the property pattern inside the {curly braces}. _ beschreibt das discard pattern, das mit default für switch-Anweisungen identisch ist.The _ describes the discard pattern, which is the same as default for switch statements.

Mit Mustern können Sie anstelle von prozeduralem Code, in dem Tests für eine Absicht implementiert werden, deklarativen Code schreiben, der diese Absicht direkt erfasst.Patterns enable you to write declarative code that captures your intent instead of procedural code that implements tests for it. Die Verantwortung zur Implementierung des prozeduralen Codes wird so dem Compiler übertragen, der diese Aufgabe immer fehlerfrei ausführt.The compiler becomes responsible for implementing that boring procedural code and is guaranteed to always do it correctly.

Es gibt dennoch Fälle, in denen switch-Anweisungen weiterhin besser geeignet sind als switch-Ausdrücke, und Muster können mit beiden Syntaxstilen verwendet werden.There will still be cases where switch statements will be a better choice than switch expressions and patterns can be used with both syntax styles.

Weitere Informationen finden Sie unter Do more with patterns in C# 8.0 (Effektivere Verwendung von Mustern in C# 8.0).For more information, see Do more with patterns in C# 8.0.

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

APIs für Gleitkommazahlen werden aktuell an die Revision des Standards IEEE 754-2008 angepasst.Floating point APIs are in the process of being updated to comply with IEEE 754-2008 revision. Ziel dieser Änderungen ist es, alle „erforderlichen“ Operationen verfügbar zu machen und sicherzustellen, dass sie mit dem in der IEEE-Spezifikation beschriebenen Verhalten kompatibel sind.The goal of these changes is to expose all "required" operations and ensure that they are behaviorally compliant with the IEEE spec.

Korrekturen bei der Analyse und Formatierung:Parsing and formatting fixes:

  • 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.
  • Unendlichkeits- 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 performing a case-insensitive check and allowing an optional preceding + where applicable.

In den neuen Mathematik-APIs sind folgende Operationen enthalten:New Math APIs have:

  • BitIncrement/BitDecrement
    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/MinMagnitude
    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
    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 which returns an integral value, it returns the integral base-2 log of the input parameter. Diese Operation entspricht im Wesentlichen floor(log2(x)), jedoch ist der Rundungsfehler minimal.This is effectively the same as floor(log2(x)), but done with minimal rounding error.

  • ScaleB
    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 which takes an integral value, it returns effectively x * pow(2, n), but is done with minimal rounding error.

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

Intrinsische .NET-plattformabhängige 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 big performance improvements in certain scenarios, such as processing data efficiently in parallel. Diese API-Operationen können nicht nur in eigenen Programmen verwendet werden, sondern werden nun auch von .NET-Bibliotheken zur Leistungssteigerung eingesetzt.In addition to exposing the APIs for your programs to use, the .NET libraries have begun using these instructions to improve performance.

In den folgenden CoreCLR-PRs werden einige intrinsische Funktionen und deren Implementierung oder Verwendung vorgestellt:The following CoreCLR PRs demonstrate a few of the intrinsics, either via implementation or use:

Weitere Informationen finden Sie unter .NET Platform Dependent Intrinsics (Intrinsische .NET-plattformabhängige Funktionen). In diesem Artikel wird eine Strategie zum Definieren von intrinsischen Funktionen für eine bestimmte Hardwareinfrastruktur vorgestellt. Dadurch können Microsoft, Chiphersteller oder andere Unternehmen oder Personen Hardware- bzw. Chip-APIs entwerfen, die in .NET-Code verfügbar gemacht werden soll.For more information, see .NET Platform Dependent Intrinsics, which defines an approach for defining this hardware infrastructure, allowing Microsoft, chip vendors, or any other company or individual to define hardware/chip APIs that should be exposed to .NET code.

Standardmäßig ausführbare DateienDefault executables

.NET Core erstellt die frameworkabhängigen ausführbaren Dateien jetzt standardmäßig..NET Core will now build framework-dependent executables by default. Dies ist neu für Anwendungen, die eine global installierte Version von .NET Core verwenden.This is new for applications that use a globally installed version of .NET Core. Bis jetzt produzierten nur eigenständige Bereitstellungen eine ausführbare Datei.Until now, 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 provided that matches the environment and platform of the SDK you are 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.

Build kopiert AbhängigkeitenBuild copies dependencies

dotnet build kopiert jetzt NuGet-Abhängigkeiten für Ihre Anwendung aus dem NuGet-Cache in den Buildausgabeordner.dotnet build 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 dotnet-ToolsLocal dotnet tools

Warnung

Nach der Vorschauversion 1 von .NET Core 3.0 wurde in Vorschauversion 2 eine Änderung an den lokalen .NET Core-Tools vorgenommen.There was a change in .NET Core Local Tools between .NET Core 3.0 Preview 1 and .NET Core 3.0 Preview 2. Wenn Sie die lokalen Tools in Vorschauversion 1 mit einem Befehl wie dotnet tool restore oder dotnet tool install verwenden haben, müssen Sie den Cacheordner für die lokalen Tools löschen, da diese andernfalls in Vorschauversion 2 nicht funktionieren.If you tried out local tools in Preview 1 by running a command like dotnet tool restore or dotnet tool install, you need to delete your local tools cache folder before local tools will work correctly in Preview 2. Je nach Betriebssystem werden die Ordnerpfade wie folgt gelöscht:This folder is located at:

Mac und Linux: rm -r $HOME/.dotnet/toolResolverCacheOn mac, Linux: rm -r $HOME/.dotnet/toolResolverCache

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

Wenn Sie diesen Ordner nicht löschen, wird eine Fehlermeldung angezeigt.If you do not delete this folder, you will receive an error.

.NET Core 2.1 unterstützt globale Tools, .NET Core 3.0 verfügt jetzt über lokale Tools.While .NET Core 2.1 supported global tools, .NET Core 3.0 now has 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. Dies ermöglicht die Bereitstellung von Tools für einzelne Projekte und Repositorys.This enables per-project and per-repository tooling. Jedes lokal installierte Tool ist nicht global verfügbar.Any tool installed locally isn't available globally. Tools werden als NuGet-Pakete verteilt.Tools are distributed as NuGet packages.

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. Durch die Erstellung dieser Manifestdatei im Stammverzeichnis Ihres Repositorys stellen Sie sicher, dass jeder, der Ihren Code klont, die Tools wiederherstellen und verwenden kann, die für eine erfolgreiche Arbeit mit Ihrem Code erforderlich sind.By creating this manifest file at the root of your repository, you ensure anyone cloning your code can restore and use the tools that are needed to successfully work with your code.

Mit dem folgenden Befehl können Sie eine dotnet-tools.json-Manifestdatei erstellen:To create a dotnet-tools.json manifest file, use:

dotnet new tool-manifest

Wenn Sie dem lokalen Manifest ein neues Tool hinzufügen möchten, verwenden Sie den folgenden Befehl:Add a new tool to the local manifest with:

dotnet tool install <packageId>

Mit dem folgenden Befehl können Sie außerdem die Tools im lokalen Manifest auflisten:You can also list the tools in the local manifest with:

dotnet tool list

Wenn Sie die global installierten Tools anzeigen möchten, verwenden Sie folgenden Befehl:To see what tools are installed globally, use:

dotnet tool list -g

Wenn die Manifestdatei für die lokalen Tools verfügbar ist, die im Manifest festgelegten Tools jedoch nicht installiert wurden, verwenden Sie den folgenden Befehl, um sie automatisch herunterzuladen und zu installieren:When the local tools manifest file is available, but the tools defined in the manifest have not been installed, use the following command to automatically download and install those tools:

dotnet tool restore

Führen Sie ein lokales Tool mit dem folgenden Befehl aus:Run a local tool with the following command:

dotnet tool run <tool-command-name>

Wenn ein lokales Tool ausgeführt wird, sucht dotnet nach einer Manifestdatei in der aktuellen Verzeichnisstruktur.When a local tool is run, dotnet searches for a manifest up the current directory structure. Wenn eine Manifestdatei für das Tool gefunden wurde, wird diese nach dem erforderlichen Tool durchsucht.When a tool manifest file is found, it is searched for the requested tool. Wenn das Tool im Manifest, aber nicht im Cache gefunden wird, wird dem Benutzer eine Fehlermeldung angezeigt. Dieser muss dann dotnet tool restore ausführen.If the tool is found in the manifest, but not the cache, the user receives an error and needs to run dotnet tool restore.

Wenn Sie ein Tool aus der Manifestdatei für die lokalen Tools entfernen möchten, führen Sie den folgenden Befehl aus:To remove a tool from the local tool manifest file, run the following command:

dotnet tool uninstall <packageId>

Die Manifestdatei des Tools ist so konzipiert, dass sie eine manuelle Bearbeitung ermöglicht. Sie müssen die Datei bearbeiten, um die erforderliche Version für die Arbeit mit dem Repository zu aktualisieren.The tool manifest file is designed to allow hand editing – which you might do to update the required version for working with the repository. Hier ist ein Beispiel für eine dotnet-tools.json-Datei:Here is an example dotnet-tools.json file:

{
  "version": 1,
  "isRoot": true,
  "tools": {
    "dotnetsay": {
      "version": "2.1.4",
      "commands": [
        "dotnetsay"
      ]
    },
    "t-rex": {
      "version": "1.0.103",
      "commands": [
        "t-rex"
      ]
    }
  }
}

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 global oder lokal zu installieren, müssten Sie weiterhin die NET Core 2.1-Runtime installieren.To install those globally or locally, you would still need to install the NET Core 2.1 Runtime.

Windows-DesktopWindows desktop

Ab .NET Core 3.0 Vorschauversion 1 können Sie Windows Desktop-Anwendungen mit WPF und Windows Forms erstellen.Starting with .NET Core 3.0 Preview 1, you can build Windows desktop applications using 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. Designer werden nach wie vor noch nicht unterstützt.Designers are still not yet supported. Sie können die Projekte in Visual Studio 2019 öffnen, starten und debuggen.And you can open, launch, and debug these projects in Visual Studio 2019.

Ab Visual Studio 2017 15.9 ist es möglich, .NET Core-Vorschauversionen zu aktivieren. Dieses Feature müssen Sie jedoch erst aktivieren, und es handelt sich dabei nicht um ein unterstütztes Szenario.Visual Studio 2017 15.9 adds the ability to enable .NET Core previews, but you need to turn that feature on, and it's not a supported scenario.

Die neuen Projekte sind die gleichen wie die bestehenden.NET Core Projekte, mit ein paar Ergänzungen.The new projects are the same as existing .NET Core projects, with a couple additions. Hier ist der Vergleich eines einfachen .NET Core-Konsolenprojekts mit einem einfachen Windows Forms- und WPF-Projekt.Here is the comparison of the basic .NET Core console project and a basic Windows Forms and WPF project.

In einem .NET Core-Konsolenprojekt verwendet das Projekt das Microsoft.NET.Sdk SDK und deklariert eine Abhängigkeit von .NET Core 3.0 über das netcoreapp3.0-Zielframework.In a .NET Core console project, the project uses the Microsoft.NET.Sdk SDK and declares a dependency on .NET Core 3.0 via the netcoreapp3.0 target framework. Um eine Windows Desktop-Anwendung zu erstellen, verwenden Sie das Microsoft.NET.Sdk.WindowsDesktop SDK und wählen Sie das zu verwendende UI-Framework:To create a Windows Desktop app, use the Microsoft.NET.Sdk.WindowsDesktop SDK and choose which UI framework to use:

-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk.WindowsDesktop">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>netcoreapp3.0</TargetFramework>
+   <UseWPF>true</UseWPF>
  </PropertyGroup>
</Project>

Um Windows Forms und nicht WPF zu wählen, legen Sie UseWindowsForms anstelle von UseWPF fest:To choose Windows Forms over WPF, set UseWindowsForms instead of UseWPF:

<Project Sdk="Microsoft.NET.Sdk.WindowsDesktop">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>netcoreapp3.0</TargetFramework>
-   <UseWPF>true</UseWPF>
+   <UseWindowsForms>true</UseWindowsForms>
  </PropertyGroup>
</Project>

Sowohl UseWPF als auch UseWindowsForms können auf true festgelegt werden, wenn die Anwendung beide Frameworks verwendet, z.B. wenn ein Windows Forms-Dialogfeld ein WPF-Steuerelement bereitstellt.Both UseWPF and UseWindowsForms can be set to true if the app uses both frameworks, for example when a Windows Forms dialog is hosting a WPF control.

Ihr Feedback in den dotnet/winforms-, dotnet/wpf- und dotnet/core-Repositorys ist jederzeit willkommen.Please share your feedback on the dotnet/winforms, dotnet/wpf and dotnet/core repos.

MSIX-Bereitstellung für Windows DesktopMSIX Deployment for Windows Desktop

MSIX ist ein neues Windows-App-Paketformat.MSIX is a new Windows app 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.

Hinweis

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>

Schneller integrierter JSON-SupportFast built-in JSON support

Das .NET-Ökosystem basiert auf Json.NET und anderen beliebten JSON-Bibliotheken, die weiterhin eine gute Wahl sind.The .NET ecosystem has 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 are 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.

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 Fehler beim Erstellen des Deserialisierungsprogramms genutzt werden kann.The Utf8JsonReader is a foundational, low-level type, that can be leveraged 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. Es wird erst dann zugewiesen, wenn Sie JSON-Token als (UTF-16)-Zeichenfolgen aktualisieren müssen.It does not allocate until you need to actualize JSON tokens as (UTF-16) strings.

Diese neue API umfasst die folgenden Komponenten:This new API will include the following components:

  • In Vorschauversion 1: JSON-Reader (sequenzieller Zugriff)In Preview 1: JSON reader (sequential access)
  • Geplant: JSON-Writer, DOM (wahlfreier Zugriff), POCO-Serialisierungsprogramm, POCO-DeserialisierungsprogrammComing next: JSON writer, DOM (random access), poco serializer, poco deserializer

Hier ist eine einfache Leserschleife für den Utf8JsonReader, die als Startpunkt verwendet werden kann:Here is the basic reader loop for the Utf8JsonReader that can be used as a starting point:

using System.Text.Json;

public static void Utf8JsonReaderLoop(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:
                string valueString = json.GetStringValue();
                break;
            case JsonTokenType.Number:
                if (!json.TryGetInt32Value(out int valueInteger))
                {
                    throw new FormatException();
                }
                break;
            case JsonTokenType.True:
            case JsonTokenType.False:
                bool valueBool = json.GetBooleanValue();
                break;
            case JsonTokenType.Null:
                break;
            default:
                throw new ArgumentException();
        }
    }

    dataUtf8 = dataUtf8.Slice((int)json.BytesConsumed);
    JsonReaderState state = json.CurrentState;
}

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 leveraged to build custom serializers. Mit der neuen Utf8JsonWriter-Klasse werden JSON-Nutzlasten 30 bis 80 % schnell 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 does not allocate.

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

static int WriteJson(IBufferWriter<byte> output, long[] extraData)
{
    var json = new Utf8JsonWriter(output, state: default);

    json.WriteStartObject();

    json.WriteNumber("age", 15, escape: false);
    json.WriteString("date", DateTime.Now);
    json.WriteString("first", "John");
    json.WriteString("last", "Smith");

    json.WriteStartArray("phoneNumbers", escape: false);
    json.WriteStringValue("425-000-1212", escape: false);
    json.WriteStringValue("425-000-1213");
    json.WriteEndArray();

    json.WriteStartObject("address");
    json.WriteString("street", "1 Microsoft Way");
    json.WriteString("city", "Redmond");
    json.WriteNumber("zip", 98052);
    json.WriteEndObject();

    json.WriteStartArray("ExtraArray");
    for (var i = 0; i < extraData.Length; i++)
    {
        json.WriteNumberValue(extraData[i]);
    }
    json.WriteEndArray();

    json.WriteEndObject();

    json.Flush(isFinalBlock: true);

    return (int)json.BytesWritten;
}

Utf8JsonWriter nimmt IBufferWriter<byte> als Ausgabespeicherort entgegen, in den die JSON-Daten geschrieben werden. In der aufrufenden Funktion muss eine konkrete Implementierung bereitgestellt werden.The Utf8JsonWriter accepts IBufferWriter<byte> as the output location to synchronously write the json data into, and you as the caller need to provide a concrete implementation. Die Plattform umfasst zurzeit keine Implementierung dieser Schnittstelle.The platform does not currently include an implementation of this interface. Ein Beispiel zu IBufferWriter<byte> finden Sie unter https://gist.github.com/ahsonkhan/c76a1cc4dc7107537c3fdc0079a68b35.For an example of IBufferWriter<byte>, see https://gist.github.com/ahsonkhan/c76a1cc4dc7107537c3fdc0079a68b35.

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 which 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 (< 1 MB) 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 very little allocations for data that is reasonably sized (i.e. < 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:

static double ParseJson()
{
    const string json = " [ { \"name\": \"John\" }, [ \"425-000-1212\", 15 ], { \"grades\": [ 90, 80, 100, 75 ] } ]";

    double average = -1;

    using (JsonDocument doc = JsonDocument.Parse(json))
    {
        JsonElement root = doc.RootElement;
        JsonElement info = root[1];

        string phoneNumber = info[0].GetString();
        int age = info[1].GetInt32();

        JsonElement grades = root[2].GetProperty("grades");

        double sum = 0;
        foreach (JsonElement grade in grades.EnumerateArray())
        {
            sum += grade.GetInt32();
        }

        int numberOfCourses = grades.GetArrayLength();
        average = sum / numberOfCourses;
    }

    return average;
}

AssemblyentladbarkeitAssembly Unloadability

Assemblyentladbarkeit ist eine neue Funktion von AssemblyLoadContext.Assembly unloadability is a new capability of AssemblyLoadContext. Dieses neue Feature bringt nur wenige neue APIs mit sich und ist daher aus der API-Perspektive gut überschaubar.This new feature is largely transparent from an API perspective, exposed with just a few new APIs. Mithilfe der Assemblyentladbarkeit kann der Ladeprogrammkontext entladen werden, wodurch sämtlicher Speicher für instanziierte Typen, statische Felder und für die Assembly selbst freigegeben wird.It enables a loader context to be unloaded, releasing all memory for instantiated types, static fields and for the assembly itself. Eine Anwendung sollte mit diesem Mechanismus unbegrenzt lange Assemblys laden und entladen können, ohne dass ein Arbeitsspeicherverlust auftritt.An application should be able to load and unload assemblies via this mechanism forever without experiencing a memory leak.

Diese neue Funktion kann für Szenarios wie die folgenden verwendet werden:This new capability can be used for scenarios similar to:

  • Plug-In-Szenarios, in denen ein dynamisches Laden und Entladen von Plug-Ins erforderlich ist.Plugin scenarios where dynamic plugin loading and unloading is required.
  • Dynamisches Kompilieren und Ausführen von Code sowie Leeren des zugehörigen Speichers.Dynamically compiling, running and then flushing code. Dies ist beispielsweise für Websites und Skript-Engines nützlich.Useful for web sites, scripting engines, etc.
  • Laden von Assemblys für eine Selbstprüfung (ähnlich wie bei ReflectionOnlyLoad). In vielen Fällen ist MetadataLoadContext (veröffentlicht in Vorschauversion 1) jedoch die bessere Wahl.Loading assemblies for introspection (like ReflectionOnlyLoad), although MetadataLoadContext (released in Preview 1) will be a better choice in many cases.

Weitere Informationen finden Sie unter Verwenden von Entladbarkeit.For more information, see the Using Unloadability document.

Beim Entladen von Assemblys muss unbedingt darauf geachtet werden, dass alle außerhalb des Ladeprogrammkontexts vorhandenen Verweise auf verwaltete Objekte nachvollzogen und verwaltet werden.Assembly unloading requires significant care to ensure that all references to managed objects from outside a loader context are understood and managed. Wenn der Ladeprogrammkontext zum Entladen aufgefordert wird, müssen alle externen Verweise bereits aufgehoben sein, damit der Ladeprogrammkontext ausschließlich mit sich selbst konsistent ist.When the loader context is requested to be unloaded, any outside references need to have been unreferenced so that the loader context is self-consistent only to itself.

Assemblyentladbarkeit wurde im .NET Framework durch Anwendungsdomänen (AppDomains) bereitgestellt, die in .NET Core nicht unterstützt werden.Assembly unloadability was provided in the .NET Framework by Application Domains (AppDomains), which are not supported with .NET Core. AppDomains hatten verglichen mit diesem neuen Modell sowohl Vor- als auch Nachteile.AppDomains had both benefits and limitations compared to this new model. Das neue Ladeprogrammmodell kann im Vergleich zu AppDomains als flexibler und leistungsfähiger betrachtet werden.Consider this new loader model to be more flexible and higher performant when compared to AppDomains.

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. Seit .NET Core 1.0 wird P/Invoke unterstützt.Since .NET Core 1.0, P/Invoke has been supported. In .NET Core 3.0 besteht nun die Möglichkeit, COCreate-COM-APIs zu erstellen und WinRT-APIs zu aktivieren.Now with .NET Core 3.0, support for the ability to CoCreate COM APIs and Activate WinRT APIs has been added.

Ein Beispiel zur Verwendung von COM finden Sie im Quellcode der Excel-Demo.You can see an example of using COM with the Excel Demo source code.

Typ: SequenceReaderType: SequenceReader

In .NET Core 3.0 wurde System.Buffers.SequenceReader hinzugefügt, der als Leser für ReadOnlySequence<T> verwendet werden kann.In .NET Core 3.0, System.Buffers.SequenceReader has been added which can be used as a reader for ReadOnlySequence<T>. Dies ermöglicht eine einfache, leistungsstarke Zuteilungsanalyse mit geringer Priorität von System.IO.Pipelines-Daten, die mehrere Hintergrundpuffer überwinden können.This allows easy, high performance, low allocation parsing of System.IO.Pipelines data that can cross multiple backing buffers.

Das folgende Beispiel bricht eine Eingabe-Sequence in gültige, durch Trennzeichen getrennte CR/LF-Zeilen auf:The following example breaks an input Sequence into valid CR/LF delimited lines:

private static ReadOnlySpan<byte> CRLF => new byte[] { (byte)'\r', (byte)'\n' };

public static void ReadLines(ReadOnlySequence<byte> sequence)
{
    SequenceReader<byte> reader = new SequenceReader<byte>(sequence);

    while (!reader.End)
    {
        if (!reader.TryReadToAny(out ReadOnlySpan<byte> line, CRLF, advancePastDelimiter:false))
        {
            // Couldn't find another delimiter
            // ...
        }

        if (!reader.IsNext(CRLF, advancePast: true))
        {
            // Not a good CR/LF pair
            // ...
        }

        // line is valid, process
        ProcessLine(line);
    }
}

Typ: MetadataLoadContextType: MetadataLoadContext

Der MetadataLoadContext-Typ wurde hinzugefügt, der das Lesen von Assemblymetadaten ermöglicht, ohne die Anwendungsdomäne des Anrufers zu beeinträchtigen.The MetadataLoadContext type has been added that enables reading assembly metadata without affecting the caller’s application domain. Assemblys werden als Daten gelesen, einschließlich Assemblys, die für andere Architekturen und Plattformen als die aktuelle Runtimeumgebung erstellt wurden.Assemblies are read as data, including assemblies built for different architectures and platforms than the current runtime environment. MetadataLoadContext überschneidet sich mit ReflectionOnlyLoad, das nur in .NET Framework verfügbar ist.MetadataLoadContext overlaps with the ReflectionOnlyLoad, which is only available in the .NET Framework.

MetdataLoadContext ist im System.Reflection.MetadataLoadContext-Paket verfügbar.MetdataLoadContext is available in the System.Reflection.MetadataLoadContext package. Es ist ein .NET Standard 2.0-Paket.It is a .NET Standard 2.0 package.

Der MetadataLoadContext stellt APIs ähnlich dem Typ AssemblyLoadContext zur Verfügung, basiert aber nicht auf diesem Typ.The MetadataLoadContext exposes APIs similar to the AssemblyLoadContext type, but is not based on that type. Ähnlich wie AssemblyLoadContext ermöglicht der MetadataLoadContext das Laden von Assemblys innerhalb einer isolierten Umgebung zum Laden von Assemblys.Much like AssemblyLoadContext, the MetadataLoadContext enables loading assemblies within an isolated assembly loading universe. MetdataLoadContext-APIs geben Assembly-Objekte zurück, sodass bekannte Reflektions-APIs verwendet werden können.MetdataLoadContext APIs return Assembly objects, enabling the use of familiar reflection APIs. Ausführungsorientierte APIs, wie MethodBase.Invoke sind nicht zulässig, und geben „InvalidOperationException“ zurück.Execution-oriented APIs, such as MethodBase.Invoke, are not allowed and will throw InvalidOperationException.

Das folgende Beispiel zeigt, wie Sie den richtigen Typen in einer Assembly findet, die eine bestimmte Schnittstelle implementiert:The following sample demonstrates how to find concrete types in an assembly that implements a given interface:

var paths = new string[] {@"C:\myapp\mscorlib.dll", @"C:\myapp\myapp.dll"};
var resolver = new PathAssemblyResolver(paths);
using (var lc = new MetadataLoadContext(resolver))
{
    Assembly a = lc.LoadFromAssemblyName("myapp");
    Type myInterface = a.GetType("MyApp.IPluginInterface");
    foreach (Type t in a.GetTypes())
    {
        if (t.IsClass && myInterface.IsAssignableFrom(t))
            Console.WriteLine($"Class {t.FullName} implements IPluginInterface");
    }
}

Szenarien für MetadataLoadContext beinhalten Entwurfszeitfeatures, Buildzeit-Tools und Runtime-Light-Up-Features, die eine Reihe von Assemblys als Daten überprüfen müssen und alle Dateisperren und Speicher freigeben, nachdem die Überprüfung durchgeführt wurde.Scenarios for MetadataLoadContext include design-time features, build-time tooling, and runtime light-up features that need to inspect a set of assemblies as data and have all file locks and memory freed after inspection is performed.

Der MetadataLoadContext hat eine Resolverklasse, die an dessen Konstruktor übergeben wird.The MetadataLoadContext has a resolver class passed to its constructor. Die Auftrag des Resolvers ist es, eine Assembly zu laden, wenn der AssemblyName angegeben ist.The resolver's job is to load an Assembly given its AssemblyName. Die Resolverklasse wird aus der abstrakten MetadataAssemblyResolver-Klasse abgeleitet.The resolver class derives from the abstract MetadataAssemblyResolver class. Die Implementierung des Resolvers für pfadbasierte Szenarien ist durch PathAssemblyResolver möglich.An implementation of the resolver for path-based scenarios is provided with PathAssemblyResolver.

Die MetadataLoadContext-Tests zeigen viele Anwendungsfälle.The MetadataLoadContext tests demonstrate many use cases. Die Assemblytests sind ein guter Ausgangspunkt.The Assembly tests are a good place to start.

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 will now take advantage of TLS 1.3 support in OpenSSL 1.1.1, when it is available in a given environment. Gemäß dem OpenSSL-Team hat TLS 1.3 viele Vorteile:There are multiple benefits of TLS 1.3, per the OpenSSL team:

  • Verbesserte Verbindungszeiten aufgrund einer Reduzierung der erforderlich Roundtrips zwischen Client und Server.Improved connection times due to a reduction in the number of round trips required between the client and server.

  • Höhere Sicherheit durch das Entfernen verschiedener veralteter und unsicher Kryptografiealgorithmen und die Verschlüsselung von mehr des Verbindungshandshake.Improved security due to the removal of various obsolete and insecure cryptographic algorithms and encryption of more of the connection handshake.

.NET Core 3.0 Vorschauversion 1 kann OpenSSL 1.1.1, OpenSSL 1.1.0 oder OpenSSL 1.0.2 (was auch immer die geeignete Lösung ist) auf einem Linux-System verwenden..NET Core 3.0 Preview 1 is capable of utilizing OpenSSL 1.1.1, OpenSSL 1.1.0, or OpenSSL 1.0.2 (whatever the best version found is, on a Linux system). Wenn OpenSSL 1.1.1 verfügbar ist, verwenden „SslStream“- und „HttpClient“-Typen TLS 1.3 bei der Nutzung von SslProtocols.None (systemseitige Standardprotokolle), sofern sowohl der Client als auch der Server TLS 1.3 unterstützen.When OpenSSL 1.1.1 is available the SslStream and HttpClient types will use TLS 1.3 when using SslProtocols.None (system default protocols), assuming both the client and server support TLS 1.3.

Das folgende Beispiel veranschaulicht .NET Core 3.0 Vorschauversion 1 auf Ubuntu 18.10 beim Verbinden mit https://www.cloudflare.com:The following sample demonstrates .NET Core 3.0 Preview 1 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 tlstest
{
    class Program
    {
        static async Task Main()
        {
            using (TcpClient tcpClient = new TcpClient())
            {
                string targetHost = "www.cloudflare.com";

                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}");
                }
            }
        }
    }
}
user@comp-ubuntu1810:~/tlstest$ dotnet run
Connected to www.cloudflare.com with Tls13
user@comp-ubuntu1810:~/tlstest$ openssl version
OpenSSL 1.1.1  11 Sep 2018

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.

KryptografieCryptography

Unterstützung für AES-GCM- und AES-CCM-Verschlüsselungen wurde hinzugefügt, implementiert über System.Security.Cryptography.AesGcm und System.Security.Cryptography.AesCcm.Support has been added for AES-GCM and AES-CCM ciphers, implemented via System.Security.Cryptography.AesGcm and System.Security.Cryptography.AesCcm. Diese Algorithmen sind beide Authenticated Encryption with Association Data (AEAD)-Algorithmen und die ersten Authenticated Encryption (AE)-Algorithmen, die zu .NET Core hinzugefügt wurden.These algorithms are both Authenticated Encryption with Association Data (AEAD) algorithms, and the first Authenticated Encryption (AE) algorithms added to .NET Core.

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.

Der Code für AesCcm würde fast identisch aussehen (nur der Variablenname der Klasse wäre anders).The code for AesCcm would look almost identical (only the class variable names would be different).

// 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 Vorschauversion 1 unterstützt das Importieren und Exportieren der asymmetrischen öffentliche und private Schlüssel aus den Standardformaten, ohne dass ein x. 509-Zertifikat verwendet werden muss..NET Core 3.0 Preview 1 supports the import and export of asymmetric public and private keys from standard formats, without needing to use an X.509 certificate.

Alle Schlüsseltypen (RSA, DSA, ECDsa, ECDiffieHellman) unterstützten das Format X.509 SubjectPublicKeyInfo für öffentliche Schlüssel und die Formate PKCS#8 PrivateKeyInfo und PKCS#8 EncryptedPrivateKeyInfo für private Schlüssel.All key types (RSA, DSA, ECDsa, ECDiffieHellman) support the X.509 SubjectPublicKeyInfo format for public keys, and the PKCS#8 PrivateKeyInfo and PKCS#8 EncryptedPrivateKeyInfo formats for private keys. RSA unterstützt zudem PKCS#1 RSAPublicKey und PKCS#1 RSAPrivateKey.RSA additionally supports PKCS#1 RSAPublicKey and PKCS#1 RSAPrivateKey. Die Exportmethoden erstellen alle DER-kodierte Binärdaten, und die Importmethoden erwarten dasselbe.The export methods all 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.IO;
using System.Security.Cryptography;

namespace rsakeyprint
{
    class Program
    {
        static void Main(string[] args)
        {
            using (RSA rsa = RSA.Create())
            {
                byte[] keyBytes = File.ReadAllBytes(args[0]);
                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));
            }
        }
    }
}
user@comp-ubuntu1810:~/rsakeyprint$ echo Making a small key to save on screen space.
Making a small key to save on screen space.
user@comp-ubuntu1810:~/rsakeyprint$ openssl genrsa 768 | openssl rsa -outform der -out rsa.key
Generating RSA private key, 768 bit long modulus (2 primes)
..+++++++
........+++++++
e is 65537 (0x010001)
writing RSA key
user@comp-ubuntu1810:~/rsakeyprint$ dotnet run rsa.key
Read 461 bytes, 0 extra byte(s) in file.
0F-D0-82-34-F8-13-38-4A-7F-C7-52-4A-F6-93-F8-FB-6D-98-7A-6A-04-3B-BC-35-8C-7D-AC-A5-A3-6E-AD-C1-66-30-81-2C-2A-DE-DA-60-03-6A-2C-D9-76-15-7F-61-97-57-
79-E1-6E-45-62-C3-83-04-97-CB-32-EF-C5-17-5F-99-60-92-AE-B6-34-6F-30-06-03-AC-BF-15-24-43-84-EB-83-60-EF-4D-3B-BD-D9-5D-56-26-F0-51-CE-F1
user@comp-ubuntu1810:~/rsakeyprint$ openssl rsa -in rsa.key -inform der -text -noout | grep -A7 private
privateExponent:
    0f:d0:82:34:f8:13:38:4a:7f:c7:52:4a:f6:93:f8:
    fb:6d:98:7a:6a:04:3b:bc:35:8c:7d:ac:a5:a3:6e:
    ad:c1:66:30:81:2c:2a:de:da:60:03:6a:2c:d9:76:
    15:7f:61:97:57:79:e1:6e:45:62:c3:83:04:97:cb:
    32:ef:c5:17:5f:99:60:92:ae:b6:34:6f:30:06:03:
    ac:bf:15:24:43:84:eb:83:60:ef:4d:3b:bd:d9:5d:
    56:26:f0:51:ce:f1

PKCS #8-Dateien können mit der System.Security.Cryptography.Pkcs.Pkcs8PrivateKeyInfo-Klasse überprüft werden.PKCS#8 files can be inspected with the System.Security.Cryptography.Pkcs.Pkcs8PrivateKeyInfo class.

PFX/PKCS#12-Dateien können mit System.Security.Cryptography.Pkcs.Pkcs12Info oder System.Security.Cryptography.Pkcs.Pkcs12Builder überprüft und bearbeitet werden.PFX/PKCS#12 files can be inspected and manipulated with System.Security.Cryptography.Pkcs.Pkcs12Info and System.Security.Cryptography.Pkcs.Pkcs12Builder, respectively.

SerialPort für LinuxSerialPort for Linux

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

Bisher unterstützte .NET Core nur die Verwendung des SerialPort-Typs auf Windows.Previously, .NET Core only supported using the SerialPort type on Windows.

Weitere BCL-VerbesserungenMore BCL Improvements

Die Typen Span<T>, Memory<T> und verwandte Typen, die in .NET Core 2.1 eingeführt wurden, wurden in .NET Core 3.0 optimiert.The Span<T>, Memory<T>, and related types that were introduced in .NET Core 2.1, have been optimized in .NET Core 3.0. Allgemeine Vorgänge, wie die Bereichserstellung, Slicing, Analyse und Formatierung werden jetzt besser ausgeführt.Common operations such as span construction, slicing, parsing, and formatting now perform better.

Darüber hinaus haben Typen wie String indirekte Verbesserungen, um sie effizienter zu machen, wenn sie als Schlüssel mit Dictionary<TKey, TValue> und anderen Sammlungen verwendet werden.Additionally, types like String have seen under-the-cover improvements to make them more efficient when used as keys with Dictionary<TKey, TValue> and other collections. Um von diesen Verbesserungen zu profitieren, sind keine Codeänderungen erforderlich.No code changes are required to benefit from these improvements.

NET Core 3 Vorschauversion 1 enthält außerdem die folgenden Verbesserungen:The following improvements are also new in .NET Core 3 Preview 1:

  • In HttpClient integrierte Brotli-UnterstützungBrotli support built in to HttpClient
  • ThreadPool.UnsafeQueueWorkItem(IThreadPoolWorkItem)ThreadPool.UnsafeQueueWorkItem(IThreadPoolWorkItem)
  • Unsafe.UnboxUnsafe.Unbox
  • CancellationToken.UnregisterCancellationToken.Unregister
  • Komplexe arithmetische OperatorenComplex arithmetic operators
  • Socket-APIs für TCP-Keep-AliveSocket APIs for TCP keep alive
  • StringBuilder.GetChunksStringBuilder.GetChunks
  • IPEndPoint-AnalyseIPEndPoint parsing
  • RandomNumberGenerator.GetInt32RandomNumberGenerator.GetInt32

Mehrstufig KompilierungTiered compilation

Die mehrstufig Kompilierung ist bei .NET Core 3.0 standardmäßig aktiviert.Tiered compilation is on by default with .NET Core 3.0. Es ist ein Feature, das es der Runtime ermöglicht, den Just-In-Time (JIT)-Compiler adaptiver zu nutzen, um eine bessere Leistung zu erzielen, sowohl beim Start als auch zur Maximierung des Durchsatzes.It is a feature that enables the runtime to more adaptively use the Just-In-Time (JIT) compiler to get better performance, both at startup and to maximize throughput.

Dieses Feature wurde als abonnierbares Feature für .NET Core 2.1 hinzugefügt, und anschließend standardmäßig in der .NET Core 2.2 Vorschauversion 2 aktiviert.This feature was added as an opt-in feature in .NET Core 2.1 and then was enabled by default in .NET Core 2.2 Preview 2. Anschließend wurde es wieder zurückgesetzt, und ist mit dem Release von .NET Core 2.2 wieder abonnierbar.Subsequently, it has been reverted back to opt in with the .NET Core 2.2 release.

ARM64-Linux-SupportARM64 Linux support

ARM64 für Linux wird nun unterstützt.Support has been added 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.

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

Bitte lesen Sie für weitere Informationen .NET Core-ARM64-StatusPlease check .NET Core ARM64 Status for more information.

Hinweis

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

Installieren von .NET Core 3.0-Vorschauversionen unter Linux mit SnapInstall .NET Core 3.0 Previews on Linux with Snap

Snap ist die bevorzugte Methode zum Installieren und Testen von .NET Core-Vorschauversionen unter Linux-Distributionen, die Snap unterstützen.Snap is the preferred way to install and try .NET Core previews on Linux distributions that support Snap.

Führen Sie nach dem Konfigurieren von Snap auf Ihrem System den folgenden Befehl aus, um das .NET Core SDK 3.0 für die Vorschauversion zu installieren.After configuring Snap on your system, run the following command to install the .NET Core SDK 3.0 Preview SDK.

sudo snap install dotnet-sdk --beta --classic

Wenn .NET Core mit dem Snap-Paket installiert wird, lautet der Standardbefehl für .NET Core dotnet-sdk.dotnet und nicht nur dotnet.When .NET Core in installed using the Snap package, the default .NET Core command is dotnet-sdk.dotnet, as opposed to just dotnet. Der Vorteil des Befehls mit dem Namespace besteht darin, dass keine Konflikte mit möglicherweise global installierten .NET Core-Versionen auftreten.The benefit of the namespaced command is that it will not conflict with a globally installed .NET Core version you may have. Für diesen Befehl kann der Alias dotnet wie folgt erstellt werden:This command can be aliased to dotnet with:

sudo snap alias dotnet-sdk.dotnet dotnet

Bei einigen Distributionen ist ein zusätzlicher Schritt zum Aktivieren des Zugriffs auf das SSL-Zertifikat erforderlich.Some distros require an additional step to enable access to the SSL certificate. Details finden Sie im Artikel zur Einrichtung von Linux.See our Linux Setup for details.

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

Über NuGet können nun zwei neue Pakete für die GPIO-Programmierung bezogen werden:Two new 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 includes APIs for GPIO, SPI, I2C and PWM devices. Das IoT-Bindungspaket enthält Gerätebindungen für verschiedene Chips und Sensoren. Dabei handelt es sich um die gleichen Bindungen, die unter dotnet/iot – src/devices verfügbar sind.The IoT bindings package includes device bindings for various chips and sensors, the same ones available at dotnet/iot - src/devices.

Die aktualisierten APIs für serielle Anschlüsse, die zusammen mit der Vorschauversion 1 von .NET Core 3.0 angekündigt wurden, sind nicht in diesen Paketen enthalten, stehen jedoch als Teil der .NET Core-Plattform zur Verfügung.The updated serial port APIs that were announced as part of .NET Core 3.0 Preview 1 are not part of these packages but are available as part of the .NET Core platform.

PlattformunterstützungPlatform Support

.NET Core 3.0 wird auf den folgenden Betriebssystemen unterstützt:.NET Core 3 will be supported on the following operating systems:

  • Windows-Client: 7, 8.1, 10 (1607 und höher)Windows Client: 7, 8.1, 10 (1607+)
  • Windows Server: 2012 R2 SP1+Windows Server: 2012 R2 SP1+
  • macOS: 10.12 und höhermacOS: 10.12+
  • RHEL: 6 und höherRHEL: 6+
  • Fedora: 26 und höherFedora: 26+
  • Ubuntu: 16.04 und höherUbuntu: 16.04+
  • Debian: 9 und höherDebian: 9+
  • SLES: 12 und höherSLES: 12+
  • openSUSE: 42.3+openSUSE: 42.3+
  • Alpine: 3.8+Alpine: 3.8+

Außerdem werden folgende Chiparchitekturen unterstützt:Chip support follows:

  • x64 unter Windows, macOS und Linuxx64 on Windows, macOS, and Linux
  • x86 unter Windowsx86 on Windows
  • ARM32 unter Windows und LinuxARM32 on Windows and Linux
  • ARM64 unter LinuxARM64 on Linux

Für Linux wird ARM32 unter Debian 9 und höher und Ubuntu 16.04 und höher unterstützt.For Linux, ARM32 is supported on Debian 9+ and Ubuntu 16.04+. Für ARM64 gilt das Gleiche wie für ARM32, jedoch wird zusätzlich Alpine 3.8 unterstützt.For ARM64, it is the same as ARM32 with the addition of Alpine 3.8. Es handelt sich um die gleichen Versionen der Distributionen, die auch für x64 unterstützt werden.These are the same versions of those distros as is supported for X64.

Docker-Images für .NET Core 3.0 sind unter microsoft/dotnet im Docker-Hub verfügbar.Docker images for .NET Core 3.0 are available at microsoft/dotnet on Docker Hub. Microsoft arbeitet aktuell an der Einführung der Microsoft Container Registry (MCR). Die finalen .NET Core 3.0-Images werden voraussichtlich nur dort veröffentlicht.Microsoft is currently in the process of adopting Microsoft Container Registry (MCR) and it is expected that the final .NET Core 3.0 images will only be published to MCR.