Novedades de .NET Core 3.0What's new in .NET Core 3.0

En este artículo se describen las novedades de .NET Core 3.0.This article describes what is new in .NET Core 3.0. Una de las mejoras más importantes es la compatibilidad con las aplicaciones de Escritorio de Windows (solo Windows).One of the biggest enhancements is support for Windows desktop applications (Windows only). Mediante el componente Escritorio de Windows del SDK de .NET Core 3.0, puede portar sus aplicaciones de Windows Forms y 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. Para ser más precisos, el componente Escritorio de Windows solo se admite e incluye en Windows.To be clear, the Windows Desktop component is only supported and included on Windows. Para obtener más información, vea la sección Escritorio de Windows más adelante en este artículo.For more information, see the Windows desktop section later in this article.

.NET Core 3.0 agrega compatibilidad con C# 8.0..NET Core 3.0 adds support for C# 8.0. Se recomienda encarecidamente usar Visual Studio 2019, versión 16.3 o una versión posterior, Visual Studio para Mac 8.3 o una versión posterior, o Visual Studio Code con la última extensión de 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.

Descargue .NET Core 3.0 y empiece a trabajar ya en Windows, macOS o Linux.Download and get started with .NET Core 3.0 right now on Windows, macOS, or Linux.

Para obtener más información acerca de la versión, consulte el anuncio de .NET Core 3.0.For more information about the release, see the .NET Core 3.0 announcement.

Microsoft considera .NET Core RC1 como listo para producción y es totalmente compatible..NET Core RC1 was considered production ready by Microsoft and was fully supported. Si usa una versión preliminar, debe pasar a la versión RTM para obtener soporte técnico continuo.If you're using a preview release, you must move to the RTM version for continued support.

Mejoras del lenguaje C# 8.0Language improvements C# 8.0

C# 8.0 también forma parte de esta versión, que incluye la característica de tipos de referencia que aceptan valores NULL, flujos asincrónicos y más patrones.C# 8.0 is also part of this release, which includes the nullable reference types feature, async streams, and more patterns. Para obtener más información sobre las características de C# 8.0, vea Novedades de C# 8.0.For more information about C# 8.0 features, see What's new in C# 8.0.

Se han agregado mejoras del lenguaje para admitir las siguientes características de API que se detallan a continuación:Language enhancements were added to support the following API features detailed below:

.NET Standard 2.1.NET Standard 2.1

.NET Core 3.0 implementa .NET Standard 2.1..NET Core 3.0 implements .NET Standard 2.1. Pero la plantilla predeterminada dotnet new classlib genera un proyecto que sigue destinado a .NET Standard 2.0.However, the default dotnet new classlib template generates a project that still targets .NET Standard 2.0. Para destinarlo a .NET Standard 2.1, edite el archivo de proyecto y cambie la propiedad TargetFramework a 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>

Si usa Visual Studio, necesita Visual Studio 2019, ya que Visual Studio 2017 no admite .NET Standard 2.1 ni .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.

Compilación e implementaciónCompile/Deploy

Archivos ejecutables predeterminadosDefault executables

.NET Core compila ahora archivos ejecutables dependientes del marco de forma predeterminada..NET Core now builds framework-dependent executables by default. Este comportamiento es nuevo en las aplicaciones que usan una versión de .NET Core instalada globalmente.This behavior is new for applications that use a globally installed version of .NET Core. Anteriormente, solo las implementaciones independientes generarían un archivo ejecutable.Previously, only self-contained deployments would produce an executable.

Durante dotnet build o dotnet publish, se crea un archivo ejecutable que coincide con el entorno y la plataforma del SDK que se usa.During dotnet build or dotnet publish, an executable is created that matches the environment and platform of the SDK you're using. Estos ejecutables funcionan de la misma forma que los ejecutables nativos:You can expect the same things with these executables as you would other native executables, such as:

  • Haga doble clic en el archivo ejecutable.You can double-click on the executable.
  • También puede iniciar la aplicación desde un símbolo del sistema directamente, como myapp.exe en Windows y ./myapp en Linux y macOS.You can launch the application from a command prompt directly, such as myapp.exe on Windows, and ./myapp on Linux and macOS.

Archivos ejecutables de único archivoSingle-file executables

El comando dotnet publish admite empaquetar la aplicación en un ejecutable de archivo único específico de la plataforma.The dotnet publish command supports packaging your app into a platform-specific single-file executable. El archivo ejecutable es autoextraíble y contiene todas las dependencias (incluidas las nativas) necesarias para ejecutar la aplicación.The executable is self-extracting and contains all dependencies (including native) that are required to run your app. Cuando la aplicación se ejecuta por primera vez, se extrae en un directorio que se basa en el nombre de la aplicación y el identificador de compilación.When the app is first run, the application is extracted to a directory based on the app name and build identifier. El inicio es más rápido cuando se vuelve a ejecutar la aplicación.Startup is faster when the application is run again. La aplicación no necesita extraerse por segunda vez a menos que se haya utilizado una nueva versión.The application doesn't need to extract itself a second time unless a new version was used.

Para publicar un ejecutable de archivo único, establezca PublishSingleFile en el proyecto o en la línea de comandos con el comando 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>

o bien-or-

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

Para obtener más información sobre la publicación de archivos únicos, vea el documento de diseño del programa de instalación de conjunto de archivos únicos.For more information about single-file publishing, see the single-file bundler design document.

Vinculación de ensambladosAssembly linking

