Co nowego w programie .NET Core 3.0What's new in .NET Core 3.0

W tym artykule opisano nowości w programie .NET Core 3.0.This article describes what is new in .NET Core 3.0. Jednym z największych ulepszeń jest obsługa aplikacji klasycznych systemu Windows (tylko system Windows).One of the biggest enhancements is support for Windows desktop applications (Windows only). Korzystając z pulpitu systemu Windows składnika zestawu SDK platformy .NET Core 3.0, można przenieść aplikacje Windows Forms i Windows Presentation Foundation (WPF).By using the .NET Core 3.0 SDK component Windows Desktop, you can port your Windows Forms and Windows Presentation Foundation (WPF) applications. Aby można było wyczyścić, składnik pulpitu systemu Windows jest obsługiwany i uwzględniany w systemie Windows.To be clear, the Windows Desktop component is only supported and included on Windows. Aby uzyskać więcej informacji, zobacz sekcję pulpitu systemu Windows w dalszej części tego artykułu.For more information, see the Windows desktop section later in this article.

Program .NET Core 3.0 dodaje obsługę C# 8.0..NET Core 3.0 adds support for C# 8.0. Zdecydowanie zaleca się używanie programu Visual Studio 2019 w wersji 16,3 lub nowszej, Visual Studio dla komputerów Mac 8,3 lub nowszego lub Visual Studio Code z najnowszym C# rozszerzeniem.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.

Pobierz i Rozpocznij pracę z platformą .NET Core 3.0 teraz w systemie Windows, MacOS lub Linux.Download and get started with .NET Core 3.0 right now on Windows, macOS, or Linux.

Aby uzyskać więcej informacji o wersji, zobacz anons programu .NET Core 3.0.For more information about the release, see the .NET Core 3.0 announcement.

Środowisko .NET Core RC1 zostało uznane za gotowe do produkcji przez firmę Microsoft i zostało w pełni obsługiwane..NET Core RC1 was considered production ready by Microsoft and was fully supported. Jeśli korzystasz z wersji zapoznawczej, musisz przejść do wersji RTM, aby uzyskać pomoc techniczną.If you're using a preview release, you must move to the RTM version for continued support.

Udoskonalenia C# języka 8,0Language improvements C# 8.0

C#8,0 jest również częścią tej wersji, która obejmuje funkcję typów referencyjnych dopuszczających wartość null , strumienie asynchronicznei więcej wzorców.C# 8.0 is also part of this release, which includes the nullable reference types feature, async streams, and more patterns. Aby uzyskać więcej informacji C# o funkcjach 8.0, zobacz co nowego C# w programie 8.0.For more information about C# 8.0 features, see What's new in C# 8.0.

Wprowadzono ulepszenia dotyczące języka w celu obsługi następujących funkcji API poniżej:Language enhancements were added to support the following API features detailed below:

.NET Standard 2.1.NET Standard 2.1

Platforma .NET Core 3,0 implementuje .NET Standard 2,1..NET Core 3.0 implements .NET Standard 2.1. Jednak domyślny szablon dotnet new classlib generuje projekt, który nadal jest przeznaczony dla .NET Standard 2,0.However, the default dotnet new classlib template generates a project that still targets .NET Standard 2.0. Aby docelowa .NET Standard 2.1, edytuj plik projektu i Zmień TargetFramework właściwość na 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>

Jeśli używasz programu Visual Studio, potrzebujesz programu Visual studio 2019, ponieważ program visual Studio 2017 nie obsługuje .NET Standard 2.1 ani .NET Core 3.0.If you're using Visual Studio, you need Visual Studio 2019, as Visual Studio 2017 doesn't support .NET Standard 2.1 or .NET Core 3.0.

Kompiluj/WdróżCompile/Deploy

Domyślne pliki wykonywalneDefault executables

Platforma .NET Core teraz domyślnie kompiluje pliki wykonywalne zależne od platformy ..NET Core now builds framework-dependent executables by default. To zachowanie jest nowe w przypadku aplikacji korzystających z zainstalowanej globalnie wersji platformy .NET Core.This behavior is new for applications that use a globally installed version of .NET Core. Wcześniej tylko wstępnie zawarte wdrożenia spowodują utworzenie pliku wykonywalnego.Previously, only self-contained deployments would produce an executable.

W trakcie dotnet build lub dotnet publish, tworzony jest plik wykonywalny zgodny ze środowiskiem i platformą używanego zestawu SDK.During dotnet build or dotnet publish, an executable is created that matches the environment and platform of the SDK you're using. Można oczekiwać, że te same elementy wykonywalne są takie same jak w przypadku innych natywnych plików wykonywalnych, takich jak:You can expect the same things with these executables as you would other native executables, such as:

  • Możesz kliknąć dwukrotnie plik wykonywalny.You can double-click on the executable.
  • Aplikację można uruchomić bezpośrednio z poziomu wiersza polecenia, na przykład myapp.exe w systemie Windows i ./myapp w systemie Linux i macOS.You can launch the application from a command prompt directly, such as myapp.exe on Windows, and ./myapp on Linux and macOS.

Pliki wykonywalne pojedynczego plikuSingle-file executables

Polecenie dotnet publish obsługuje pakowanie aplikacji do pliku wykonywalnego określonego dla konkretnej platformy.The dotnet publish command supports packaging your app into a platform-specific single-file executable. Plik wykonywalny jest samowyodrębniający się i zawiera wszystkie zależności (w tym natywne) wymagane do uruchomienia aplikacji.The executable is self-extracting and contains all dependencies (including native) that are required to run your app. Gdy aplikacja jest uruchamiana po raz pierwszy, aplikacja zostanie wyodrębniona do katalogu na podstawie nazwy aplikacji i identyfikatora kompilacji.When the app is first run, the application is extracted to a directory based on the app name and build identifier. Uruchamianie jest szybsze, gdy aplikacja jest uruchamiana ponownie.Startup is faster when the application is run again. Aplikacja nie musi wyodrębniać siebie po raz drugi, chyba że została użyta Nowa wersja.The application doesn't need to extract itself a second time unless a new version was used.

Aby opublikować plik wykonywalny pojedynczego pliku, ustaw PublishSingleFile w projekcie lub w wierszu polecenia za pomocą polecenia dotnet publish:To publish a single-file executable, set the PublishSingleFile in your project or on the command line with the dotnet publish command:

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

