Новые возможности .NET Core 3.0What's new in .NET Core 3.0

В этой статье описываются новые возможности в .NET Core 3.0.This article describes what is new in .NET Core 3.0. Одно из основных усовершенствований — это поддержка классических приложений Windows (только Windows).One of the biggest enhancements is support for Windows desktop applications (Windows only). С помощью пакета SDK для .NET Core 3.0 под названием Windows Desktop можно переносить приложения Windows Forms и 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. Следует уточнить, что компонент Windows Desktop поддерживается и включен только в Windows.To be clear, the Windows Desktop component is only supported and included on Windows. Дополнительные сведения см. далее в этой статье, в разделе Рабочий стол Windows.For more information, see the Windows desktop section later in this article.

В .NET Core 3.0 добавлена поддержка C# 8.0..NET Core 3.0 adds support for C# 8.0. Настоятельно рекомендуется использовать Visual Studio 2019 версии 16.3 или более поздней, Visual Studio для Mac 8.3 или более поздней или Visual Studio Code с последним расширением C# .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.

Скачайте .NET Core 3.0 и начните работу прямо сейчас в Windows, macOS или Linux.Download and get started with .NET Core 3.0 right now on Windows, macOS, or Linux.

Дополнительные сведения см. в объявлении о выпуске .NET Core 3.0.For more information about the release, see the .NET Core 3.0 announcement.

Релиз-кандидат 1 .NET Core считался корпорацией Майкрософт готовым к эксплуатации и полностью поддерживался..NET Core RC1 was considered production ready by Microsoft and was fully supported. Если вы используете предварительную версию, необходимо перейти на версию RTM, чтобы продолжать получать поддержку.If you're using a preview release, you must move to the RTM version for continued support.

Улучшения C# 8.0Language improvements C# 8.0

В этот выпуск также входит версия C# 8.0, в которой появились ссылочные типы, допускающие значение NULL, асинхронные потоки и другие возможности.C# 8.0 is also part of this release, which includes the nullable reference types feature, async streams, and more patterns. Дополнительные сведения о функциях C# 8.0 см. в разделе Новые возможности C# 8.0.For more information about C# 8.0 features, see What's new in C# 8.0.

Добавлены улучшения языка для поддержки следующих функций API:Language enhancements were added to support the following API features detailed below:

.NET Standard 2.1.NET Standard 2.1

.NET Core 3.0 реализует .NET Standard 2.1..NET Core 3.0 implements .NET Standard 2.1. При этом шаблон dotnet new classlib по умолчанию создает проект, который по-прежнему предназначен для .NET Standard 2.0.However, the default dotnet new classlib template generates a project that still targets .NET Standard 2.0. Чтобы создать проект для .NET Standard 2.1, откройте файл проекта и измените значение свойства TargetFramework на 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>

Если вы используете Visual Studio, у вас должна быть версия Visual Studio 2019, так как Visual Studio 2017 не поддерживает .NET Standard 2.1 или .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.

Компиляция и развертываниеCompile/Deploy

Исполняемые файлы по умолчаниюDefault executables

.NET Core теперь по умолчанию собирает исполняемые файлы, зависимые от платформы..NET Core now builds framework-dependent executables by default. Такое поведение ново для приложений, которые используют глобально установленную версию .NET Core.This behavior is new for applications that use a globally installed version of .NET Core. Раньше исполняемые файлы создавались только в автономных развертываниях.Previously, only self-contained deployments would produce an executable.

Во время выполнения команды dotnet build или dotnet publish создается исполняемый файл (называемый appHost), который соответствует среде и платформе используемого пакета SDK.During dotnet build or dotnet publish, an executable (known as the appHost) is created that matches the environment and platform of the SDK you're using. Предполагается, что с этими исполняемыми файлами можно выполнять те же действия, что и с другими исполняемыми файлами в машинном коде, например:You can expect the same things with these executables as you would other native executables, such as:

  • исполняемый файл можно дважды щелкнуть;You can double-click on the executable.
  • приложение можно запустить из командной строки напрямую, например myapp.exe в Windows и ./myapp в Linux и macOS.You can launch the application from a command prompt directly, such as myapp.exe on Windows, and ./myapp on Linux and macOS.

Файл appHost в macOS и заверениеmacOS appHost and notarization

Только macOSmacOS only

Начиная с заверенного пакета SDK для .NET Core 3.0 для macOS параметр, отвечающий за создание исполняемого файла по умолчанию (называемого appHost), отключен по умолчанию.Starting with the notarized .NET Core SDK 3.0 for macOS, the setting to produce a default executable (known as the appHost) is disabled by default. Дополнительные сведения см. в статье Заверение macOS Catalina и влияние на скачиваемые файлы и проекты .NET Core.For more information, see macOS Catalina Notarization and the impact on .NET Core downloads and projects.

Если параметр appHost включен, .NET Core создает собственный исполняемый файл Mach-O, когда вы выполняете сборку или публикацию.When the appHost setting is enabled, .NET Core generates a native Mach-O executable when you build or publish. Приложение выполняется в контексте appHost при запуске из исходного кода с помощью команды dotnet run или путем непосредственного запуска исполняемого файла Mach-O.Your app runs in the context of the appHost when it is run from source code with the dotnet run command, or by starting the Mach-O executable directly.

Без appHost пользователь может запустить приложение, зависящее от платформы, только одним способом — с помощью команды dotnet <filename.dll>.Without the appHost, the only way a user can start a framework-dependent app is with the dotnet <filename.dll> command. AppHost всегда создается при публикации приложения в автономном виде.An appHost is always created when you publish your app self-contained.

Можно либо настроить appHost на уровне проекта, либо переключить использование appHost для определенной команды dotnet с помощью параметра -p:UseAppHost:You can either configure the appHost at the project level, or toggle the appHost for a specific dotnet command with the -p:UseAppHost parameter:

  • Файл проектаProject file

    <PropertyGroup>
      <UseAppHost>true</UseAppHost>
    </PropertyGroup>
    
  • Параметр командной строкиCommand-line parameter

    dotnet run -p:UseAppHost=true
    