El SDL de .NET Core 3.0 cuenta con una herramienta que puede reducir el tamaño de las aplicaciones mediante el análisis de IL y el recorte de los ensamblados no usados.The .NET core 3.0 SDK comes with a tool that can reduce the size of apps by analyzing IL and trimming unused assemblies.

Las aplicaciones independientes incluyen todo lo necesario para ejecutar el código, sin necesidad de instalar .NET en el equipo host.Self-contained apps include everything needed to run your code, without requiring .NET to be installed on the host computer. Sin embargo, muchas veces, la aplicación solo requiere un pequeño subconjunto de marco para que funcione, y otras bibliotecas que no se utilizan podrían quitarse.However, many times the app only requires a small subset of the framework to function, and other unused libraries could be removed.

.NET Core incluye ahora un valor que usará la herramienta Enlazador de IL para examinar el nivel de integridad de la aplicación..NET Core now includes a setting that will use the IL linker tool to scan the IL of your app. Esta herramienta detecta el código que es necesario y, después, recorta las bibliotecas no utilizadas.This tool detects what code is required, and then trims unused libraries. Esta herramienta puede reducir significativamente el tamaño de implementación de algunas aplicaciones.This tool can significantly reduce the deployment size of some apps.

Para habilitar esta herramienta, agregue el valor <PublishTrimmed> en el proyecto y publique una aplicación independiente: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

Por ejemplo, la nueva y básica plantilla de proyecto de consola "Hola mundo" que se incluye, cuando se publica, tiene un tamaño aproximado de 70 MB.As an example, the basic "hello world" new console project template that is included, when published, hits about 70 MB in size. Mediante el uso de <PublishTrimmed>, ese tamaño se reduce a unos 30 MB.By using <PublishTrimmed>, that size is reduced to about 30 MB.

Es importante tener en cuenta que las aplicaciones o marcos (incluidos ASP.NET Core y WPF) que usan la reflexión o las características dinámicas relacionadas, se interrumpirán a menudo cuando se recorten.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. Esta interrupción se produce porque el enlazador no conoce este comportamiento dinámico y no puede determinar qué tipos de marco son necesarios para la reflexión.This breakage occurs because the linker doesn't know about this dynamic behavior and can't determine which framework types are required for reflection. La herramienta Enlazador de IL puede configurarse para tener en cuenta este escenario.The IL Linker tool can be configured to be aware of this scenario.

Por encima de todo lo demás, no olvide probar la aplicación después del recorte.Above all else, be sure to test your app after trimming.

Para más información sobre la herramienta Enlazador de IL, vea la documentación o visite el repositorio mono/linker.For more information about the IL Linker tool, see the documentation or visit the mono/linker repo.

Compilación en nivelesTiered compilation

La compilación en niveles (TC) está activada de forma predeterminada con .NET Core 3.0.Tiered compilation (TC) is on by default with .NET Core 3.0. Esta característica permite que el runtime utilice el compilador Just-In-Time (JIT) de forma más flexible para generar un mejor rendimiento.This feature enables the runtime to more adaptively use the Just-In-Time (JIT) compiler to get better performance.

La principal ventaja de TC es permitir la vuelta a los métodos JIT con un nivel de menor calidad, pero más rápido, o un nivel de mayor calidad, pero más lento.The main benefit of TC is to enable (re-)jitting methods with a lower-quality-but-faster tier or a higher-quality-but-slower tier. Esto contribuye a aumentar el rendimiento de una aplicación a medida que pasa por distintas fases de ejecución, desde el inicio hasta alcanzar el estado estable.This helps increase performance of an application as it goes through various stages of execution, from startup through steady-state. Esto contrasta con el enfoque no TC, donde cada método se compila de una sola manera (al igual que el nivel de alta calidad), que se inclina por el estado estable sobre el rendimiento de inicio.This contrasts with the non-TC approach, where every method is compiled a single way (the same as the high-quality tier), which is biased to steady-state over startup performance.

Al habilitar TC durante el inicio de un método al que se llama:When TC is enabled, during startup for a method that is called:

  • Si el método tiene código compilado por AOT (ReadyToRun), se usará el código generado previamente.If the method has AOT-compiled code (ReadyToRun), the pregenerated code will be used.
  • De lo contrario, el método se compilará mediante JIT.Otherwise, the method will be jitted. Normalmente, estos métodos son genéricos con respecto a los tipos de valor.Typically, these methods currently are generics over value types.
    • La compilación mediante JIT rápida produce código de menor calidad a un ritmo superior.Quick JIT produces lower-quality code more quickly. Este tipo de compilación está habilitado de forma predeterminada en .NET Core 3.0 para los métodos que no contienen ningún bucle y que tienen preferencia durante el inicio.Quick JIT is enabled by default in .NET Core 3.0 for methods that do not contain loops and is preferred during startup.
    • La compilación mediante JIT completamente optimizada produce código de mayor calidad a un ritmo inferior.The fully-optimizing JIT produces higher-quality code more slowly. En el caso de los métodos en los que no se use la compilación mediante JIT rápida (por ejemplo, si el método tiene el atributo [MethodImpl(MethodImplOptions.AggressiveOptimization)]), se utilizará la compilación mediante JIT totalmente optimizada.For methods where Quick JIT would not be used (for example, if the method is attributed with [MethodImpl(MethodImplOptions.AggressiveOptimization)]), the fully-optimizing JIT is used.

Finalmente, después de que se llame a los métodos varias veces, se volverán a compilar mediante JIT con la compilación mediante JIT completamente optimizada en segundo plano.Eventually, after methods are called a number of times, they are re-jitted with the fully-optimizing JIT in the background.