lub-or-

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

Aby uzyskać więcej informacji o publikowaniu jednoplikowym, zapoznaj się z dokumentem projektu pakietu pojedynczego pliku.For more information about single-file publishing, see the single-file bundler design document.

Łączenie zestawówAssembly linking

Zestaw SDK platformy .NET Core 3.0 zawiera narzędzie, które pozwala zmniejszyć rozmiar aplikacji przez analizowanie IL i przycinanie nieużywanych zestawów.The .NET core 3.0 SDK comes with a tool that can reduce the size of apps by analyzing IL and trimming unused assemblies.

Aplikacje samodzielne obejmują wszystko, co jest potrzebne do uruchomienia kodu, bez konieczności instalowania programu .NET na komputerze-hoście.Self-contained apps include everything needed to run your code, without requiring .NET to be installed on the host computer. Jednak wiele razy aplikacja wymaga tylko małego podzestawu platformy do działania, a inne nieużywane biblioteki mogą zostać usunięte.However, many times the app only requires a small subset of the framework to function, and other unused libraries could be removed.

Platforma .NET Core zawiera teraz ustawienie, które będzie używać narzędzia konsolidatora Il do skanowania Il aplikacji..NET Core now includes a setting that will use the IL linker tool to scan the IL of your app. To narzędzie wykrywa wymagany kod, a następnie przycina nieużywane biblioteki.This tool detects what code is required, and then trims unused libraries. To narzędzie może znacznie zmniejszyć rozmiar wdrożenia niektórych aplikacji.This tool can significantly reduce the deployment size of some apps.

Aby włączyć to narzędzie, należy dodać ustawienie <PublishTrimmed> w projekcie i opublikować samodzielną aplikację: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

Na przykład podstawowy "Hello World" nowy szablon projektu konsoli, który jest dostępny po opublikowaniu, trafień o rozmiarze 70 MB.As an example, the basic "hello world" new console project template that is included, when published, hits about 70 MB in size. Przy użyciu <PublishTrimmed>rozmiar jest zmniejszany do około 30 MB.By using <PublishTrimmed>, that size is reduced to about 30 MB.

Należy wziąć pod uwagę, że aplikacje lub struktury (w tym ASP.NET Core i WPF), które wykorzystują odbicie lub powiązane funkcje dynamiczne, często będą przerywane po przycięciu.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. To uszkodzenie występuje, ponieważ konsolidator nie wie o tym zachowaniu dynamicznym i nie może określić, które typy struktur są wymagane do odbicia.This breakage occurs because the linker doesn't know about this dynamic behavior and can't determine which framework types are required for reflection. Narzędzie konsolidatora IL można skonfigurować pod kątem tego scenariusza.The IL Linker tool can be configured to be aware of this scenario.

Przed przycinaniem upewnij się, że aplikacja została przetestowana.Above all else, be sure to test your app after trimming.

Aby uzyskać więcej informacji na temat narzędzia konsolidatora IL, zapoznaj się z dokumentacją lub odwiedź repozytorium mono/konsolidatora .For more information about the IL Linker tool, see the documentation or visit the mono/linker repo.

Kompilacja warstwowaTiered compilation

Kompilacja warstwowa (TC) jest domyślnie włączona z platformą .NET Core 3.0.Tiered compilation (TC) is on by default with .NET Core 3.0. Ta funkcja umożliwia środowisku uruchomieniowemu wydajniejsze używanie kompilatora just-in-Time (JIT) w celu uzyskania lepszej wydajności.This feature enables the runtime to more adaptively use the just-in-time (JIT) compiler to achieve better performance.

Główną zaletą kompilacji warstwowej jest zapewnienie dwóch sposobów jitting metod: w warstwach o niższej jakości lub szybszych lub wyższych warstwach.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. Jakość odnosi się do tego, jak dobrze jest zoptymalizowana Metoda.The quality refers to how well the method is optimized. TC ułatwia zwiększenie wydajności aplikacji w miarę przechodzenia przez różne etapy wykonywania — od uruchomienia do stanu stałego.TC helps to improve the performance of an application as it goes through various stages of execution, from startup through steady state. Gdy kompilacja warstwowa jest wyłączona, każda metoda jest kompilowana w jednym ze sposobów, która jest obciążona wydajnością o stałej kondycji w porównaniu z wydajnością uruchamiania.When tiered compilation is disabled, every method is compiled in a single way that's biased to steady-state performance over startup performance.

Po włączeniu TC następujące zachowanie ma zastosowanie do kompilacji metody podczas uruchamiania aplikacji:When TC is enabled, the following behavior applies for method compilation when an app starts up:

  • Jeśli metoda zawiera kod skompilowany z wyprzedzeniem lub ReadyToRun, używany jest wygenerowany kod.If the method has ahead-of-time-compiled code, or ReadyToRun, the pregenerated code is used.
  • W przeciwnym razie metoda jest trybie JIT.Otherwise, the method is jitted. Zazwyczaj te metody są ogólne względem typów wartościowych.Typically, these methods are generics over value types.
    • Szybkie kompilatory umożliwiają szybsze generowanie kodu o niższej jakości (lub mniej zoptymalizowanym).Quick JIT produces lower-quality (or less optimized) code more quickly. W przypadku programu .NET Core 3,0, szybkie JIT jest domyślnie włączone dla metod, które nie zawierają pętli i są preferowane podczas uruchamiania.In .NET Core 3.0, Quick JIT is enabled by default for methods that don't contain loops and is preferred during startup.
    • W pełni Optymalizacja JIT powoduje szybsze generowanie kodu o wyższej jakości (lub bardziej zoptymalizowany).The fully-optimizing JIT produces higher-quality (or more optimized) code more slowly. Dla metod, w których nie można użyć metody szybkiej JIT (na przykład jeśli metoda ma atrybut MethodImplOptions.AggressiveOptimization), używana jest pełna optymalizacja JIT.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.

W przypadku często wywoływanych metod kompilator just in Time w końcu tworzy w tle w pełni zoptymalizowany kod.For frequently called methods, the just-in-time compiler eventually creates fully optimized code in the background. Zoptymalizowany kod zastępuje wstępnie skompilowany kod dla tej metody.The optimized code then replaces the pre-compiled code for that method.