Дополнительные сведения о параметре UseAppHost см. в разделе Свойства MSBuild для Microsoft.NET.Sdk.For more information about the UseAppHost setting, see MSBuild properties for Microsoft.NET.Sdk.

Однофайловые исполняемые файлыSingle-file executables

Команда dotnet publish поддерживает упаковку приложения в однофайловый исполняемый файл для конкретной платформы.The dotnet publish command supports packaging your app into a platform-specific single-file executable. Исполняемый файл является самоизвлекаемым и содержит все зависимости (включая машинные), необходимые для запуска приложения.The executable is self-extracting and contains all dependencies (including native) that are required to run your app. При первом запуске приложение извлекается в каталог, который зависит от имени и идентификатора сборки приложения.When the app is first run, the application is extracted to a directory based on the app name and build identifier. Впоследствии запуск происходит быстрее.Startup is faster when the application is run again. Если версия не изменилась, приложению не нужно извлекать себя заново.The application doesn't need to extract itself a second time unless a new version was used.

Чтобы опубликовать однофайловый исполняемый файл, задайте PublishSingleFile в своем проекте или в командной строке с помощью команды 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>

-или--or-

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

Дополнительные сведения о публикации однофайловых исполняемых файлов см. в документе о разработке однофайловых пакетных установщиков.For more information about single-file publishing, see the single-file bundler design document.

Связывание сборокAssembly linking

Пакет SDK для .NET Core 3.0 содержит инструмент, который позволяет уменьшить размер приложения, анализируя промежуточный язык и устраняя неиспользуемые сборки.The .NET core 3.0 SDK comes with a tool that can reduce the size of apps by analyzing IL and trimming unused assemblies.

Автономные приложения включают все необходимое для выполнения кода. Это позволяет не устанавливать .NET на соответствующем компьютере.Self-contained apps include everything needed to run your code, without requiring .NET to be installed on the host computer. Но во многих случаях для работы приложения достаточно небольшого набора функций платформы, а все неиспользуемые библиотеки можно удалить.However, many times the app only requires a small subset of the framework to function, and other unused libraries could be removed.

Теперь .NET Core предоставляет параметр, который позволяет использовать компоновщик IL для сканирования кода приложения на промежуточном языке..NET Core now includes a setting that will use the IL linker tool to scan the IL of your app. Это средство отслеживает необходимый код, а затем удаляет все неиспользуемые библиотеки.This tool detects what code is required, and then trims unused libraries. Это позволяет значительно снизить размер развертывания для некоторых приложений.This tool can significantly reduce the deployment size of some apps.

Чтобы включить этот инструмент, укажите в проекте параметр <PublishTrimmed> и опубликуйте автономное приложение: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

Например, простейший шаблон консольного приложения hello world, который входит в стандартную поставку, при публикации достигает размера около 70 МБ.As an example, the basic "hello world" new console project template that is included, when published, hits about 70 MB in size. С помощью <PublishTrimmed> этот размер можно снизить до 30 МБ.By using <PublishTrimmed>, that size is reduced to about 30 MB.

Важно учитывать, что приложения и платформы (в том числе ASP.NET Core и WPF), которые используют отражение или связанные динамические функции, могут стать неработоспособными после обрезки.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. Такие нарушения возникают потому, что компоновщик ничего не знает о динамическом поведении и не может определить, какие типы платформы потребуются для отражения.This breakage occurs because the linker doesn't know about this dynamic behavior and can't determine which framework types are required for reflection. Но вы можете настроить компоновщик IL так, чтобы он учитывал этот сценарий.The IL Linker tool can be configured to be aware of this scenario.

В любом случае обязательно протестируйте приложение после обрезки.Above all else, be sure to test your app after trimming.

Дополнительные сведения о компоновщике IL вы найдете в этой документации или на страницах репозитория mono/linker.For more information about the IL Linker tool, see the documentation or visit the mono/linker repo.

Многоуровневая компиляцияTiered compilation

Многоуровневая компиляция (МК) по умолчанию входит только в .NET Core 3.0.Tiered compilation (TC) is on by default with .NET Core 3.0. Эта функция позволяет среде выполнения более адаптивно использовать компилятор JIT для повышения производительности.This feature enables the runtime to more adaptively use the just-in-time (JIT) compiler to achieve better performance.

Основное преимущество многоуровневой компиляции состоит в том, что она обеспечивает два типа методов JIT: более качественные, но при этом более медленные, или менее качественные, но более быстрые.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. Качество определяет то, насколько хорошо оптимизирован метод.The quality refers to how well the method is optimized. Многоуровневая компиляция позволяет повысить производительность приложения на разных этапах его выполнения: с первого запуска и до достижения стабильной работы.TC helps to improve the performance of an application as it goes through various stages of execution, from startup through steady state. Если же многоуровневая компиляция отключена, каждый метод компилируется одним и тем же способом с упором на стабильную работу, а не скорость запуска.When tiered compilation is disabled, every method is compiled in a single way that's biased to steady-state performance over startup performance.

Когда многоуровневая компиляция включена, при запуске приложения компиляция методов происходит описанным ниже образом.When TC is enabled, the following behavior applies for method compilation when an app starts up:

  • Если метод имеет скомпилированный в режиме Ahead Of Time код (ReadyToRun), используется предварительно сформированный код.If the method has ahead-of-time-compiled code, or ReadyToRun, the pregenerated code is used.
  • В противном случае производится JIT-компиляция.Otherwise, the method is jitted. Как правило, эти методы являются универсальными для типов значений.Typically, these methods are generics over value types.
    • Быстрая JIT-компиляция позволяет быстрее создавать код с более низким качеством (менее оптимизированный).Quick JIT produces lower-quality (or less optimized) code more quickly. В .NET Core 3.0 быстрая JIT-компиляция по умолчанию включена для методов, которые не содержат циклов, и является предпочтительной при запуске.In .NET Core 3.0, Quick JIT is enabled by default for methods that don't contain loops and is preferred during startup.
    • JIT-компиляция с полной оптимизацией позволяет создать высококачественный (более оптимизированный) код. Но на это уходит больше времени.The fully optimizing JIT produces higher-quality (or more optimized) code more slowly. Для методов, где не применяется быстрая JIT-компиляция (например, если метод имеет атрибут MethodImplOptions.AggressiveOptimization), используется 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.