El código generado con compilación mediante JIT rápida puede ejecutarse más lentamente, asignar más memoria o usar más espacio de pila.Code generated by Quick JIT may run slower, allocate more memory, or use more stack space. Si tiene algún problema, puede deshabilitar la compilación mediante JIT rápida usando este valor en el archivo del proyecto:If there are issues, Quick JIT may be disabled using this setting in your project file:

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

Para deshabilitar completamente TC, use esta opción en el archivo de proyecto:To disable TC completely, use this setting in your project file:

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

Cualquier cambio en la configuración anterior del archivo del proyecto puede requerir que se refleje una compilación limpia (elimine los directorios obj y bin y vuelva a realizar la compilación).Any changes to the above settings in the project file may require a clean build to be reflected (delete the obj and bin directories and rebuild).

Imágenes ReadyToRunReadyToRun images

Puede mejorar el tiempo de inicio de la aplicación .NET Core mediante la compilación de los ensamblados de aplicación como el formato ReadyToRun (R2R).You can improve the startup time of your .NET Core application by compiling your application assemblies as ReadyToRun (R2R) format. R2R es una forma de compilación Ahead Of Time (AOT).R2R is a form of ahead-of-time (AOT) compilation.

Los binarios de R2R mejoran el rendimiento de inicio reduciendo la cantidad de trabajo que el compilador Just-In-Time (JIT) debe llevar a cabo cuando se carga la aplicación.R2R binaries improve startup performance by reducing the amount of work the just-in-time (JIT) compiler needs to do as your application loads. Los binarios contienen código nativo similar en comparación con lo que generaría el compilador JIT.The binaries contain similar native code compared to what the JIT would produce. Sin embargo, los binarios de R2R son más grandes porque contienen tanto el código de lenguaje intermedio (IL), que sigue siendo necesario para algunos escenarios, como la versión nativa del mismo código.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 solo está disponible cuando publica una aplicación independiente que tenga como destino entornos de tiempo de ejecución específicos (RID), como Linux x64 o 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.

Para compilar el proyecto como ReadyToRun, haga lo siguiente:To compile your project as ReadyToRun, do the following:

  1. Agregue el valor <PublishReadyToRun> al proyecto:Add the <PublishReadyToRun> setting to your project:

    <PropertyGroup>
      <PublishReadyToRun>true</PublishReadyToRun>
    </PropertyGroup>
    
  2. Publique una aplicación independiente.Publish a self-contained app. Por ejemplo, este comando crea una aplicación independiente para la versión de 64 bits de 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
    

Restricciones multiplataforma y de arquitecturaCross platform/architecture restrictions

Actualmente, el compilador ReadyToRun no admite la compatibilidad cruzada.The ReadyToRun compiler doesn't currently support cross-targeting. Debe compilar en un destino dado.You must compile on a given target. Por ejemplo, si desea imágenes R2R para Windows x64, deberá ejecutar el comando de publicación en ese entorno.For example, if you want R2R images for Windows x64, you need to run the publish command on that environment.

Excepciones de la compatibilidad cruzada:Exceptions to cross-targeting:

  • Windows x64 se puede usar para compilar imágenes de Windows ARM32, ARM64 y x86.Windows x64 can be used to compile Windows ARM32, ARM64, and x86 images.
  • Windows x86 se puede usar para compilar imágenes de Windows ARM32.Windows x86 can be used to compile Windows ARM32 images.
  • Linux x64 se puede usar para compilar imágenes de Linux ARM32 y ARM64.Linux x64 can be used to compile Linux ARM32 and ARM64 images.

Runtime y SDKRuntime/SDK

Puesta al día de versiones principalesMajor-version Roll Forward

.NET Core 3.0 presenta una característica opcional que permite poner la aplicación al día con la versión principal más reciente de .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. Además, se agregó una nueva configuración para controlar cómo se aplica la puesta al día a la aplicación.Additionally, a new setting has been added to control how roll forward is applied to your app. Esto se puede configurar de las maneras siguientes:This can be configured in the following ways:

  • Propiedad de archivo del proyecto: RollForwardProject file property: RollForward
  • Propiedad de archivo de configuración del entorno de ejecución: rollForwardRuntime configuration file property: rollForward
  • Variable de entorno: DOTNET_ROLL_FORWARDEnvironment variable: DOTNET_ROLL_FORWARD
  • Argumento de línea de comandos: --roll-forwardCommand-line argument: --roll-forward

Debe especificarse uno de los valores siguientes.One of the following values must be specified. Si se omite la configuración, Minor es el valor predeterminado.If the setting is omitted, Minor is the default.

  • LatestPatchLatestPatch
    Se pone al día con la última versión de revisión.Roll forward to the highest patch version. Se deshabilita la puesta al día de versiones secundarias.This disables minor version roll forward.
  • MinorMinor
    Se pone al día con la versión secundaria mínima superior, si no se encuentra la versión secundaria solicitada.Roll forward to the lowest higher minor version, if requested minor version is missing. Si se encuentra la versión secundaria solicitada, se utiliza la directiva LatestPatch.If the requested minor version is present, then the LatestPatch policy is used.
  • MajorMajor
    Se pone al día con la versión secundaria mínima superior, y la versión secundaria mínima, si no se encuentra la versión secundaria solicitada.Roll forward to lowest higher major version, and lowest minor version, if requested major version is missing. Si se encuentra la versión principal solicitada, se utiliza la directiva Minor.If the requested major version is present, then the Minor policy is used.
  • LatestMinorLatestMinor
    Se pone al día con la última versión secundaria, aunque la versión secundaria solicitada esté presente.Roll forward to highest minor version, even if requested minor version is present. Se destina a escenarios de hospedaje de componentes.Intended for component hosting scenarios.
  • LatestMajorLatestMajor
    Se pone al día con la última versión principal y la última versión secundaria, aunque la versión principal solicitada esté presente.Roll forward to highest major and highest minor version, even if requested major is present. Se destina a escenarios de hospedaje de componentes.Intended for component hosting scenarios.
  • DisableDisable
    No se pone al día.Don't roll forward. Solo se enlaza a la versión especificada.Only bind to specified version. No se recomienda esta directiva para uso general, ya que deshabilita la capacidad de puesta al día con las revisiones más recientes.This policy isn't recommended for general use because it disables the ability to roll forward to the latest patches. Este valor solo se recomienda a efectos de pruebas.This value is only recommended for testing.