Kod wygenerowany przez szybką JIT może działać wolniej, przydzielać więcej pamięci lub używać większej ilości miejsca na stosie.Code generated by Quick JIT may run slower, allocate more memory, or use more stack space. Jeśli występują problemy, można wyłączyć szybkie JIT przy użyciu tej właściwości programu MSBuild w pliku projektu:If there are issues, you can disabled Quick JIT using this MSBuild property in the project file:

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

Aby całkowicie wyłączyć TC, Użyj tej właściwości programu MSBuild w pliku projektu:To disable TC completely, use this MSBuild property in your project file:

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

Porada

Jeśli zmienisz te ustawienia w pliku projektu, może być konieczne wykonanie czystej kompilacji w celu odzwierciedlenia nowych ustawień (Usuń obj i bin katalogi i Skompiluj ponownie).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).

Aby uzyskać więcej informacji o konfigurowaniu kompilacji w czasie wykonywania, zobacz Opcje konfiguracji czasu wykonywania dla kompilacji.For more information about configuring compilation at run time, see Run-time configuration options for compilation.

Obrazy ReadyToRunReadyToRun images

Można skrócić czas uruchamiania aplikacji .NET Core, kompilując zestawy aplikacji jako ReadyToRun (R2R).You can improve the startup time of your .NET Core application by compiling your application assemblies as ReadyToRun (R2R) format. R2R to forma kompilacji z wyprzedzeniem (AOT).R2R is a form of ahead-of-time (AOT) compilation.

Pliki binarne R2R zwiększają wydajność uruchamiania przez zmniejszenie ilości pracy kompilatora, który jest potrzebny do załadowania aplikacji.R2R binaries improve startup performance by reducing the amount of work the just-in-time (JIT) compiler needs to do as your application loads. Pliki binarne zawierają podobny kod natywny w porównaniu z przeznaczeniem JIT.The binaries contain similar native code compared to what the JIT would produce. R2R pliki binarne są jednak większe, ponieważ zawierają kod języka pośredniego (IL), który jest nadal wymagany w niektórych scenariuszach i natywną wersję tego samego kodu.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 jest dostępna tylko w przypadku publikowania aplikacji samodzielnej, która jest przeznaczona dla określonych środowisk uruchomieniowych (RID), takich jak Linux x64 lub Windows x64.R2R is only available when you publish a self-contained app that targets specific runtime environments (RID) such as Linux x64 or Windows x64.

Aby skompilować projekt jako ReadyToRun, wykonaj następujące czynności:To compile your project as ReadyToRun, do the following:

  1. Dodaj do projektu ustawienie <PublishReadyToRun>:Add the <PublishReadyToRun> setting to your project:

    <PropertyGroup>
      <PublishReadyToRun>true</PublishReadyToRun>
    </PropertyGroup>
    
  2. Publikowanie aplikacji samodzielnej.Publish a self-contained app. Na przykład to polecenie tworzy samodzielną aplikację dla 64-bitowej wersji systemu 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
    

Ograniczenia dotyczące wielu platform/architekturyCross platform/architecture restrictions

Kompilator ReadyToRun nie obsługuje obecnie określania wartości docelowej.The ReadyToRun compiler doesn't currently support cross-targeting. Należy skompilować na danym miejscu docelowym.You must compile on a given target. Na przykład jeśli chcesz, aby obrazy R2R dla systemu Windows x64 zostały wykonane, należy uruchomić polecenie Publikuj w tym środowisku.For example, if you want R2R images for Windows x64, you need to run the publish command on that environment.

Wyjątki dla wielu elementów docelowych:Exceptions to cross-targeting:

  • System Windows x64 może służyć do kompilowania obrazów systemów Windows ARM32, ARM64 i x86.Windows x64 can be used to compile Windows ARM32, ARM64, and x86 images.
  • System Windows x86 może służyć do kompilowania obrazów ARM32 systemu Windows.Windows x86 can be used to compile Windows ARM32 images.
  • System Linux x64 może służyć do kompilowania obrazów systemu Linux ARM32 i ARM64.Linux x64 can be used to compile Linux ARM32 and ARM64 images.

Środowisko uruchomieniowe/zestaw SDKRuntime/SDK

Wersja główna — przekazanie do przoduMajor-version Roll Forward

W programie .NET Core 3.0 wprowadzono funkcję wyboru, która pozwala aplikacji na przewinięcie do najnowszej wersji programu .NET Core..NET Core 3.0 introduces an opt-in feature that allows your app to roll forward to the latest major version of .NET Core. Ponadto zostało dodane nowe ustawienie służące do kontrolowania sposobu, w jaki przenoszone do przodu jest stosowane do aplikacji.Additionally, a new setting has been added to control how roll forward is applied to your app. Tę konfigurację można skonfigurować w następujący sposób:This can be configured in the following ways:

  • Właściwość pliku projektu: RollForwardProject file property: RollForward
  • Właściwość pliku konfiguracji czasu wykonywania: rollForwardRun-time configuration file property: rollForward
  • Zmienna środowiskowa: DOTNET_ROLL_FORWARDEnvironment variable: DOTNET_ROLL_FORWARD
  • Argument wiersza polecenia: --roll-forwardCommand-line argument: --roll-forward

Należy określić jedną z następujących wartości.One of the following values must be specified. Jeśli ustawienie zostanie pominięte, wartością domyślną jest wartość pomocnicza .If the setting is omitted, Minor is the default.

  • LatestPatchLatestPatch
    Przewinięcie do najwyższej wersji poprawki.Roll forward to the highest patch version. Spowoduje to wyłączenie wycofywania wersji pomocniczej.This disables minor version roll forward.
  • \ pomocniczeMinor</span> Przewinięcie do najmniejszej wyższej wersji pomocniczej, jeśli brakuje wymaganej wersji pomocniczej.Roll forward to the lowest higher minor version, if requested minor version is missing. Jeśli jest obecna żądana wersja pomocnicza, zostaną użyte zasady LatestPatch .If the requested minor version is present, then the LatestPatch policy is used.
  • \ GłówneMajor</span> Zaczekaj na najmniejszą wyższą wersję główną i najniższą wersję pomocniczą, jeśli brakuje żądanej wersji głównej.Roll forward to lowest higher major version, and lowest minor version, if requested major version is missing. Jeśli jest obecna żądana wersja główna, są używane zasady pomocnicze .If the requested major version is present, then the Minor policy is used.
  • LatestMinorLatestMinor
    Przewinięcie do przodu do najwyższej wersji pomocniczej, nawet jeśli jest obecna żądana wersja pomocnicza.Roll forward to highest minor version, even if requested minor version is present. Przeznaczone do scenariuszy hostingu składników.Intended for component hosting scenarios.
  • LatestMajorLatestMajor
    Przewinięcie do przodu do najwyższej głównej i najwyższej wersji pomocniczej, nawet jeśli jest obecny żądany główny.Roll forward to highest major and highest minor version, even if requested major is present. Przeznaczone do scenariuszy hostingu składników.Intended for component hosting scenarios.
  • WyłączDisable
    Nie przetaczaj dalej.Don't roll forward. Powiąż tylko z określoną wersją.Only bind to specified version. Te zasady nie są zalecane do użytku ogólnego, ponieważ uniemożliwiają one przekazanie do najnowszych poprawek.This policy isn't recommended for general use because it disables the ability to roll forward to the latest patches. Ta wartość jest zalecana tylko do celów testowych.This value is only recommended for testing.