Для часто вызываемых методов JIT-компилятор в конечном итоге создает полностью оптимизированный код в фоновом режиме.For frequently called methods, the just-in-time compiler eventually creates fully optimized code in the background. После этого оптимизированный код заменяет предварительно скомпилированный код для данного метода.The optimized code then replaces the pre-compiled code for that method.

Код, созданный быстрой JIT-компиляцией, может выполняться медленнее, выделять больше памяти или использовать больше пространства стека.Code generated by Quick JIT may run slower, allocate more memory, or use more stack space. При возникновении проблем быструю JIT-компиляцию можно отключить с помощью следующего свойства MSBuild в файле проекта.If there are issues, you can disabled Quick JIT using this MSBuild property in the project file:

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

Чтобы полностью отключить многоуровневую компиляцию, добавьте в файл проекта следующее свойство MSBuild.To disable TC completely, use this MSBuild property in your project file:

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

Совет

При внесении изменений в эти параметры в файле проекта может потребоваться выполнить чистую сборку, чтобы они вступили в силу (удалите каталоги obj и bin и перестройте проект).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).

Дополнительные сведения о настройке компиляции во время выполнения см. в статье Параметры конфигурации времени выполнения для компиляции.For more information about configuring compilation at run time, see Run-time configuration options for compilation.

Образы ReadyToRunReadyToRun images

Вы можете снизить время запуска приложения .NET Core, скомпилировав все сборки приложения в формат ReadyToRun (R2R).You can improve the startup time of your .NET Core application by compiling your application assemblies as ReadyToRun (R2R) format. R2R является разновидностью компиляции AOT.R2R is a form of ahead-of-time (AOT) compilation.

Бинарные файлы R2R повышают производительность при запуске, снижая объем работы, выполняемой на этом этапе компилятором JIT.R2R binaries improve startup performance by reducing the amount of work the just-in-time (JIT) compiler needs to do as your application loads. Бинарные файлы содержат такой же машинный код, который создается компилятором JIT.The binaries contain similar native code compared to what the JIT would produce. Но бинарные файлы R2R имеют больший размер, так как содержат не только код на промежуточном языке (IL), который по-прежнему необходим для некоторых сценариев, но и версию того же кода на машинном языке.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 доступна только при публикации автономного приложения, предназначенного для конкретной среды выполнения (RID), например для Windows x64 или Linux 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.

Чтобы скомпилировать проект как ReadyToRun, выполните следующие действия:To compile your project as ReadyToRun, do the following:

  1. Добавьте в проект параметр <PublishReadyToRun>:Add the <PublishReadyToRun> setting to your project:

    <PropertyGroup>
      <PublishReadyToRun>true</PublishReadyToRun>
    </PropertyGroup>
    
  2. Опубликуйте автономное приложение.Publish a self-contained app. Например, такая команда создает автономное приложение для 64-разрядной версии 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
    

Ограничения при работе с несколькими платформами и архитектурамиCross platform/architecture restrictions

Компилятор ReadyToRun пока не поддерживает перекрестное нацеливание.The ReadyToRun compiler doesn't currently support cross-targeting. Компиляцию необходимо выполнять в конкретной целевой среде.You must compile on a given target. Например, если вам нужен образ R2R для 64-разрядной ОС Windows, команду публикации следует выполнять именно в этой среде.For example, if you want R2R images for Windows x64, you need to run the publish command on that environment.

Исключения для кроссплатформенного таргетирования:Exceptions to cross-targeting:

  • можно использовать Windows x64 для компиляции образов Windows ARM32, ARM64 и x86;Windows x64 can be used to compile Windows ARM32, ARM64, and x86 images.
  • можно использовать Windows x86 для компиляции образов Windows ARM32;Windows x86 can be used to compile Windows ARM32 images.
  • можно использовать Linux x64 для компиляции образов Linux ARM32 и ARM64.Linux x64 can be used to compile Linux ARM32 and ARM64 images.

Среда выполнения и пакет SDKRuntime/SDK

Накат основной версии среды выполненияMajor-version runtime roll forward

В .NET Core 3.0 появилась функция согласия, которая позволяет приложению выполнять накат до последней основной версии .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. Кроме того, добавлен новый параметр для управления тем, как накат применяется к приложению.Additionally, a new setting has been added to control how roll forward is applied to your app. Его можно настроить одним из следующих способов:This can be configured in the following ways:

  • Свойство файла проекта: RollForwardProject file property: RollForward
  • Свойство файла конфигурации среды выполнения: rollForwardRun-time configuration file property: rollForward
  • Переменная среды: DOTNET_ROLL_FORWARDEnvironment variable: DOTNET_ROLL_FORWARD
  • Аргумент командной строки: --roll-forwardCommand-line argument: --roll-forward

Необходимо указать одно из следующих значений.One of the following values must be specified. Если параметр не указан, ему по умолчанию присваивается значение Minor.If the setting is omitted, Minor is the default.

  • LatestPatchLatestPatch
    Накат до версии с наибольшим номером исправления.Roll forward to the highest patch version. Отключает накат дополнительных версий.This disables minor version roll forward.
  • MinorMinor
    Накат до дополнительной версии со следующим по порядку возрастания номером, если запрошенная дополнительная версия отсутствует.Roll forward to the lowest higher minor version, if requested minor version is missing. Если запрошенная дополнительная версия присутствует, используется политика LatestPatch.If the requested minor version is present, then the LatestPatch policy is used.
  • MajorMajor
    Накат до основной версии со следующим по порядку возрастания или дополнительной версии с наименьшим номером, если запрошенная дополнительная версия отсутствует.Roll forward to lowest higher major version, and lowest minor version, if requested major version is missing. Если запрошенная основная версия присутствует, используется политика Minor.If the requested major version is present, then the Minor policy is used.
  • LatestMinorLatestMinor
    Накат до дополнительной версии с наибольшим номером, даже если запрошенная дополнительная версия присутствует.Roll forward to highest minor version, even if requested minor version is present. Предназначен для сценариев размещения компонентов.Intended for component hosting scenarios.
  • LatestMajorLatestMajor
    Накат до основной версии с наибольшим номером и дополнительной версии с наибольшим номером, даже если запрошенная основная версия присутствует.Roll forward to highest major and highest minor version, even if requested major is present. Предназначен для сценариев размещения компонентов.Intended for component hosting scenarios.
  • DisableDisable
    Накат не выполняется.Don't roll forward. Привязка только к указанной версии.Only bind to specified version. Эта политика не рекомендуется для общего использования, поскольку отключает возможность наката до последних исправлений.This policy isn't recommended for general use because it disables the ability to roll forward to the latest patches. Это значение рекомендуется использовать только для тестирования.This value is only recommended for testing.