Además del valor Disable, todos los valores usarán la última versión de revisión disponible.Besides the Disable setting, all settings will use the highest available patch version.

Compilación de dependencias de copiasBuild copies dependencies

El comando dotnet build copia ahora las dependencias de NuGet para la aplicación de la caché de NuGet a la carpeta de salida de compilación.The dotnet build command now copies NuGet dependencies for your application from the NuGet cache to the build output folder. Anteriormente, las dependencias solo se copiaban como parte de dotnet publish.Previously, dependencies were only copied as part of dotnet publish.

Hay algunas operaciones, como la publicación de páginas Razor y la vinculación, que aún es necesario publicar.There are some operations, like linking and razor page publishing that will still require publishing.

Herramientas localesLocal tools

.NET Core 3.0 presenta herramientas locales..NET Core 3.0 introduces local tools. Las herramientas locales son similares a las herramientas globales pero están asociadas a una ubicación concreta en el disco.Local tools are similar to global tools but are associated with a particular location on disk. Las herramientas locales no están disponibles globalmente y se distribuyen como paquetes NuGet.Local tools aren't available globally and are distributed as NuGet packages.

Advertencia

Si ha probado herramientas locales en la versión preliminar 1 de .NET Core 3.0, tales como la ejecución de dotnet tool restore o de dotnet tool install, elimine la carpeta de caché de herramientas locales.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. En caso contrario, las herramientas locales no funcionan en las versiones más recientes.Otherwise, local tools won't work on any newer release. Esta carpeta se encuentra en:This folder is located at:

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

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

Las herramientas locales se basan en un nombre de archivo de manifiesto dotnet-tools.json del directorio actual.Local tools rely on a manifest file name dotnet-tools.json in your current directory. Este archivo de manifiesto define las herramientas que estarán disponibles en esa carpeta y a continuación.This manifest file defines the tools to be available at that folder and below. Puede distribuir el archivo de manifiesto con su código para asegurarse de que todo aquel que trabaje con su código pueda restaurar y utilizar las mismas herramientas.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.

Para las herramientas locales y globales, se requiere una versión compatible del entorno de ejecución.For both global and local tools, a compatible version of the runtime is required. Actualmente, muchas herramientas de NuGet.org tienen como destino el entorno de ejecución de .NET Core 2.1.Many tools currently on NuGet.org target .NET Core Runtime 2.1. Para instalar estas herramientas local o globalmente, aún tendría que instalar NET Core 2.1 Runtime.To install these tools globally or locally, you would still need to install the NET Core 2.1 Runtime.

Tamaños del montón de recolección de elementos no utilizados más pequeñosSmaller Garbage Collection heap sizes

Se ha reducido el tamaño predeterminado del montón del recolector de elementos no utilizados, lo que se traduce en que .NET Core usa menos memoria.The Garbage Collector's default heap size has been reduced resulting in .NET Core using less memory. Este cambio se adapta mejor al presupuesto de asignación de generación 0 con tamaños de caché de procesador moderno.This change better aligns with the generation 0 allocation budget with modern processor cache sizes.

Compatibilidad con Large Pages de recolección de elementos no utilizadosGarbage Collection Large Page support

Large Pages (también conocida como Huge Pages en Linux) es una característica en la que el sistema operativo es capaz de establecer regiones de memoria más grandes que el tamaño de página nativo (a menudo, 4 K) para mejorar el rendimiento de la aplicación que solicita estas páginas grandes.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.

Ahora, el recolector de elementos no utilizados puede configurarse con el valor GCLargePages como característica opcional para elegir la asignación de páginas grandes en 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.

Escritorio de Windows y COMWindows Desktop & COM

Windows Installer del SDK de .NET Core.NET Core SDK Windows Installer

El instalador MSI para Windows ha cambiado a partir de .NET Core 3.0.The MSI installer for Windows has changed starting with .NET Core 3.0. Los instaladores del SDK actualizarán ahora las versiones de la banda de características del SDK.The SDK installers will now upgrade SDK feature-band releases in place. Las bandas de características se definen en los grupos de centenas de la sección revisión del número de versión.Feature bands are defined in the hundreds groups in the patch section of the version number. Por ejemplo, 3.0.101 y 3.0.201 son versiones de dos bandas de características distintas mientras que 3.0.101 y 3.0.199 están en la misma banda de características.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. Y, cuando se instale el SDK 3.0.101 de .NET Core, se quitará el SDK 3.0.100 de .NET Core de la máquina si existe.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. Cuando se instale el SDK 3.0.200 de .NET Core en la misma máquina, no se quitará el SDK 3.0.101 de .NET Core.When .NET Core SDK 3.0.200 is installed on the same machine, .NET Core SDK 3.0.101 won't be removed.