Oprócz ustawienia Wyłącz wszystkie ustawienia będą używać najwyższej dostępnej wersji poprawki.Besides the Disable setting, all settings will use the highest available patch version.

Zależności kompilacji kopiiBuild copies dependencies

Polecenie dotnet build teraz kopiuje zależności NuGet dla aplikacji z pamięci podręcznej NuGet do folderu danych wyjściowych kompilacji.The dotnet build command now copies NuGet dependencies for your application from the NuGet cache to the build output folder. Wcześniej zależności były kopiowane tylko jako część dotnet publish.Previously, dependencies were only copied as part of dotnet publish.

Istnieją pewne operacje, takie jak łączenie i publikowanie stron Razor, które nadal wymagają publikacji.There are some operations, like linking and razor page publishing that will still require publishing.

Narzędzia lokalneLocal tools

Środowisko .NET Core 3.0 zawiera wprowadzenie do narzędzi lokalnych..NET Core 3.0 introduces local tools. Narzędzia lokalne są podobne do narzędzi globalnych , ale są skojarzone z konkretną lokalizacją na dysku.Local tools are similar to global tools but are associated with a particular location on disk. Narzędzia lokalne nie są dostępne globalnie i są dystrybuowane jako pakiety NuGet.Local tools aren't available globally and are distributed as NuGet packages.

Ostrzeżenie

Jeśli podjęto próbę skorzystania z narzędzi lokalnych w programie .NET Core 3.0 dotnet tool restore w dotnet tool installwersji zapoznawczej 1, takiej jak uruchamianie lub, Usuń folder pamięci podręcznej narzędzi lokalnychIf 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. W przeciwnym razie narzędzia lokalne nie będą działały w żadnej nowszej wersji.Otherwise, local tools won't work on any newer release. Ten folder znajduje się w lokalizacji:This folder is located at:

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

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

Narzędzia lokalne są zależne od nazwy pliku manifestu dotnet-tools.json w bieżącym katalogu.Local tools rely on a manifest file name dotnet-tools.json in your current directory. Ten plik manifestu definiuje narzędzia do udostępnienia w tym folderze i poniżej.This manifest file defines the tools to be available at that folder and below. Plik manifestu można dystrybuować z kodem, aby upewnić się, że każda osoba, która współpracuje z kodem, będzie mogła przywrócić i korzystać z tych samych narzędzi.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.

W przypadku narzędzi globalnych i lokalnych wymagana jest zgodna wersja środowiska uruchomieniowego.For both global and local tools, a compatible version of the runtime is required. Wiele narzędzi obecnie na NuGet.org docelowym środowiska uruchomieniowego .NET Core 2.1.Many tools currently on NuGet.org target .NET Core Runtime 2.1. Aby zainstalować te narzędzia globalnie lub lokalnie, nadal trzeba zainstalować środowisko uruchomieniowe NET Core 2.1.To install these tools globally or locally, you would still need to install the NET Core 2.1 Runtime.

Mniejsze rozmiary sterty wyrzucania elementów bezużytecznychSmaller Garbage Collection heap sizes

Rozmiar sterty domyślnej modułu wyrzucania elementów bezużytecznych został zmniejszony z powodu mniejszej ilości pamięci w programie .NET Core.The Garbage Collector's default heap size has been reduced resulting in .NET Core using less memory. Ta zmiana jest lepsza w porównaniu z budżetem alokacji generacji 0 z nowoczesnymi rozmiarami pamięci podręcznej.This change better aligns with the generation 0 allocation budget with modern processor cache sizes.

Obsługa dużej strony odzyskiwania pamięciGarbage Collection Large Page support

Duże strony (znane również jako ogromne strony w systemie Linux) to funkcja, w której system operacyjny może ustalić obszary pamięci większe niż rozmiar strony natywnej (często 4K), aby zwiększyć wydajność aplikacji żądającej tych dużych stron.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.

Moduł wyrzucania elementów bezużytecznych można teraz skonfigurować przy użyciu ustawienia GCLargePages jako funkcji wyboru do przydzielania dużych stron w systemie Windows.The Garbage Collector can now be configured with the GCLargePages setting as an opt-in feature to choose to allocate large pages on Windows.

Windows Desktop & COMWindows Desktop & COM

Zestaw .NET Core SDK Instalator Windows.NET Core SDK Windows Installer

Instalator MSI dla systemu Windows został zmieniony począwszy od platformy .NET Core 3.0.The MSI installer for Windows has changed starting with .NET Core 3.0. Instalatorzy zestawu SDK teraz uaktualniają wersje funkcji zestawu SDK na miejscu.The SDK installers will now upgrade SDK feature-band releases in place. Paski funkcji są zdefiniowane w grupach setek w sekcji poprawka numeru wersji.Feature bands are defined in the hundreds groups in the patch section of the version number. Na przykład 3.0. 101 i 3.0. 201 są wersje w dwóch różnych warstwach funkcji podczas 3.0. 101 i 3.0. 199 znajdują się w tej samej paśmie funkcji.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. I, w przypadku zestaw .NET Core SDK 3.0. 101 jest zainstalowana, zestaw .NET Core SDK 3.0. 100 zostanie usunięta z komputera, jeśli istnieje.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. Gdy zestaw .NET Core SDK 3.0. 200 jest zainstalowana na tym samym komputerze, zestaw .NET Core SDK 3.0. 101 nie zostanie usunięta.When .NET Core SDK 3.0.200 is installed on the same machine, .NET Core SDK 3.0.101 won't be removed.