Все параметры, кроме параметра Disable, будут использовать версию с последним доступным исправлением.Besides the Disable setting, all settings will use the highest available patch version.

Если запрашиваемая версия (как указано в .runtimeconfig.json для приложения) является версией выпуска, по умолчанию для наката предназначаются только такие версии.By default, if the requested version (as specified in .runtimeconfig.json for the application) is a release version, only release versions are considered for roll forward. Все предварительные версии игнорируются.Any pre-release versions are ignored. Если соответствующая версия выпуска отсутствует, учитываются предварительные версии.If there is no matching release version, then pre-release versions are taken into account. Это поведение можно изменить, установив значение DOTNET_ROLL_FORWARD_TO_PRERELEASE=1. В этом случае будут учитываться все версии.This behavior can be changed by setting DOTNET_ROLL_FORWARD_TO_PRERELEASE=1, in which case all versions are always considered.

Сборка копирует зависимостиBuild copies dependencies

Команда dotnet build копирует зависимости NuGet для вашего приложения из кэша NuGet в выходную папку сборки.The dotnet build command now copies NuGet dependencies for your application from the NuGet cache to the build output folder. Ранее зависимости копировались только в рамках выполнения команды dotnet publish.Previously, dependencies were only copied as part of dotnet publish.

Для некоторых операций, таких как связывание и публикация страницы Razor, по-прежнему будет требоваться публикация.There are some operations, like linking and razor page publishing that will still require publishing.

Локальные средстваLocal tools

В .NET Core 3.0 появились локальные средства..NET Core 3.0 introduces local tools. Локальные средства похожи на глобальные средства, но связаны с определенным расположением на диске.Local tools are similar to global tools but are associated with a particular location on disk. Локальные средства недоступны глобально и распространяются в виде пакетов NuGet.Local tools aren't available globally and are distributed as NuGet packages.

Предупреждение

Если вы пробовали использовать локальные средства в предварительной версии 1 .NET Core 3.0, например запуск dotnet tool restore или dotnet tool install, удалите папку кэша локальных средств.If you tried local tools in .NET Core 3.0 Preview 1, such as running dotnet tool restore or dotnet tool install, delete the local tools cache folder. В противном случае локальные средства не будут работать ни в одной более новой версии.Otherwise, local tools won't work on any newer release. Эта папка находится по адресу:This folder is located at:

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

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

Локальные средства используют имя файла манифеста dotnet-tools.json в текущем каталоге.Local tools rely on a manifest file name dotnet-tools.json in your current directory. Этот файл манифеста определяет, какие средства доступны в этой папке и далее.This manifest file defines the tools to be available at that folder and below. Файл манифеста можно распространять вместе с кодом, чтобы те же средства мог восстановить и использовать любой, кто работает с вашим кодом.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.

Для глобальных и локальных средств требуется совместимая версия среды выполнения.For both global and local tools, a compatible version of the runtime is required. Сейчас на сайте NuGet.org многие средства предназначены для среды выполнения .NET Core 2.1.Many tools currently on NuGet.org target .NET Core Runtime 2.1. Чтобы установить эти средства глобально или локально, нужно, как и раньше, установить среду выполнения NET Core 2.1.To install these tools globally or locally, you would still need to install the NET Core 2.1 Runtime.

Новые параметры global.jsonNew global.json options

Файл Global. JSON содержит новые параметры, которые позволяют более гибко определять требуемую версию пакета SDK для .NET Core.The global.json file has new options that provide more flexibility when you're trying to define which version of the .NET Core SDK is used. Эти новые параметры перечислены ниже.The new options are:

  • allowPrerelease. Указывает, должен ли сопоставитель пакетов SDK учитывать предварительные версии при выборе версии пакета SDK, которую следует использовать.allowPrerelease: Indicates whether the SDK resolver should consider prerelease versions when selecting the SDK version to use.
  • rollForward. Обозначает политику наката, которая используется при выборе версии пакета SDK (либо в качестве резервной, если определенная версия пакета SDK отсутствует, либо в качестве директивы для использования более поздней версии).rollForward: Indicates the roll-forward policy to use when selecting an SDK version, either as a fallback when a specific SDK version is missing or as a directive to use a higher version.

Дополнительные сведения об изменениях, в том числе значения по умолчанию, поддерживаемые значения и новые правила сопоставления, см. в разделе общих сведений о global.json.For more information about the changes including default values, supported values, and new matching rules, see global.json overview.

Уменьшенные размеры куч сборки мусораSmaller Garbage Collection heap sizes

Размер кучи сборщика мусора по умолчанию был уменьшен, так что теперь .NET Core использует меньше памяти.The Garbage Collector's default heap size has been reduced resulting in .NET Core using less memory. Это изменение лучше соответствует выделению бюджета нулевого поколения и размерам кэша современных процессоров.This change better aligns with the generation 0 allocation budget with modern processor cache sizes.

Поддержка больших страниц сборки мусораGarbage Collection Large Page support

Большие страницы (также известные как огромные страницы в Linux) — это функция, благодаря которой операционная система может задавать области памяти больше, чем размер нативной страницы (часто 4K), чтобы повысить производительность приложения, запрашивающего такие страницы.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.

Сборщик мусора теперь можно настраивать с помощью параметра GCLargePages как дополнительной функции, позволяющей выделять большие страницы в 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 и модель COMWindows Desktop & COM