Para obtener más información sobre las versiones, vea el artículo de introducción a la creación de versiones de .NET Core.For more information about versioning, see Overview of how .NET Core is versioned.

Escritorio de WindowsWindows desktop

.NET Core 3.0 admite aplicaciones de escritorio de Windows con Windows Presentation Foundation (WPF) y Windows Forms..NET Core 3.0 supports Windows desktop applications using Windows Presentation Foundation (WPF) and Windows Forms. Estos marcos también admiten el uso de controles modernos y los estilos de Fluent de la biblioteca de XAML de la interfaz de usuario de Windows (WinUI) a través de islas XAML.These frameworks also support using modern controls and Fluent styling from the Windows UI XAML Library (WinUI) via XAML islands.

El componente Escritorio de Windows forma parte del SDK de Windows .NET Core 3.0.The Windows Desktop component is part of the Windows .NET Core 3.0 SDK.

Puede crear una aplicación de Windows Forms o WPF con los siguientes comandos 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 agrega plantillas de nuevo proyecto para WPF y Windows Forms de .NET Core 3.0.Visual Studio 2019 adds New Project templates for .NET Core 3.0 Windows Forms and WPF.

Para obtener más información sobre cómo migrar una aplicación existente de .NET Framework, vea los artículos sobre cómo portar proyectos de WPF y cómo portar proyectos de Windows Forms.For more information about how to port an existing .NET Framework application, see Port WPF projects and Port Windows Forms projects.

PPP alto de WinFormsWinForms high DPI

En .NET Core, las aplicaciones de Windows Forms pueden establecer el modo de valores altos de PPP con Application.SetHighDpiMode(HighDpiMode)..NET Core Windows Forms applications can set high DPI mode with Application.SetHighDpiMode(HighDpiMode). El método SetHighDpiMode establece el modo de valores altos de PPP correspondiente a menos que la opción se haya establecido por otros medios como App.Manifest o P/Invoke antes de 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.

Los posibles valores de highDpiMode, expresados por la enumeración System.Windows.Forms.HighDpiMode son:The possible highDpiMode values, as expressed by the System.Windows.Forms.HighDpiMode enum are:

  • DpiUnaware
  • SystemAware
  • PerMonitor
  • PerMonitorV2
  • DpiUnawareGdiScaled

Para más información sobre los modos de valores altos de PPP, consulte el artículo sobre desarrollo de aplicaciones de escritorio con valores altos de PPP en Windows.For more information about high DPI modes, see High DPI Desktop Application Development on Windows.

Creación de componentes COMCreate COM components

En Windows, ahora puede crear componentes COM administrados invocables.On Windows, you can now create COM-callable managed components. Esta capacidad es fundamental para usar .NET Core con modelos de complemento COM, así como para ofrecer paridad con .NET Framework.This capability is critical to use .NET Core with COM add-in models and also to provide parity with .NET Framework.

A diferencia de .NET Framework, donde se utilizó mscoree.dll como servidor COM, .NET Core agregará un archivo dll de inicio nativo al directorio bin al compilar el componente COM.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.

Para ver un ejemplo de cómo crear un componente COM y usarlo, consulte la demostración de COM.For an example of how to create a COM component and consume it, see the COM Demo.

Interoperabilidad nativa de WindowsWindows Native Interop

Windows ofrece una API nativa enriquecida en forma de API de C sin formato, COM y WinRT.Windows offers a rich native API in the form of flat C APIs, COM, and WinRT. Mientras que .NET Core admite P/Invoke, .NET Core 3.0 agrega la capacidad de API COM CoCreate y API WinRT Activate.While .NET Core supports P/Invoke, .NET Core 3.0 adds the ability to CoCreate COM APIs and Activate WinRT APIs. Para obtener un ejemplo de código, vea la demostración de Excel.For a code example, see the Excel Demo.

Implementación de MSIXMSIX Deployment

MSIX es un nuevo formato de paquete de aplicación de Windows.MSIX is a new Windows application package format. Se puede usar para implementar aplicaciones de escritorio de .NET Core 3.0 en Windows 10.It can be used to deploy .NET Core 3.0 desktop applications to Windows 10.

El proyecto de paquete de aplicación de Windows, disponible en Visual Studio 2019, le permite crear paquetes de MSIX con aplicaciones de .NET Core independientes.The Windows Application Packaging Project, available in Visual Studio 2019, allows you to create MSIX packages with self-contained .NET Core applications.

El archivo del proyecto de .NET Core debe especificar los tiempos de ejecución admitidos en la propiedad <RuntimeIdentifiers>:The .NET Core project file must specify the supported runtimes in the <RuntimeIdentifiers> property:

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

Mejoras de LinuxLinux improvements

SerialPort para LinuxSerialPort for Linux

.Net Core 3.0 proporciona compatibilidad básica para System.IO.Ports.SerialPort en Linux..NET Core 3.0 provides basic support for System.IO.Ports.SerialPort on Linux.

Anteriormente, .NET Core solo admitía el uso de SerialPort en Windows.Previously, .NET Core only supported using SerialPort on Windows.

Para obtener más información sobre la compatibilidad limitada para el puerto de serie en Linux, vea Problema #33146 de GitHub.For more information about the limited support for the serial port on Linux, see GitHub issue #33146.

Docker y límites de memoria de cgroupDocker and cgroup memory Limits