Aby uzyskać więcej informacji na temat przechowywania wersji, zobacz Omówienie wersji platformy .NET Core.For more information about versioning, see Overview of how .NET Core is versioned.

Pulpit systemu WindowsWindows desktop

Program .NET Core 3.0 obsługuje aplikacje klasyczne systemu Windows przy użyciu Windows Presentation Foundation (WPF) i Windows Forms..NET Core 3.0 supports Windows desktop applications using Windows Presentation Foundation (WPF) and Windows Forms. Te struktury obsługują również korzystanie z nowoczesnych kontrolek i stylów Fluent z poziomu biblioteki XAML interfejsu użytkownika systemu Windows (WinUI) za pośrednictwem wysp XAML.These frameworks also support using modern controls and Fluent styling from the Windows UI XAML Library (WinUI) via XAML islands.

Składnik pulpitu systemu Windows jest częścią zestawu SDK systemu Windows .NET Core 3.0.The Windows Desktop component is part of the Windows .NET Core 3.0 SDK.

Nową aplikację WPF lub Windows Forms można utworzyć przy użyciu następujących poleceń dotnet:You can create a new WPF or Windows Forms app with the following dotnet commands:

dotnet new wpf
dotnet new winforms

Program Visual Studio 2019 dodaje nowe szablony projektów dla platformy .NET Core 3.0 Windows Forms i WPF.Visual Studio 2019 adds New Project templates for .NET Core 3.0 Windows Forms and WPF.

Aby uzyskać więcej informacji na temat sposobu przenoszenia istniejącej aplikacji .NET Framework, zobacz port WPF projekty i projekty Windows Forms portów.For more information about how to port an existing .NET Framework application, see Port WPF projects and Port Windows Forms projects.

Bardzo wysokie wartości DPIWinForms high DPI

Aplikacje .NET Core Windows Forms mogą ustawiać tryb wysokiej rozdzielczości DPI z Application.SetHighDpiMode(HighDpiMode)..NET Core Windows Forms applications can set high DPI mode with Application.SetHighDpiMode(HighDpiMode). Metoda SetHighDpiMode ustawia odpowiedni tryb wysokiej rozdzielczości DPI, chyba że ustawienie zostało ustawione za pomocą innych metod, takich jak App.Manifest lub P/Invoke przed Application.Run.The SetHighDpiMode method sets the corresponding high DPI mode unless the setting has been set by other means like App.Manifest or P/Invoke before Application.Run.

Możliwe wartości highDpiMode wyrażone przez Wyliczenie System.Windows.Forms.HighDpiMode są następujące:The possible highDpiMode values, as expressed by the System.Windows.Forms.HighDpiMode enum are:

  • DpiUnaware
  • SystemAware
  • PerMonitor
  • PerMonitorV2
  • DpiUnawareGdiScaled

Aby uzyskać więcej informacji na temat trybów wysokiej rozdzielczości DPI, zobacz Tworzenie aplikacji klasycznych o wysokiej rozdzielczości DPI w systemie Windows.For more information about high DPI modes, see High DPI Desktop Application Development on Windows.

Tworzenie składników COMCreate COM components

W systemie Windows można teraz tworzyć zarządzane składniki COM.On Windows, you can now create COM-callable managed components. Ta funkcja ma kluczowe znaczenie dla korzystania z platformy .NET Core z modelami dodatków COM, a także do zapewnienia parzystości .NET Framework.This capability is critical to use .NET Core with COM add-in models and also to provide parity with .NET Framework.

W przeciwieństwie do .NET Framework, w którym Biblioteka mscoree. dll była używana jako serwer com, podczas kompilowania składnika com program .NET Core doda natywną bibliotekę DLL uruchamiania do katalogu bin .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.

Przykład sposobu tworzenia składnika modelu COM i korzystania z niego można znaleźć w demonstracji modelu COM.For an example of how to create a COM component and consume it, see the COM Demo.

Windows Native InteropWindows Native Interop

System Windows oferuje bogaty natywny interfejs API w postaci prostych interfejsów API języka C, COM i WinRT.Windows offers a rich native API in the form of flat C APIs, COM, and WinRT. Podczas gdy platforma .NET Core obsługuje funkcję P/Invoke, program .NET Core 3.0 dodaje możliwość CoCreate interfejsów API modelu COM i aktywowania interfejsów API WinRT.While .NET Core supports P/Invoke, .NET Core 3.0 adds the ability to CoCreate COM APIs and Activate WinRT APIs. Aby zapoznać się z przykładem kodu, zobacz Demonstracja programu Excel.For a code example, see the Excel Demo.

Wdrożenie MSIXMSIX Deployment

MSIX to nowy format pakietu aplikacji systemu Windows.MSIX is a new Windows application package format. Można go użyć do wdrożenia aplikacji klasycznych platformy .NET Core 3.0 w systemie Windows 10.It can be used to deploy .NET Core 3.0 desktop applications to Windows 10.

Projekt pakietu aplikacji systemu Windows, dostępny w programie Visual Studio 2019, umożliwia tworzenie pakietów MSIX przy użyciu samodzielnych aplikacji .NET Core.The Windows Application Packaging Project, available in Visual Studio 2019, allows you to create MSIX packages with self-contained .NET Core applications.

Plik projektu .NET Core musi określać obsługiwane środowiska uruchomieniowe we właściwości <RuntimeIdentifiers>:The .NET Core project file must specify the supported runtimes in the <RuntimeIdentifiers> property:

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

Udoskonalenia systemu LinuxLinux improvements

Klasy SerialPort dla systemu LinuxSerialPort for Linux

Program .NET Core 3.0 zapewnia podstawową pomoc System.IO.Ports.SerialPort techniczną dla systemu Linux..NET Core 3.0 provides basic support for System.IO.Ports.SerialPort on Linux.

Wcześniej platforma .NET Core była obsługiwana tylko przy użyciu SerialPort w systemie Windows.Previously, .NET Core only supported using SerialPort on Windows.

Aby uzyskać więcej informacji o ograniczonej obsłudze portu szeregowego w systemie Linux, zobacz artykuł dotyczący usługi GitHub #33146.For more information about the limited support for the serial port on Linux, see GitHub issue #33146.

Limity pamięci Docker i cgroupDocker and cgroup memory Limits