Установщик пакета SDK Windows для .NET Core.NET Core SDK Windows Installer

Начиная с .NET Core 3.0, установщик MSI для Windows был изменен.The MSI installer for Windows has changed starting with .NET Core 3.0. Установщики пакетов SDK теперь обновляют дополнительные пакеты функций SDK на месте.The SDK installers will now upgrade SDK feature-band releases in place. Пакеты функций определяют сотни в обозначении исправления в номере версии.Feature bands are defined in the hundreds groups in the patch section of the version number. Например, в версиях 3.0.101 и 3.0.201 пакеты функций различаются, а в версиях 3.0.101 и 3.0.199  — одинаковы.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. При установке пакета SDK для .NET Core 3.0.101 пакет SDK для .NET Core 3.0.100, если он есть на компьютере, удаляется.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. Когда на тот же компьютер устанавливается пакет SDK для .NET Core 3.0.200, пакет SDK для .NET Core 3.0.101 удаляться не будет.When .NET Core SDK 3.0.200 is installed on the same machine, .NET Core SDK 3.0.101 won't be removed.

Дополнительные сведения об управлении версиями см. в разделе Общие сведения об управлении версиями в .NET Core.For more information about versioning, see Overview of how .NET Core is versioned.

Классические приложения WindowsWindows desktop

.NET Core 3.0 поддерживает классические приложения Windows с помощью Windows Presentation Foundation (WPF) и Windows Forms..NET Core 3.0 supports Windows desktop applications using Windows Presentation Foundation (WPF) and Windows Forms. Эти платформы также поддерживают использование современных элементов управления и стилей Fluent из библиотеки XAML пользовательского интерфейса Windows (WinUI) через острова XAML.These frameworks also support using modern controls and Fluent styling from the Windows UI XAML Library (WinUI) via XAML islands.

Компонент Windows Desktop является частью пакета SDK .NET Core 3.0 для Windows.The Windows Desktop component is part of the Windows .NET Core 3.0 SDK.

Вы можете создать приложение WPF или Windows Forms с помощью следующих команд dotnet:You can create a new WPF or Windows Forms app with the following dotnet commands:

dotnet new wpf
dotnet new winforms

Visual Studio 2019 добавляет шаблоны Новый проект для .NET Core 3.0 Windows Forms и WPF.Visual Studio 2019 adds New Project templates for .NET Core 3.0 Windows Forms and WPF.

Дополнительные сведения о переносе существующего приложения .NET Framework см. в разделах Перенос проектов WPF и Перенос проектов Windows Forms.For more information about how to port an existing .NET Framework application, see Port WPF projects and Port Windows Forms projects.

Высокое разрешение для WinFormsWinForms high DPI

Приложения .NET Core Windows Forms могут устанавливать режим высокого разрешения экрана с помощью Application.SetHighDpiMode(HighDpiMode)..NET Core Windows Forms applications can set high DPI mode with Application.SetHighDpiMode(HighDpiMode). Метод SetHighDpiMode задает соответствующий режим высокого разрешения, если параметр не задан другими способами, например с помощью App.Manifest или P/Invoke перед 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.

Возможны следующие значения highDpiMode, выраженные перечислением System.Windows.Forms.HighDpiMode:The possible highDpiMode values, as expressed by the System.Windows.Forms.HighDpiMode enum are:

  • DpiUnaware
  • SystemAware
  • PerMonitor
  • PerMonitorV2
  • DpiUnawareGdiScaled

См. о разработке классических приложений с поддержкой высокого разрешения экрана в Windows.For more information about high DPI modes, see High DPI Desktop Application Development on Windows.

Создание компонентов COMCreate COM components

Теперь в Windows можно создавать управляемые компоненты, вызываемые COM.On Windows, you can now create COM-callable managed components. Эта возможность необходима для использования .NET Core с моделями надстроек COM и обеспечивает соответствие с платформой .NET Framework.This capability is critical to use .NET Core with COM add-in models and also to provide parity with .NET Framework.

В отличие от .NET Framework, где в качестве сервера использовалась библиотека mscoree.dll, .NET Core при сборке вашего COM-компонента добавляет в каталог bin dll собственного средства запуска.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.

Пример того, как создать и использовать компонент COM, см. в разделе Демонстрация COM.For an example of how to create a COM component and consume it, see the COM Demo.

Собственное взаимодействие WindowsWindows Native Interop

Windows предоставляет собственный API с широкими возможностями в виде API C, COM и WinRT.Windows offers a rich native API in the form of flat C APIs, COM, and WinRT. При том что .NET Core поддерживает P/Invoke, в .NET Core 3.0 добавлена возможность воссоздавать API COM и активировать API WinRT.While .NET Core supports P/Invoke, .NET Core 3.0 adds the ability to CoCreate COM APIs and Activate WinRT APIs. Пример кода см. в разделе Демонстрация Excel.For a code example, see the Excel Demo.

Развертывание MSIXMSIX Deployment

MSIX — это новый формат пакета приложения Windows.MSIX is a new Windows application package format. Его можно использовать для развертывания классических приложений .NET Core 3.0 для Windows 10.It can be used to deploy .NET Core 3.0 desktop applications to Windows 10.

Проект упаковки приложений Windows, доступный в Visual Studio 2019, позволяет создавать пакеты MSIX с автономными приложениями .NET Core.The Windows Application Packaging Project, available in Visual Studio 2019, allows you to create MSIX packages with self-contained .NET Core applications.

Файл проекта .NET Core должен указывать поддерживаемые среды выполнения в свойстве <RuntimeIdentifiers>:The .NET Core project file must specify the supported runtimes in the <RuntimeIdentifiers> property:

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

Усовершенствования LinuxLinux improvements

SerialPort для LinuxSerialPort for Linux

.NET Core 3.0 обеспечивает базовую поддержку System.IO.Ports.SerialPort в Linux..NET Core 3.0 provides basic support for System.IO.Ports.SerialPort on Linux.

Раньше среда .NET Core поддерживала SerialPort только в Windows.Previously, .NET Core only supported using SerialPort on Windows.