La ejecución de .NET Core 3.0 en Linux con Docker funciona mejor con límites de memoria de cgroup.Running .NET Core 3.0 on Linux with Docker works better with cgroup memory limits. La ejecución de un contenedor de Docker con límites de memoria, como con docker run -m, cambia el comportamiento de .NET Core.Running a Docker container with memory limits, such as with docker run -m, changes how .NET Core behaves.

  • Tamaño predeterminado del montón del recolector de elementos no utilizados (GC): máximo de 20 MB o 75 % del límite de memoria en el contenedor.Default Garbage Collector (GC) heap size: maximum of 20 mb or 75% of the memory limit on the container.
  • Puede establecerse el tamaño explícito como número absoluto o porcentaje del límite de cgroup.Explicit size can be set as an absolute number or percentage of cgroup limit.
  • El tamaño mínimo del segmento reservado por el montón de GC es de 16 MB.Minimum reserved segment size per GC heap is 16 mb. Con este tamaño se reduce el número de montones que se crean en las máquinas.This size reduces the number of heaps that are created on machines.

Compatibilidad de GPIO con Raspberry PiGPIO Support for Raspberry Pi

Se han publicado dos paquetes en NuGet que puede usar para la programación de GPIO:Two packages have been released to NuGet that you can use for GPIO programming:

Los paquetes GPIO incluyen interfaces API para dispositivos GPIO, SPI, I2C y PWM.The GPIO packages include APIs for GPIO, SPI, I2C, and PWM devices. El paquete de enlaces de IoT incluye enlaces de dispositivos.The IoT bindings package includes device bindings. Para obtener más información, vea el repositorio de GitHub de los dispositivos.For more information, see the devices GitHub repo.

Compatibilidad con ARM64 para LinuxARM64 Linux support

.NET Core 3.0 agrega compatibilidad con ARM64 para Linux..NET Core 3.0 adds support for ARM64 for Linux. El principal caso de uso de ARM64 son escenarios de IoT.The primary use case for ARM64 is currently with IoT scenarios. Para obtener más información, vea el artículo sobre el estado de ARM64 de .NET Core.For more information, see .NET Core ARM64 Status.

Hay imágenes de docker para .NET Core en ARM64 disponibles para Alpine, Debian y Ubuntu.Docker images for .NET Core on ARM64 are available for Alpine, Debian, and Ubuntu.

Nota

Windows aún no ofrece soporte técnico para ARM64.ARM64 Windows support isn't yet available.

SeguridadSecurity

TLS 1.3 y OpenSSL 1.1.1 en LinuxTLS 1.3 & OpenSSL 1.1.1 on Linux

.NET Core aprovecha ahora la ventaja de la compatibilidad con TLS 1.3 en OpenSSL 1.1.1, cuando está disponible en un entorno determinado..NET Core now takes advantage of TLS 1.3 support in OpenSSL 1.1.1, when it's available in a given environment. Con TLS 1.3:With TLS 1.3:

  • Se han mejorado los tiempos de conexión con menores recorridos de ida y vuelta necesarios entre el cliente y servidor.Connection times are improved with reduced round trips required between the client and server.
  • Se ha mejorado la seguridad gracias a la eliminación de varios algoritmos criptográficos obsoletos y no seguros.Improved security because of the removal of various obsolete and insecure cryptographic algorithms.

Cuando está disponible, .NET Core 3.0 utiliza OpenSSL 1.1.1, OpenSSL 1.1.0 o OpenSSL 1.0.2 en un sistema 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. Si OpenSSL 1.1.1 está disponible, los tipos System.Net.Security.SslStream y System.Net.Http.HttpClient, utilizarán TLS 1.3 (suponiendo que el cliente y el servidor admitan 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).

Importante

Windows y macOS aún no admiten TLS 1.3.Windows and macOS do not yet support TLS 1.3. .NET Core 3.0 será compatible con TLS 1.3 en estos sistemas operativos cuando haya disponible soporte técnico..NET Core 3.0 will support TLS 1.3 on these operating systems when support becomes available.

El siguiente ejemplo de C# 8.0 muestra .NET Core 3.0 en Ubuntu 18.10 al conectarse a 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}");
        }
    }
}

Cifrados de criptografíaCryptography ciphers

.NET 3.0 agrega compatibilidad con los cifrados AES-GCM y AES-CCM, que se implementan con System.Security.Cryptography.AesGcm y System.Security.Cryptography.AesCcm respectivamente..NET 3.0 adds support for AES-GCM and AES-CCM ciphers, implemented with System.Security.Cryptography.AesGcm and System.Security.Cryptography.AesCcm respectively. Estos dos algoritmos son algoritmos AEAD (Authenticated Encryption with Associated Data).These algorithms are both Authenticated Encryption with Association Data (AEAD) algorithms.

El código siguiente muestra cómo utilizar cifrado AesGcm para cifrar y descifrar datos aleatorios.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.");
        }
    }
}

Importación y exportación de claves criptográficaCryptographic Key Import/Export

.NET Core 3.0 admite la importación y exportación de claves asimétricas públicas y privadas en formatos estándar..NET Core 3.0 supports the import and export of asymmetric public and private keys from standard formats. No es necesario utilizar un certificado X.509.You don't need to use an X.509 certificate.

Todos los tipos de clave, como RSA, DSA, ECDsa y ECDiffieHellman, admiten los siguientes formatos:All key types, such as RSA, DSA, ECDsa, and ECDiffieHellman, support the following formats:

  • Clave públicaPublic Key

    • SubjectPublicKeyInfo X.509X.509 SubjectPublicKeyInfo
  • Clave privadaPrivate key

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