Uruchamianie programu .NET Core 3.0 w systemie Linux przy użyciu platformy Docker działa lepiej z limitami pamięci cgroup.Running .NET Core 3.0 on Linux with Docker works better with cgroup memory limits. Uruchamianie kontenera Docker z limitami pamięci, na przykład z docker run -m, zmienia sposób działania programu .NET Core.Running a Docker container with memory limits, such as with docker run -m, changes how .NET Core behaves.

  • Domyślny rozmiar sterty modułu wyrzucania elementów bezużytecznych (GC): maksymalnie 20 MB lub 75% limitu pamięci w kontenerze.Default Garbage Collector (GC) heap size: maximum of 20 mb or 75% of the memory limit on the container.
  • Rozmiar jawny można ustawić jako liczbę bezwzględną lub procent limitu cgroup.Explicit size can be set as an absolute number or percentage of cgroup limit.
  • Minimalny zarezerwowany rozmiar segmentu na stos GC to 16 MB.Minimum reserved segment size per GC heap is 16 mb. Ten rozmiar zmniejsza liczbę stert, które są tworzone na maszynach.This size reduces the number of heaps that are created on machines.

Obsługa interfejsu GPIO dla Raspberry PiGPIO Support for Raspberry Pi

Do programu NuGet zostały wydane dwa pakiety, których można użyć do programowania interfejsu GPIO:Two packages have been released to NuGet that you can use for GPIO programming:

Pakiety GPIO obejmują interfejsy API dla urządzeń z interfejsem GPIO, SPI, I2Ci PWM .The GPIO packages include APIs for GPIO, SPI, I2C, and PWM devices. Pakiet powiązań IoT obejmuje powiązania urządzeń.The IoT bindings package includes device bindings. Aby uzyskać więcej informacji, zobacz repozytorium GitHub.For more information, see the devices GitHub repo.

Obsługa systemu Linux ARM64ARM64 Linux support

Program .NET Core 3.0 dodaje obsługę ARM64 dla systemu Linux..NET Core 3.0 adds support for ARM64 for Linux. Podstawowy przypadek użycia dla ARM64 jest obecnie z scenariuszami IoT.The primary use case for ARM64 is currently with IoT scenarios. Aby uzyskać więcej informacji, zobacz temat stan arm64 programu .NET Core.For more information, see .NET Core ARM64 Status.

Obrazy Docker dla platformy .NET Core w systemie arm64 są dostępne dla Alpine, Debian i Ubuntu.Docker images for .NET Core on ARM64 are available for Alpine, Debian, and Ubuntu.

Uwaga

Arm64 Obsługa systemu Windows nie jest jeszcze dostępna.ARM64 Windows support isn't yet available.

ZabezpieczeniaSecurity

TLS 1.3 & OpenSSL 1.1.1 w systemie LinuxTLS 1.3 & OpenSSL 1.1.1 on Linux

Platforma .NET Core wykorzystuje teraz zalety protokołu TLS 1.3 w OpenSSL 1.1.1, gdy jest on dostępny w danym środowisku..NET Core now takes advantage of TLS 1.3 support in OpenSSL 1.1.1, when it's available in a given environment. Z protokołem TLS 1.3:With TLS 1.3:

  • Czas połączenia jest ulepszony ze zredukowanymi przedziałami rundy między klientem i serwerem.Connection times are improved with reduced round trips required between the client and server.
  • Ulepszone zabezpieczenia spowodowane usuwaniem różnych przestarzałych i niezabezpieczonych algorytmów kryptograficznych.Improved security because of the removal of various obsolete and insecure cryptographic algorithms.

Jeśli jest dostępny, program .NET Core 3.0 używa OpenSSL 1.1.1, OpenSSL 1.1.0lub OpenSSL 1.0.2 w systemie Linux.When available, .NET Core 3.0 uses OpenSSL 1.1.1, OpenSSL 1.1.0, or OpenSSL 1.0.2 on a Linux system. Gdy OpenSSL 1.1.1 jest dostępny, oba System.Net.Security.SslStream typy System.Net.Http.HttpClient i używają protokołu TLS 1.3 (przy założeniu, że zarówno klient, jak i serwer obsługują protokół TLS 1.3).When OpenSSL 1.1.1 is available, both System.Net.Security.SslStream and System.Net.Http.HttpClient types will use TLS 1.3 (assuming both the client and server support TLS 1.3).

Ważne

Systemy Windows i macOS nie obsługują jeszcze protokołu TLS 1.3.Windows and macOS do not yet support TLS 1.3. Platforma .NET Core 3.0 będzie obsługiwać protokół TLS 1.3 w tych systemach operacyjnych, gdy będzie dostępna pomoc techniczna..NET Core 3.0 will support TLS 1.3 on these operating systems when support becomes available.

Poniższy C# przykład 8,0 ilustruje platformę .NET Core 3.0 na Ubuntu 18.10 https://www.cloudflare.comz: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}");
        }
    }
}

Szyfrowanie kryptografiiCryptography ciphers

Program .NET 3.0 dodaje obsługę szyfrów AES-GCM i AES-CCM , implementowanych System.Security.Cryptography.AesGcm za System.Security.Cryptography.AesCcm pomocą i odpowiednio..NET 3.0 adds support for AES-GCM and AES-CCM ciphers, implemented with System.Security.Cryptography.AesGcm and System.Security.Cryptography.AesCcm respectively. Te algorytmy są uwierzytelnianiem uwierzytelnianym przy użyciu algorytmów danych skojarzenia (AEAD).These algorithms are both Authenticated Encryption with Association Data (AEAD) algorithms.

Poniższy kod ilustruje użycie szyfru AesGcm do szyfrowania i odszyfrowywania danych losowych.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.");
        }
    }
}

Import/Eksport klucza kryptograficznegoCryptographic Key Import/Export

Program .NET Core 3.0 obsługuje importowanie i eksportowanie asymetrycznych kluczy publicznych i prywatnych z formatów standardowych..NET Core 3.0 supports the import and export of asymmetric public and private keys from standard formats. Nie musisz używać certyfikatu X. 509.You don't need to use an X.509 certificate.

