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.

Tutoriales relacionados con las características del lenguaje de C# 8.0:Tutorials related to C# 8.0 language features:

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 (conocido como appHost) que coincide con el entorno y la plataforma del SDK que se usa.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. 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.

appHost y certificación de macOSmacOS appHost and notarization

Solo para macOSmacOS only

A partir del SDK de .NET Core 3.0 para macOS certificado, el valor para generar un archivo ejecutable predeterminado (conocido como appHost) está deshabilitado de forma predeterminada.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. Para obtener más información, vea Certificación de macOS Catalina y el impacto en las descargas y proyectos de .NET Core.For more information, see macOS Catalina Notarization and the impact on .NET Core downloads and projects.

Cuando la configuración de appHost está habilitada, .NET Core genera un ejecutable Mach-O nativo al compilar o publicar.When the appHost setting is enabled, .NET Core generates a native Mach-O executable when you build or publish. La aplicación se ejecuta en el contexto de appHost cuando se ejecuta desde el código fuente con el comando dotnet run o mediante el inicio directo del ejecutable 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.

Sin appHost, la única manera en la que un usuario puede iniciar una aplicación dependiente del marco es con el comando dotnet <filename.dll>.Without the appHost, the only way a user can start a framework-dependent app is with the dotnet <filename.dll> command. Siempre se crea un instancia de appHost al publicar la aplicación de manera independiente.An appHost is always created when you publish your app self-contained.

Puede configurar appHost en el nivel de proyecto, o bien cambiar la instancia de appHost de un comando dotnet específico con el parámetro -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:

  • Archivo del proyectoProject file

    <PropertyGroup>
      <UseAppHost>true</UseAppHost>
    </PropertyGroup>
    
  • Parámetro de línea de comandosCommand-line parameter

    dotnet run -p:UseAppHost=true
    

Para obtener más información sobre la configuración de UseAppHost, vea Propiedades de MSBuild para Microsoft.NET.Sdk.For more information about the UseAppHost setting, see MSBuild properties for Microsoft.NET.Sdk.

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 use el compilador Just-In-Time (JIT) de forma más flexible para lograr un mejor rendimiento.This feature enables the runtime to more adaptively use the just-in-time (JIT) compiler to achieve better performance.

La principal ventaja de la compilación en niveles es que ofrece dos maneras de aplicar JIT a los métodos: 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 tiered compilation is to provide two ways of jitting methods: in a lower-quality-but-faster tier or a higher-quality-but-slower tier. La calidad se refiere al grado de optimización del método.The quality refers to how well the method is optimized. La compilación en niveles contribuye a mejorar el rendimiento de una aplicación a medida que pasa por distintas fases de ejecución, desde el inicio hasta el estado estable.TC helps to improve the performance of an application as it goes through various stages of execution, from startup through steady state. Cuando la compilación en niveles está deshabilitada, todos los métodos se compilan de una manera única que prima el rendimiento de estado estable sobre el rendimiento de inicio.When tiered compilation is disabled, every method is compiled in a single way that's biased to steady-state performance over startup performance.

Cuando la compilación en niveles está habilitada, se aplica el comportamiento siguiente a la compilación de métodos al iniciar una aplicación:When TC is enabled, the following behavior applies for method compilation when an app starts up:

  • Si el método tiene código compilado mediante Ahead-Of-Time, o ReadyToRun, se usa el código generado previamente.If the method has ahead-of-time-compiled code, or ReadyToRun, the pregenerated code is used.
  • De lo contrario, el método se compila mediante JIT.Otherwise, the method is jitted. Normalmente, estos métodos son genéricos con respecto a los tipos de valor.Typically, these methods are generics over value types.
    • JIT rápido produce código de menor calidad (o menos optimizado) más rápidamente.Quick JIT produces lower-quality (or less optimized) code more quickly. En .NET Core 3.0, JIT rápido está habilitado de forma predeterminada para los métodos que no contienen ningún bucle y tiene preferencia durante el inicio.In .NET Core 3.0, Quick JIT is enabled by default for methods that don't contain loops and is preferred during startup.
    • JIT de optimización completa produce código de mayor calidad (o más optimizado) más lentamente.The fully optimizing JIT produces higher-quality (or more optimized) 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 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 MethodImplOptions.AggressiveOptimization), the fully optimizing JIT is used.

En el caso de los métodos a los que se llama con frecuencia, el compilador Just-in-Time al final crea código totalmente optimizado en segundo plano.For frequently called methods, the just-in-time compiler eventually creates fully optimized code in the background. Luego, el código optimizado reemplaza el código compilado previamente de ese método.The optimized code then replaces the pre-compiled code for that method.

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 hay problemas, puede deshabilitar JIT rápido con esta propiedad de MSBuild en el archivo de proyecto:If there are issues, you can disabled Quick JIT using this MSBuild property in the project file:

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

Para deshabilitar completamente la compilación en niveles, use esta propiedad de MSBuild en el archivo de proyecto:To disable TC completely, use this MSBuild property in your project file:

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

Sugerencia

Si cambia esta configuración en el archivo de proyecto, es posible que deba realizar una compilación limpia para que se refleje la nueva configuración (elimine los directorios obj y bin y vuelva a compilar).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).

Para obtener más información sobre la configuración de la compilación en tiempo de ejecución, vea Opciones de configuración del entorno de ejecución para compilación.For more information about configuring compilation at run time, see Run-time configuration options for compilation.

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.

Para obtener más información, consulte Ready to Run.For more information, see Ready to Run.

Runtime y SDKRuntime/SDK

Puesta al día del runtime de versiones principalesMajor-version runtime 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 en tiempo de ejecución: rollForwardRun-time 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.

De forma predeterminada, si la versión solicitada (como se especifica en .runtimeconfig.json para la aplicación) es una versión de lanzamiento, solo se tienen en cuenta las versiones de lanzamiento para la puesta al día.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. Se omiten las versiones preliminares.Any pre-release versions are ignored. Si no hay ninguna versión de lanzamiento que coincida, se tienen en cuenta las versiones preliminares.If there is no matching release version, then pre-release versions are taken into account. Este comportamiento se puede cambiar estableciendo DOTNET_ROLL_FORWARD_TO_PRERELEASE=1, en cuyo caso siempre se tienen en cuenta todas las versiones.This behavior can be changed by setting DOTNET_ROLL_FORWARD_TO_PRERELEASE=1, in which case all versions are always considered.

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.

Opciones nuevas de global.jsonNew global.json options

El archivo global.json tiene opciones nuevas que proporcionan más flexibilidad cuando se intenta definir qué versión de la SDK de .NET Core se usa.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. Las opciones nuevas son:The new options are:

  • allowPrerelease: Indica si la resolución del SDK debe tener en cuenta las versiones preliminares a la hora de seleccionar la versión del SDK que se va a usar.allowPrerelease: Indicates whether the SDK resolver should consider prerelease versions when selecting the SDK version to use.
  • rollForward: indica la directiva de puesta al día que se va a usar al seleccionar una versión del SDK, ya sea como reserva si falta una versión específica del SDK o como una directiva para usar una versión superior.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.

Para más información sobre los cambios, incluidos los valores predeterminados, los valores admitidos y reglas de coincidencia nuevas, consulte la información general de global.json.For more information about the changes including default values, supported values, and new matching rules, see global.json overview.

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.

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 Core 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 Core 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 es FusedMultiplyAdd(1e308, 2.0, -1e308), que devuelve 1e308.An example is 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, consulte 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