Las claves RSA también admiten:RSA keys also support:

  • Clave públicaPublic Key

    • RSAPublicKey PKCS#1PKCS#1 RSAPublicKey
  • Clave privadaPrivate key

    • RSAPrivateKey PKCS#1PKCS#1 RSAPrivateKey

Los métodos de exportación generan datos binarios con codificación DER y los métodos de importación esperan lo mismo.The export methods produce DER-encoded binary data, and the import methods expect the same. Si una clave se almacena en el formato PEM de texto descriptivo, el llamador debe descodificar en base64 el contenido antes de llamar a un método de importación.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));
        }
    }
}

Los archivos PKCS#8 se pueden inspeccionar con System.Security.Cryptography.Pkcs.Pkcs8PrivateKeyInfo y los archivos PFX/PKCS#12 se pueden inspeccionar con 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. Los archivos PFX/PKCS#12 se pueden manipular con System.Security.Cryptography.Pkcs.Pkcs12Builder.PFX/PKCS#12 files can be manipulated with System.Security.Cryptography.Pkcs.Pkcs12Builder.

Cambios de API en .NET Core 3.0.NET Core 3.0 API changes

Rangos e índicesRanges and indices

El nuevo tipo System.Index se puede utilizar para la indización.The new System.Index type can be used for indexing. Puede crear uno desde un índice int que cuente desde el principio o con un operador ^ de prefijo (C#) que cuente desde el final: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"

Existe también el tipo System.Range, que consta de dos valores Index, uno para el inicio y otro para el final, y se puede escribir con una expresión de intervalo 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#). Luego puede crear un índice con un Range, lo que genera un segmento:You can then index with a Range, which produces a slice:

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

Para obtener más información, vea el tutorial sobre intervalos e índices.For more information, see the ranges and indices tutorial.

Flujos asincrónicosAsync streams

El tipo IAsyncEnumerable<T> es una nueva versión asincrónica de IEnumerable<T>.The IAsyncEnumerable<T> type is a new asynchronous version of IEnumerable<T>. El lenguaje permite ejecutar la instrucción await foreach en IAsyncEnumerable<T> para consumir sus elementos, y usar la instrucción yield return en ellos para generar los elementos.The language lets you await foreach over IAsyncEnumerable<T> to consume their elements, and use yield return to them to produce elements.

En el ejemplo siguiente se muestra la producción y el consumo de flujos asincrónicos.The following example demonstrates both production and consumption of async streams. La instrucción foreach es asincrónica y usa yield return para generar un flujo asincrónico para los llamadores.The foreach statement is async and itself uses yield return to produce an async stream for callers. Este patrón (que usa yield return) es el modelo recomendado para generar flujos asincrónicos.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;
    }
}

Además de poder ejecutar await foreach, también puede crear iteradores asincrónicos, por ejemplo, uno que devuelva un enumerador IAsyncEnumerable/IAsyncEnumerator en el que pueda ejecutar await y 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. Para los objetos que deban eliminarse, puede usar IAsyncDisposable, que implementan varios tipos BCL, como Stream y Timer.For objects that need to be disposed, you can use IAsyncDisposable, which various BCL types implement, such as Stream and Timer.

Para obtener más información, vea el tutorial sobre flujos asincrónicos.For more information, see the async streams tutorial.

Punto flotante de IEEEIEEE Floating-point

Las API de punto flotante se actualizan para cumplir con la revisión IEEE 754-2008.Floating point APIs are being updated to comply with IEEE 754-2008 revision. El objetivo de estos cambios es exponer todas operaciones requeridas y asegurarse de que cumplen con la especificación IEEE. Para obtener más información sobre las mejoras de punto flotante, vea la entrada de blog sobre mejoras de formato y análisis de punto flotante en .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.

Entre las correcciones de análisis y formato se incluyen:Parsing and formatting fixes include:

  • Analice y redondee entradas de cualquier longitud correctamente.Correctly parse and round inputs of any length.
  • Analice y formatee el cero negativo correctamente.Correctly parse and format negative zero.
  • Análisis correcto de Infinity y NaN al hacer una comprobación que no distingue mayúsculas de minúsculas y permitir un + anterior opcional cuando corresponda.Correctly parse Infinity and NaN by doing a case-insensitive check and allowing an optional preceding + where applicable.