Wszystkie typy kluczy, takie jak RSA, DSA, ECDSAi ECDiffieHellman, obsługują następujące formaty:All key types, such as RSA, DSA, ECDsa, and ECDiffieHellman, support the following formats:

  • Klucz publicznyPublic Key

    • SubjectPublicKeyInfo X. 509X.509 SubjectPublicKeyInfo
  • Klucz prywatnyPrivate key

    • PrivateKeyInfo PKCS # 8PKCS#8 PrivateKeyInfo
    • EncryptedPrivateKeyInfo PKCS # 8PKCS#8 EncryptedPrivateKeyInfo

Klucze RSA obsługują również:RSA keys also support:

  • Klucz publicznyPublic Key

    • RSAPublicKey PKCS # 1PKCS#1 RSAPublicKey
  • Klucz prywatnyPrivate key

    • RSAPrivateKey PKCS # 1PKCS#1 RSAPrivateKey

Metody eksportowania generują dane binarne kodowane algorytmem DER, a metody importowe oczekują na to samo.The export methods produce DER-encoded binary data, and the import methods expect the same. Jeśli klucz jest przechowywany w formacie PEM przyjaznym dla tekstu, wywołujący będzie musiał odkodować zawartość przed wywołaniem metody Import.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));
        }
    }
}

Pliki PKCS # 8 można sprawdzić za pomocą System.Security.Cryptography.Pkcs.Pkcs8PrivateKeyInfo, a pliki PFX/PKCS # 12 można sprawdzić przy użyciu 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. Pliki PFX/PKCS # 12 można manipulować przy użyciu System.Security.Cryptography.Pkcs.Pkcs12Builder.PFX/PKCS#12 files can be manipulated with System.Security.Cryptography.Pkcs.Pkcs12Builder.

Zmiany interfejsu API programu .NET Core 3,0.NET Core 3.0 API changes

Zakresy i indeksyRanges and indices

Nowy typ System.Index może służyć do indeksowania.The new System.Index type can be used for indexing. Można utworzyć jeden z int, który liczy od początku lub z prefiksem ^ (C#), który liczy się od końca: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"

Istnieje również typ System.Range, który składa się z dwóch Index wartości, jeden dla początku i jeden dla końca, i może być zapisany z wyrażeniem zakresu x..y (C#).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#). Następnie można indeksować za pomocą Range, co spowoduje utworzenie wycinka:You can then index with a Range, which produces a slice:

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

Aby uzyskać więcej informacji, zobacz Samouczek dotyczący zakresów i indeksów.For more information, see the ranges and indices tutorial.

Strumienie asynchroniczneAsync streams

Typ IAsyncEnumerable<T> to nowa asynchroniczna wersja IEnumerable<T>.The IAsyncEnumerable<T> type is a new asynchronous version of IEnumerable<T>. Język pozwala await foreach za pośrednictwem IAsyncEnumerable<T> do korzystania z ich elementów, a następnie używać yield return do tworzenia elementów.The language lets you await foreach over IAsyncEnumerable<T> to consume their elements, and use yield return to them to produce elements.

Poniższy przykład ilustruje produkcję i zużycie strumieni asynchronicznych.The following example demonstrates both production and consumption of async streams. Instrukcja foreach jest asynchroniczna i sama używa yield return do tworzenia strumienia asynchronicznego dla obiektów wywołujących.The foreach statement is async and itself uses yield return to produce an async stream for callers. Ten wzorzec (przy użyciu yield return) jest zalecanym modelem do tworzenia strumieni asynchronicznych.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;
    }
}

Poza możliwością await foreachmożna także tworzyć Iteratory asynchroniczne, na przykład iterator, który zwraca IAsyncEnumerable/IAsyncEnumerator, które można await i yield w.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. W przypadku obiektów, które muszą zostać usunięte, można użyć IAsyncDisposable, które mają różne implementacje typów BCL, takie jak Stream i Timer.For objects that need to be disposed, you can use IAsyncDisposable, which various BCL types implement, such as Stream and Timer.

Aby uzyskać więcej informacji, zobacz Samouczek dotyczący strumieni asynchronicznych.For more information, see the async streams tutorial.

Liczba zmiennoprzecinkowa IEEEIEEE Floating-point

Interfejsy API zmiennoprzecinkowe są aktualizowane w celu zapewnienia zgodności z poprawką IEEE 754-2008.Floating point APIs are being updated to comply with IEEE 754-2008 revision. Celem tych zmian jest uwidocznienie wszystkich wymaganych operacji i upewnienie się, że są one zgodne z specyfikacją IEEE. Aby uzyskać więcej informacji na temat ulepszeń zmiennoprzecinkowych, zobacz udoskonalenia analizy i formatowania zmiennoprzecinkowe w wpisie na blogu programu .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.

Poprawki dotyczące analizowania i formatowania obejmują:Parsing and formatting fixes include:

  • Poprawnie Analizuj i Zaokrąglij dane wejściowe o dowolnej długości.Correctly parse and round inputs of any length.
  • Prawidłowo Przeanalizuj i sformatuj ujemną wartość zero.Correctly parse and format negative zero.
  • Prawidłowo Przeanalizuj Infinity i NaN, wykonując kontrolę bez uwzględniania wielkości liter i zezwalając na opcjonalne, poprzednia +, jeśli ma to zastosowanie.Correctly parse Infinity and NaN by doing a case-insensitive check and allowing an optional preceding + where applicable.