Дополнительные сведения об ограниченной поддержке последовательного порта в Linux см. в описании проблемы № 33146 на сайте GitHub.For more information about the limited support for the serial port on Linux, see GitHub issue #33146.

Ограничения памяти в Docker и cgroupDocker and cgroup memory Limits

Запуск .NET Core 3.0 на платформе Linux с помощью Docker лучше работает с ограничениями памяти в cgroup.Running .NET Core 3.0 on Linux with Docker works better with cgroup memory limits. Запуск контейнера Docker с ограничениями памяти, например с docker run -m, изменяет поведение .NET Core.Running a Docker container with memory limits, such as with docker run -m, changes how .NET Core behaves.

  • Размер кучи сборщика мусора (GC) по умолчанию составляет не более 20 МБ или 75 % от ограничения памяти для контейнера.Default Garbage Collector (GC) heap size: maximum of 20 mb or 75% of the memory limit on the container.
  • Конкретный размер можно указать абсолютным числом или в виде процента от ограничения cgroup.Explicit size can be set as an absolute number or percentage of cgroup limit.
  • Минимальный зарезервированный размер сегмента в куче GC составляет 16 МБ.Minimum reserved segment size per GC heap is 16 mb. При использовании такого размера количество создаваемых на компьютерах куч будет меньше.This size reduces the number of heaps that are created on machines.

Поддержка GPIO для Raspberry PiGPIO Support for Raspberry Pi

В NuGet выпущено два новых пакета, которые можно использовать для программирования GPIO:Two packages have been released to NuGet that you can use for GPIO programming:

Пакеты GPIO содержат API для устройств GPIO, SPI, I2C и PWM.The GPIO packages include APIs for GPIO, SPI, I2C, and PWM devices. Пакет привязок Интернета вещей содержит привязки устройств.The IoT bindings package includes device bindings. Дополнительные сведения см. в репозитории GitHub устройств.For more information, see the devices GitHub repo.

Поддержка ARM64 LinuxARM64 Linux support

В .NET Core 3.0 добавлена поддержка ARM64 для Linux..NET Core 3.0 adds support for ARM64 for Linux. Основной вариант использования для ARM64 в данный момент — это сценарии Интернета вещей.The primary use case for ARM64 is currently with IoT scenarios. Дополнительные сведения см. в статье Состояние .NET Core в ARM64.For more information, see .NET Core ARM64 Status.

Образы Docker для .NET Core в ARM64 доступны для Alpine, Debian и Ubuntu.Docker images for .NET Core on ARM64 are available for Alpine, Debian, and Ubuntu.

Примечание

Поддержка ARM64 в Windows еще недоступна.ARM64 Windows support isn't yet available.

БезопасностьSecurity

TLS 1.3 и OpenSSL 1.1.1 в LinuxTLS 1.3 & OpenSSL 1.1.1 on Linux

Теперь .NET Core использует преимущества поддержки TLS 1.3 в OpenSSL 1.1.1, когда она доступна в данной среде..NET Core now takes advantage of TLS 1.3 support in OpenSSL 1.1.1, when it's available in a given environment. В TLS 1.3:With TLS 1.3:

  • За счет уменьшения количества круговых путей между клиентом и сервером уменьшено время соединения.Connection times are improved with reduced round trips required between the client and server.
  • За счет удаления различных устаревших и небезопасных алгоритмов шифрования повышена безопасность.Improved security because of the removal of various obsolete and insecure cryptographic algorithms.

В системе Linux .NET Core 3.0 по возможности использует OpenSSL 1.1.1, OpenSSL 1.1.0 или OpenSSL 1.0.2.When available, .NET Core 3.0 uses OpenSSL 1.1.1, OpenSSL 1.1.0, or OpenSSL 1.0.2 on a Linux system. Если есть доступ к OpenSSL 1.1.1, оба типа, System.Net.Security.SslStream и System.Net.Http.HttpClient, используют TLS 1.3 (при условии что клиент и сервер поддерживают 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).

Важно!

Windows и macOS еще не поддерживают TLS 1.3.Windows and macOS do not yet support TLS 1.3. .NET Core 3.0 будет поддерживать TLS 1.3 в этих операционных системах, когда поддержка станет доступной..NET Core 3.0 will support TLS 1.3 on these operating systems when support becomes available.

В следующем примере C# 8.0 показано, как .NET Core 3.0 в Ubuntu 18.10 подключается к https://www.cloudflare.com:The following C# 8.0 example demonstrates .NET Core 3.0 on Ubuntu 18.10 connecting to https://www.cloudflare.com:

using System;
using System.Net.Security;
using System.Net.Sockets;
using System.Threading.Tasks;

namespace whats_new
{
    public static class TLS
    {
        public static async Task ConnectCloudFlare()
        {
            var targetHost = "www.cloudflare.com";

            using TcpClient tcpClient = new TcpClient();

            await tcpClient.ConnectAsync(targetHost, 443);

            using SslStream sslStream = new SslStream(tcpClient.GetStream());

            await sslStream.AuthenticateAsClientAsync(targetHost);
            await Console.Out.WriteLineAsync($"Connected to {targetHost} with {sslStream.SslProtocol}");
        }
    }
}

Шифры криптографииCryptography ciphers

В .NET 3.0 добавлена поддержка шифров AES-GCM и AES-CCM, реализованных с помощью System.Security.Cryptography.AesGcm и System.Security.Cryptography.AesCcm соответственно..NET 3.0 adds support for AES-GCM and AES-CCM ciphers, implemented with System.Security.Cryptography.AesGcm and System.Security.Cryptography.AesCcm respectively. Оба этих алгоритма представляют собой алгоритмы AEAD (аутентифицированного шифрования с присоединенными данными).These algorithms are both Authenticated Encryption with Association Data (AEAD) algorithms.

В следующем коде показано использование шифра AesGcm для шифрования и расшифровки случайных данных.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.");
        }
    }
}

Импорт и экспорт криптографических ключейCryptographic Key Import/Export

.NET Core 3.0 поддерживает импорт и экспорт асимметричных открытых и закрытых ключей из стандартных форматов..NET Core 3.0 supports the import and export of asymmetric public and private keys from standard formats. Сертификат X.509 использовать не нужно.You don't need to use an X.509 certificate.