Entre las nuevas API System.Math se incluyen:New System.Math APIs include:

  • BitIncrement(Double) y BitDecrement(Double)BitIncrement(Double) and BitDecrement(Double)
    Corresponde a las operaciones IEEE nextUp y nextDown.Corresponds to the nextUp and nextDown IEEE operations. Devuelven el número de punto flotante más pequeño que compara mayor o menor que la entrada (respectivamente).They return the smallest floating-point number that compares greater or lesser than the input (respectively). Por ejemplo, Math.BitIncrement(0.0) devolvería double.Epsilon.For example, Math.BitIncrement(0.0) would return double.Epsilon.

  • MaxMagnitude(Double, Double) y MinMagnitude(Double, Double)MaxMagnitude(Double, Double) and MinMagnitude(Double, Double)
    Corresponde a las operaciones IEEE maxNumMag y minNumMag, que devuelven el valor que es mayor o menor en magnitud de las dos entradas (respectivamente).Corresponds to the maxNumMag and minNumMag IEEE operations, they return the value that is greater or lesser in magnitude of the two inputs (respectively). Por ejemplo, Math.MaxMagnitude(2.0, -3.0) devolvería -3.0.For example, Math.MaxMagnitude(2.0, -3.0) would return -3.0.

  • ILogB(Double)
    Corresponde a la operación IEEE logB que devuelve un valor entero, devuelve el logaritmo en base 2 integral del parámetro de entrada.Corresponds to the logB IEEE operation that returns an integral value, it returns the integral base-2 log of the input parameter. Este método es efectivamente el mismo que floor(log2(x)), pero con errores de redondeo mínimo.This method is effectively the same as floor(log2(x)), but done with minimal rounding error.

  • ScaleB(Double, Int32)
    Corresponde a la operación IEEE scaleB que toma un valor integral, devuelve eficazmente x * pow(2, n), pero se realiza con errores de redondeo mínimo.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)
    Corresponde a la operación IEEE log2. Devuelve el logaritmo de base 2.Corresponds to the log2 IEEE operation, it returns the base-2 logarithm. Minimiza el error de redondeo.It minimizes rounding error.

  • FusedMultiplyAdd(Double, Double, Double)
    Corresponde a la operación IEEE fma. Realiza una multiplicación y suma fusionadas.Corresponds to the fma IEEE operation, it performs a fused multiply add. Es decir, realiza (x * y) + z como operación única, de forma que se minimiza el error de redondeo.That is, it does (x * y) + z as a single operation, thereby minimizing the rounding error. Un ejemplo sería FusedMultiplyAdd(1e308, 2.0, -1e308), que devuelve 1e308.An example would be FusedMultiplyAdd(1e308, 2.0, -1e308) which returns 1e308. La operación (1e308 * 2.0) - 1e308 regular devuelve double.PositiveInfinity.The regular (1e308 * 2.0) - 1e308 returns double.PositiveInfinity.

  • CopySign(Double, Double)
    Corresponde a la operación IEEE copySign. Devuelve el valor de x, pero con el signo de y.Corresponds to the copySign IEEE operation, it returns the value of x, but with the sign of y.

Elementos intrínsecos dependientes de la plataforma .NET.NET Platform-Dependent Intrinsics

Se han agregado API que permiten el acceso a determinadas instrucciones CPU orientadas al rendimiento, como los conjuntos de instrucciones de manipulación de bits o SIMD.APIs have been added that allow access to certain perf-oriented CPU instructions, such as the SIMD or Bit Manipulation instruction sets. Estas instrucciones pueden ayudar a conseguir importantes mejoras de rendimiento en ciertos escenarios, como el procesamiento de datos con eficiencia en paralelo.These instructions can help achieve significant performance improvements in certain scenarios, such as processing data efficiently in parallel.

En su caso, las bibliotecas de .NET han comenzado a utilizar estas instrucciones para mejorar el rendimiento.Where appropriate, the .NET libraries have begun using these instructions to improve performance.

Para obtener más información, vea el artículo sobre elementos intrínsecos dependientes de la plataforma .NET.For more information, see .NET Platform Dependent Intrinsics.

API de versión mejoradas de .NET CoreImproved .NET Core Version APIs

A partir de .NET Core 3.0, las API de versión incluidas con .NET Core ahora devuelven la información que se espera.Starting with .NET Core 3.0, the version APIs provided with .NET Core now return the information you expect. Por ejemplo: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

Advertencia

Cambio importante.Breaking change. Se trata técnicamente de un cambio importante, porque ha cambiado el esquema de control de versiones.This is technically a breaking change because the versioning scheme has changed.

Compatibilidad con JSON integrada con rápido rendimientoFast built-in JSON support

Los usuarios de .NET se han basado en gran medida en Newtonsoft.Json y otras bibliotecas populares de JSON, que siguen siendo buenas opciones..NET users have largely relied on Newtonsoft.Json and other popular JSON libraries, which continue to be good choices. Newtonsoft.Json usa cadenas de .NET como tipo de datos base, que, en esencia, es UTF-16.Newtonsoft.Json uses .NET strings as its base datatype, which is UTF-16 under the hood.

La nueva compatibilidad integrada con JSON es de alto rendimiento, baja asignación y funciona con texto JSON codificado UTF-8.The new built-in JSON support is high-performance, low allocation, and works with UTF-8 encoded JSON text. Para obtener más información sobre el espacio de nombres System.Text.Json y los tipos, vea los artículos siguientes:For more information about the System.Text.Json namespace and types, see the following articles:

Compatibilidad con HTTP/2HTTP/2 support

El tipo System.Net.Http.HttpClient es compatible con el protocolo HTTP/2.The System.Net.Http.HttpClient type supports the HTTP/2 protocol. Si se habilita HTTP/2, la versión del protocolo HTTP se negocia a través de TLS/ALPN y HTTP/2 solo se usa si el servidor opta por usarlo.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.

El protocolo predeterminado sigue siendo HTTP/1.1, pero se puede habilitar HTTP/2 de dos maneras diferentes.The default protocol remains HTTP/1.1, but HTTP/2 can be enabled in two different ways. En primer lugar, puede establecer el mensaje de solicitud HTTP para usar 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);

En segundo lugar, puede cambiar HttpClient para usar HTTP/2 de forma predeterminada: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);

Muchas veces cuando está desarrollando una aplicación, desea utilizar una conexión no cifrada.Many times when you're developing an application, you want to use an unencrypted connection. Si sabe que el punto de conexión de destino utilizará HTTP/2, puede activar las conexiones no cifradas para HTTP/2.If you know the target endpoint will be using HTTP/2, you can turn on unencrypted connections for HTTP/2. Puede activarlas estableciendo la variable de entorno DOTNET_SYSTEM_NET_HTTP_SOCKETSHTTPHANDLER_HTTP2UNENCRYPTEDSUPPORT en 1 o habilitándolas en el contexto de la aplicación: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);

Pasos siguientesNext steps