Nowe System.Math interfejsy API obejmują:New System.Math APIs include:

  • BitIncrement(Double) i BitDecrement(Double)BitIncrement(Double) and BitDecrement(Double)
    Odnosi się do nextUp i nextDown operacji IEEE.Corresponds to the nextUp and nextDown IEEE operations. Zwracają one najmniejszą liczbę zmiennoprzecinkową, która porównuje większe lub mniejsze niż dane wejściowe (odpowiednio).They return the smallest floating-point number that compares greater or lesser than the input (respectively). Na przykład Math.BitIncrement(0.0) zwróci double.Epsilon.For example, Math.BitIncrement(0.0) would return double.Epsilon.

  • MaxMagnitude(Double, Double) i MinMagnitude(Double, Double)MaxMagnitude(Double, Double) and MinMagnitude(Double, Double)
    Odnosi się do maxNumMag i minNumMag operacji IEEE, zwracają wartość, która jest większa lub mniejsza o wielkości dwóch danych wejściowych (odpowiednio).Corresponds to the maxNumMag and minNumMag IEEE operations, they return the value that is greater or lesser in magnitude of the two inputs (respectively). Na przykład Math.MaxMagnitude(2.0, -3.0) zwróci -3.0.For example, Math.MaxMagnitude(2.0, -3.0) would return -3.0.

  • ILogB(Double)
    Odnosi się do logB operacji IEEE, która zwraca wartość całkowitą, zwracająca podstawowy dziennik Base-2 parametru wejściowego.Corresponds to the logB IEEE operation that returns an integral value, it returns the integral base-2 log of the input parameter. Ta metoda jest efektywnie taka sama jak floor(log2(x)), ale została wykonana z minimalnym błędem zaokrąglania.This method is effectively the same as floor(log2(x)), but done with minimal rounding error.

  • ScaleB(Double, Int32)
    Odnosi się do scaleB operacji IEEE, która przyjmuje wartość całkowitą, która zwraca efektywnie x * pow(2, n), ale jest wykonywana z minimalnym błędem zaokrąglania.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)
    Odnosi się do log2 operacji IEEE, która zwraca logarytm o podstawie 2.Corresponds to the log2 IEEE operation, it returns the base-2 logarithm. Minimalizuje błąd zaokrąglania.It minimizes rounding error.

  • FusedMultiplyAdd(Double, Double, Double)
    Odnosi się do fma operacji IEEE, dlatego wykonuje odrzucane, wielokrotne Dodawanie.Corresponds to the fma IEEE operation, it performs a fused multiply add. Oznacza to, że (x * y) + z w ramach jednej operacji, co minimalizuje błąd zaokrąglania.That is, it does (x * y) + z as a single operation, thereby minimizing the rounding error. Przykładem może być FusedMultiplyAdd(1e308, 2.0, -1e308), które zwraca 1e308.An example would be FusedMultiplyAdd(1e308, 2.0, -1e308) which returns 1e308. Regularne (1e308 * 2.0) - 1e308 zwraca double.PositiveInfinity.The regular (1e308 * 2.0) - 1e308 returns double.PositiveInfinity.

  • CopySign(Double, Double)
    Odnosi się do copySign operacji IEEE, która zwraca wartość x, ale ze znakiem y.Corresponds to the copySign IEEE operation, it returns the value of x, but with the sign of y.

Elementy wewnętrzne zależne od platformy .NET.NET Platform-Dependent Intrinsics

Dodano interfejsy API, które umożliwiają dostęp do pewnych instrukcji procesora CPU zorientowanych na wydajność, takich jak SIMD lub bitowe zestawy instrukcji manipulowania .APIs have been added that allow access to certain perf-oriented CPU instructions, such as the SIMD or Bit Manipulation instruction sets. Te instrukcje mogą pomóc w osiągnięciu znaczących ulepszeń wydajności w niektórych scenariuszach, takich jak wydajne przetwarzanie danych.These instructions can help achieve significant performance improvements in certain scenarios, such as processing data efficiently in parallel.

W odpowiednich przypadkach biblioteki .NET zaczęły korzystać z tych instrukcji w celu zwiększenia wydajności.Where appropriate, the .NET libraries have begun using these instructions to improve performance.

Aby uzyskać więcej informacji, zobacz elementy wewnętrzne zależne od platformy .NET.For more information, see .NET Platform Dependent Intrinsics.

Ulepszone interfejsy API wersji platformy .NET CoreImproved .NET Core Version APIs

Począwszy od platformy .NET Core 3.0, interfejsy API wersji dostarczone z platformą .NET Core teraz zwracają oczekiwane informacje.Starting with .NET Core 3.0, the version APIs provided with .NET Core now return the information you expect. Na przykład: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

Ostrzeżenie

Istotna zmiana.Breaking change. Jest to technicznie istotna zmiana, ponieważ schemat przechowywania wersji został zmieniony.This is technically a breaking change because the versioning scheme has changed.

Szybka Wbudowana obsługa JSONFast built-in JSON support

Użytkownicy platformy .NET w dużym stopniu opierają się na Newtonsoft. JSON i innych popularnych bibliotekach JSON, które nadal są dobrym wybórem..NET users have largely relied on Newtonsoft.Json and other popular JSON libraries, which continue to be good choices. Newtonsoft.Json używa ciągów .NET jako podstawowego elementu DataType, który jest UTF-16 pod okapem.Newtonsoft.Json uses .NET strings as its base datatype, which is UTF-16 under the hood.

Nowa Wbudowana obsługa JSON to wysoka wydajność, niska alokacja i współpracuje z tekstem JSON zakodowanym w formacie UTF-8.The new built-in JSON support is high-performance, low allocation, and works with UTF-8 encoded JSON text. Więcej informacji o przestrzeni nazw i typach System.Text.Json można znaleźć w następujących artykułach:For more information about the System.Text.Json namespace and types, see the following articles:

Obsługa protokołu HTTP/2HTTP/2 support

Typ System.Net.Http.HttpClient obsługuje protokół HTTP/2.The System.Net.Http.HttpClient type supports the HTTP/2 protocol. Jeśli protokół HTTP/2 jest włączony, wersja protokołu HTTP jest negocjowana za pośrednictwem protokołu TLS/CLIENTHELLO ALPN, a protokół HTTP/2 jest używany, jeśli serwer zdecyduje się go użyć.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.

Domyślnym protokołem jest protokół HTTP/1.1, ale protokół HTTP/2 można włączyć na dwa różne sposoby.The default protocol remains HTTP/1.1, but HTTP/2 can be enabled in two different ways. Najpierw można ustawić komunikat żądania HTTP na potrzeby używania protokołu HTTP/2:First, you can set the HTTP request message to use HTTP/2:

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

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

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

Następnie można zmienić HttpClient, aby domyślnie używać protokołu HTTP/2: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);

W wielu przypadkach podczas tworzenia aplikacji chcesz użyć nieszyfrowanego połączenia.Many times when you're developing an application, you want to use an unencrypted connection. Jeśli wiesz, że docelowy punkt końcowy będzie używać protokołu HTTP/2, możesz włączyć nieszyfrowane połączenia dla protokołu HTTP/2.If you know the target endpoint will be using HTTP/2, you can turn on unencrypted connections for HTTP/2. Można ją włączyć, ustawiając zmienną środowiskową DOTNET_SYSTEM_NET_HTTP_SOCKETSHTTPHANDLER_HTTP2UNENCRYPTEDSUPPORT na 1 lub włączając ją w kontekście aplikacji: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);

Następne krokiNext steps