Все типы ключей, включая RSA, DSA, ECDsa и ECDiffieHellman, поддерживают следующие форматы:All key types, such as RSA, DSA, ECDsa, and ECDiffieHellman, support the following formats:

  • Открытый ключPublic Key

    • X.509 SubjectPublicKeyInfoX.509 SubjectPublicKeyInfo
  • Закрытый ключPrivate key

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

Ключи RSA также поддерживают:RSA keys also support:

  • Открытый ключPublic Key

    • PKCS#1 RSAPublicKeyPKCS#1 RSAPublicKey
  • Закрытый ключPrivate key

    • PKCS#1 RSAPrivateKeyPKCS#1 RSAPrivateKey

Методы экспорта создают двоичные данные в кодировке DER, а методы импорта выполняют то же самое.The export methods produce DER-encoded binary data, and the import methods expect the same. Если ключ хранится в формате PEM в виде текста, вызывающему объекту потребуется выполнить декодирование содержимого в формате base64, прежде чем вызывать метод импорта.If a key is stored in the text-friendly PEM format, the caller will need to base64-decode the content before calling an import method.

using System;
using System.Security.Cryptography;

namespace whats_new
{
    public static class RSATest
    {
        public static void Run(string keyFile)
        {
            using var rsa = RSA.Create();

            byte[] keyBytes = System.IO.File.ReadAllBytes(keyFile);
            rsa.ImportRSAPrivateKey(keyBytes, out int bytesRead);

            Console.WriteLine($"Read {bytesRead} bytes, {keyBytes.Length - bytesRead} extra byte(s) in file.");
            RSAParameters rsaParameters = rsa.ExportParameters(true);
            Console.WriteLine(BitConverter.ToString(rsaParameters.D));
        }
    }
}

Файлы PKCS 8 можно проверять с помощью System.Security.Cryptography.Pkcs.Pkcs8PrivateKeyInfo, а файлы PFX/PKCS #12 — с помощью System.Security.Cryptography.Pkcs.Pkcs12Info.PKCS#8 files can be inspected with System.Security.Cryptography.Pkcs.Pkcs8PrivateKeyInfo and PFX/PKCS#12 files can be inspected with System.Security.Cryptography.Pkcs.Pkcs12Info. Для манипуляций с файлами PFX/PKCS #12 можно использовать System.Security.Cryptography.Pkcs.Pkcs12Builder.PFX/PKCS#12 files can be manipulated with System.Security.Cryptography.Pkcs.Pkcs12Builder.

Изменения API .NET Core 3.0.NET Core 3.0 API changes

Диапазоны и индексыRanges and indices

Новый тип System.Index можно использовать для индексирования.The new System.Index type can be used for indexing. Вы можете создать с помощью int индекс, который отсчитывается с начала, а с помощью оператора ^ префикса (C#) индекс, который отсчитывается с конца: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"

Кроме того, есть тип System.Range, который состоит из двух значений Index (одно для начала и одно для конца) и который можно написать с помощью выражения диапазона 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#). После этого можно выполнить индексацию с помощью команды Range, которая создает срез:You can then index with a Range, which produces a slice:

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

Дополнительные сведения см. в руководстве по диапазонам и индексам.For more information, see the ranges and indices tutorial.

Асинхронные потокиAsync streams

Тип IAsyncEnumerable<T> — это новая асинхронная версия IEnumerable<T>.The IAsyncEnumerable<T> type is a new asynchronous version of IEnumerable<T>. Язык позволяет выполнить действие await foreach с этими объектами IAsyncEnumerable<T>, чтобы использовать их элементы, и действие yield return по отношению к ним, чтобы создать элементы.The language lets you await foreach over IAsyncEnumerable<T> to consume their elements, and use yield return to them to produce elements.

В приведенном ниже примере демонстрируется создание и применение асинхронных потоков.The following example demonstrates both production and consumption of async streams. Инструкция foreach является асинхронной и использует yield return, чтобы создать асинхронные потоки для вызывающих объектов.The foreach statement is async and itself uses yield return to produce an async stream for callers. Этот шаблон (с использованием yield return) является рекомендуемой моделью для создания асинхронных потоков.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;
    }
}

Помимо возможности await foreach вы также можете создать асинхронные итераторы, например, итератор, который возвращает IAsyncEnumerable/IAsyncEnumerator, для которого можно применить await и yield.In addition to being able to await foreach, you can also create async iterators, for example, an iterator that returns an IAsyncEnumerable/IAsyncEnumerator that you can both await and yield in. Для объектов, которые необходимо удалить, можно использовать IAsyncDisposable, который реализовывают различные типы BCL, такие как Stream и Timer.For objects that need to be disposed, you can use IAsyncDisposable, which various BCL types implement, such as Stream and Timer.

Дополнительные сведения см. в руководстве по асинхронным потокам.For more information, see the async streams tutorial.

IEEE с плавающей запятойIEEE Floating-point

API плавающей запятой сейчас обновляются, чтобы соответствовать редакции IEEE 754-2008.Floating point APIs are being updated to comply with IEEE 754-2008 revision. Цель этих изменений — предоставлять все обязательные операции и гарантировать, что их поведение будет соответствовать спецификации IEEE. Дополнительные сведения об улучшениях, связанных с плавающей запятой, см. в записи блога Улучшения в синтаксическом анализе и форматировании плавающей запятой в .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.

Исправления синтаксического анализа и форматирования включают:Parsing and formatting fixes include:

  • Правильный анализ и округление входных данных любой длины.Correctly parse and round inputs of any length.
  • Правильный анализ и форматирование отрицательного нуля.Correctly parse and format negative zero.
  • Правильный анализ Infinity и NaN с помощью проверки без учета регистра и допущения необязательного + в начале, где это применимо.Correctly parse Infinity and NaN by doing a case-insensitive check and allowing an optional preceding + where applicable.

Новый API System.Math включают:New System.Math APIs include:

  • BitIncrement(Double) и BitDecrement(Double)BitIncrement(Double) and BitDecrement(Double)
    Соответствует операциям IEEE nextUp и nextDown.Corresponds to the nextUp and nextDown IEEE operations. Они возвращают наименьшее число с плавающей запятой, которое может быть больше или меньше входных данных (соответственно).They return the smallest floating-point number that compares greater or lesser than the input (respectively). Например, Math.BitIncrement(0.0) вернет double.Epsilon.For example, Math.BitIncrement(0.0) would return double.Epsilon.

  • MaxMagnitude(Double, Double) и MinMagnitude(Double, Double)MaxMagnitude(Double, Double) and MinMagnitude(Double, Double)
    Соответствуют операциям IEEE maxNumMag и minNumMag. Они возвращают значение, которое будет больше или меньше из двух величин (соответственно).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) вернет -3.0.For example, Math.MaxMagnitude(2.0, -3.0) would return -3.0.

  • ILogB(Double)
    Соответствует операции IEEE logB, которая возвращает целочисленное значение. Она возвращает целочисленный логарифм по основанию 2 входного параметра.Corresponds to the logB IEEE operation that returns an integral value, it returns the integral base-2 log of the input parameter. Этот метод действует практически так же, как floor(log2(x)), но с минимальными погрешностями округления.This method is effectively the same as floor(log2(x)), but done with minimal rounding error.

  • ScaleB(Double, Int32)
    Соответствует операции IEEE scaleB, которая принимает целочисленное значение. Возвращает x * pow(2, n), но выполняется с минимальными погрешностями округления.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)
    Соответствует операции IEEE log2. Возвращает логарифм по основанию 2.Corresponds to the log2 IEEE operation, it returns the base-2 logarithm. Сводит к минимуму погрешность округления.It minimizes rounding error.

  • FusedMultiplyAdd(Double, Double, Double)
    Соответствует операции IEEE fma. Выполняет умножение и сложение.Corresponds to the fma IEEE operation, it performs a fused multiply add. То есть он выполняет (x * y) + z как одну операцию, тем самым сводя к минимуму погрешность округления.That is, it does (x * y) + z as a single operation, thereby minimizing the rounding error. Например, FusedMultiplyAdd(1e308, 2.0, -1e308) возвращает 1e308.An example is FusedMultiplyAdd(1e308, 2.0, -1e308), which returns 1e308. Стандартный (1e308 * 2.0) - 1e308 возвращает double.PositiveInfinity.The regular (1e308 * 2.0) - 1e308 returns double.PositiveInfinity.

  • CopySign(Double, Double)
    Соответствует операции IEEE copySign. Возвращает значение x, но со знаком y.Corresponds to the copySign IEEE operation, it returns the value of x, but with the sign of y.

Встроенные объекты, зависимые от платформы .NET.NET Platform-Dependent Intrinsics

Были добавлены API-интерфейсы, которые разрешают доступ к определенным инструкциям ЦП, ориентированным на производительность, например SIMD или наборы инструкций побитовой обработки.APIs have been added that allow access to certain perf-oriented CPU instructions, such as the SIMD or Bit Manipulation instruction sets. Эти инструкции помогут значительно улучшить производительность в некоторых сценариях, таких как эффективная параллельная обработка данных.These instructions can help achieve significant performance improvements in certain scenarios, such as processing data efficiently in parallel.

Там, где это возможно, библиотеки .NET начали использовать эти инструкции для повышения производительности.Where appropriate, the .NET libraries have begun using these instructions to improve performance.

Дополнительные сведения см. в разделе Встроенные объекты, зависимые от платформы .NET.For more information, see .NET Platform-Dependent Intrinsics.

Улучшенные API версий .NET CoreImproved .NET Core Version APIs

Начиная с .NET Core 3.0, API версий, предоставляемые с .NET Core, возвращают те данные, которые должны.Starting with .NET Core 3.0, the version APIs provided with .NET Core now return the information you expect. Пример: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

Предупреждение

Критическое изменение.Breaking change. С технической точки зрения это изменение является критическим, поскольку изменилась схема управления версиями.This is technically a breaking change because the versioning scheme has changed.

Быстрая встроенная поддержка JSONFast built-in JSON support

Пользователи .NET в основном полагались на Newtonsoft.Json и другие популярные библиотеки JSON, которые по-прежнему остаются хорошими вариантами..NET users have largely relied on Newtonsoft.Json and other popular JSON libraries, which continue to be good choices. Newtonsoft.Json использует в качестве базового типа данных строки .NET, которые обладают внутренней структурой UTF-16.Newtonsoft.Json uses .NET strings as its base datatype, which is UTF-16 under the hood.

Новая встроенная поддержка JSON отличается высокой производительностью, малым распределением и поддержкой текста JSON в кодировке UTF-8.The new built-in JSON support is high-performance, low allocation, and works with UTF-8 encoded JSON text. Дополнительные сведения о пространстве имен и типах System.Text.Json см. в следующих статьях:For more information about the System.Text.Json namespace and types, see the following articles:

Поддержка HTTP/2HTTP/2 support

Тип System.Net.Http.HttpClient поддерживает протокол HTTP/2.The System.Net.Http.HttpClient type supports the HTTP/2 protocol. Если протокол HTTP/2 включен, версия протокола HTTP согласуется через TLS/ALPN, а HTTP/2 используется, только если его выбрал сервер.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.

Протоколом по умолчанию остается HTTP/1.1, но у вас есть два способа включить HTTP/2.The default protocol remains HTTP/1.1, but HTTP/2 can be enabled in two different ways. Во-первых, можно указать использование 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);

Во-вторых, можно изменить HttpClient для использования 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);

При разработке приложений часто требуется подключение без шифрования.Many times when you're developing an application, you want to use an unencrypted connection. Если вы знаете, что целевая конечная точка использует протокол HTTP/2, вы можете включить незашифрованные подключения для HTTP/2.If you know the target endpoint will be using HTTP/2, you can turn on unencrypted connections for HTTP/2. Для этого задайте переменной среды DOTNET_SYSTEM_NET_HTTP_SOCKETSHTTPHANDLER_HTTP2UNENCRYPTEDSUPPORT значение 1 или включите этот параметр в контексте приложения: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);

Следующие шагиNext steps