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 16.3, Visual Studio para Mac 8.3 o Visual Studio Code con la extensión de C# .It's highly recommended that you use Visual Studio 2019 16.3, Visual Studio for Mac 8.3, or Visual Studio Code with the 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.

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.

C# 8.0C# 8.0

C# 8.0 también forma parte de esta versión, la cual 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.

.NET Standard 2.1.NET Standard 2.1

Aunque .NET Core 3.0 admite .NET Standard 2.1, la plantilla predeterminada dotnet new classlib genera un proyecto que sigue destinado a .NET Standard 2.0.Even though .NET Core 3.0 supports .NET Standard 2.1, 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.

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
//   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.

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.

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 qué código es necesario y, a continuación, recorta las bibliotecas sin usar.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.

Para habilitar JIT rápido (código de nivel 0 con compilación JIT), use esta opción en el archivo de proyecto:To enable Quick JIT (tier 0 jitted code), use this setting in your project file:

<PropertyGroup>
  <TieredCompilationQuickJit>true</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:

<TieredCompilation>false</TieredCompilation>

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 true
    

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.

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.

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.

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.

Componentes COM invocables: Escritorio de WindowsCOM-callable components - Windows Desktop

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.

Implementación de MSIX: Escritorio de WindowsMSIX Deployment - Windows Desktop

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>

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.

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.

Mejoras de punto flotante de IEEEIEEE Floating-point improvements

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.

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

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

La nueva compatibilidad con JSON integrada es el alto rendimiento, una baja asignación y se basa en Span<byte>.The new built-in JSON support is high-performance, low allocation, and based on Span<byte>. Se han agregado tres nuevos tipos relacionados con JSON principales a .NET Core 3.0 y el espacio de nombres System.Text.Json.Three new main JSON-related types have been added to .NET Core 3.0 the System.Text.Json namespace. Estos tipos aún no admiten la serialización y deserialización de objetos CLR estándar (POCO).These types don't yet support plain old CLR object (POCO) serialization and deserialization.

Utf8JsonReaderUtf8JsonReader

System.Text.Json.Utf8JsonReader es un lector de solo avance, de baja asignación y de alto rendimiento para texto JSON con codificación UTF-8 que se lee desde ReadOnlySpan<byte>.System.Text.Json.Utf8JsonReader is a high-performance, low allocation, forward-only reader for UTF-8 encoded JSON text, read from a ReadOnlySpan<byte>. Utf8JsonReader es un tipo fundamental, de bajo nivel, que se puede usar para compilar los analizadores personalizados y deserializadores.The Utf8JsonReader is a foundational, low-level type, that can be used to build custom parsers and deserializers. La lectura a través de una carga JSON con el nuevo lector Utf8JsonReader es el doble de rápido que con el lector de Json.NET.Reading through a JSON payload using the new Utf8JsonReader is 2x faster than using the reader from Json.NET. No se asigna hasta que haya que actualizar tokens JSON como cadenas (UTF-16).It doesn't allocate until you need to actualize JSON tokens as (UTF-16) strings.

Este es un ejemplo de lectura a través del archivo launch.json creado por Visual Studio Code:Here is an example of reading through the launch.json file created by Visual Studio Code:

public static void PrintJson(ReadOnlySpan<byte> dataUtf8)
{
    var json = new Utf8JsonReader(dataUtf8, isFinalBlock: true, state: default);
    
    while (json.Read())
    {
        JsonTokenType tokenType = json.TokenType;
        ReadOnlySpan<byte> valueSpan = json.ValueSpan;
        switch (tokenType)
        {
            case JsonTokenType.StartObject:
            case JsonTokenType.EndObject:
                break;
            case JsonTokenType.StartArray:
            case JsonTokenType.EndArray:
                break;
            case JsonTokenType.PropertyName:
                break;
            case JsonTokenType.String:
                Console.WriteLine($"STRING: {json.GetString()}");
                break;
            case JsonTokenType.Number:
                if (!json.TryGetInt32(out int valueInteger))
                {
                    throw new FormatException();
                }
                break;
            case JsonTokenType.True:
            case JsonTokenType.False:
                Console.WriteLine($"BOOL: {json.GetBoolean()}");
                break;
            case JsonTokenType.Null:
                break;
            default:
                throw new ArgumentException();
        }
    }

    dataUtf8 = dataUtf8.Slice((int)json.BytesConsumed);
    JsonReaderState state = json.CurrentState;
}
// Calling code
Console.WriteLine("Read with Utf8JsonReader");
PrintJson(File.ReadAllBytes("launch.json").AsSpan());

Utf8JsonWriterUtf8JsonWriter

System.Text.Json.Utf8JsonWriter proporciona una forma de escribir texto JSON con codificación UTF-8 de alto rendimiento, sin almacenar en caché y de solo avance a partir de tipos de .NET comunes como String, Int32 y DateTime.System.Text.Json.Utf8JsonWriter provides a high-performance, non-cached, forward-only way to write UTF-8 encoded JSON text from common .NET types like String, Int32, and DateTime. Al igual que el lector, el sistema de escritura es un tipo fundamental, de bajo nivel, que puede usarse para generar serializadores personalizados.Like the reader, the writer is a foundational, low-level type, that can be used to build custom serializers. Escribir una carga JSON con el nuevo Utf8JsonWriter es un 30-80 % más rápido que con el escritor de Json.NET y no se asigna.Writing a JSON payload using the new Utf8JsonWriter is 30-80% faster than using the writer from Json.NET and doesn't allocate.

JsonDocumentJsonDocument

System.Text.Json.JsonDocument se basa en Utf8JsonReader.System.Text.Json.JsonDocument is built on top of the Utf8JsonReader. JsonDocument proporciona la capacidad de analizar datos JSON y crear un Document Object Model (DOM) de solo lectura que se puede consultar para admitir el acceso aleatorio y la enumeración.The JsonDocument provides the ability to parse JSON data and build a read-only Document Object Model (DOM) that can be queried to support random access and enumeration. A los elementos JSON que componen los datos se puede acceder mediante el tipo JsonElement que se expone mediante JsonDocument como una propiedad denominada RootElement.The JSON elements that compose the data can be accessed via the JsonElement type that is exposed by the JsonDocument as a property called RootElement. El JsonElement contiene la matriz de JSON y enumeradores del objeto junto con las API para convertir texto JSON en tipos de .NET comunes.The JsonElement contains the JSON array and object enumerators along with APIs to convert JSON text to common .NET types. El análisis de una carga útil típica de JSON y el acceso a todos sus miembros usando JsonDocument es 2-3 veces más rápido que con Json.NET con pequeñas asignaciones de datos de tamaño razonable (es decir, < 1 MB).Parsing a typical JSON payload and accessing all its members using the JsonDocument is 2-3x faster than Json.NET with little allocations for data that is reasonably sized (that is, < 1 MB).

A continuación se muestra un uso del ejemplo del JsonDocument y JsonElement que se puede utilizar como punto inicial:Here is a sample usage of the JsonDocument and JsonElement that can be used as a starting point:

public static void ReadJson(string jsonString)
{
    using var document = JsonDocument.Parse(jsonString);

    var root = document.RootElement;
    var version = root.GetProperty("version").GetString();
    var configurations = root.GetProperty("configurations");

    Console.WriteLine($"Launch Version: {version}");

    foreach (var config in configurations.EnumerateArray())
    {
        var name = config.GetProperty("name").GetString();
        Console.WriteLine($"Config: {name}");
    }
}

Este es un ejemplo de lectura de C# 8.0 a través del archivo launch.json creado por Visual Studio Code:Here is a C# 8.0 example of reading through the launch.json file created by Visual Studio Code:

// Calling code
Console.WriteLine("Read with JsonDocument");
ReadJson(File.ReadAllText("launch.json"));

JsonSerializerJsonSerializer

System.Text.Json.JsonSerializer se compila sobre Utf8JsonReader y Utf8JsonWriter para proporcionar una rápida opción de serialización de memoria baja cuando se trabaja con documentos y fragmentos de JSON.System.Text.Json.JsonSerializer is built on top of Utf8JsonReader and Utf8JsonWriter to provide a fast, low-memory serialization option when working with JSON documents and fragments.

Este es un ejemplo de serialización de un objeto en JSON:Here is an example of serializing an object to JSON:

var instance = new
{
    FirstName = "John",
    LastName = "Smith",
    Age = 18
};

System.Console.WriteLine(System.Text.Json.JsonSerializer.Serialize(instance));

Este es un ejemplo de deserialización de una cadena JSON en un objeto.Here is an example of deserializing a JSON string to an object. Puede usar la cadena JSON generada en el ejemplo anterior:You can use the JSON string produced by the previous example:

public class JsonPerson
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public int Age { get; set; }

    public static JsonPerson Parse(string json) =>
        System.Text.Json.JsonSerializer.Deserialize<JsonPerson>(json);
}

Mejoras de interoperabilidadInterop improvements

.NET Core 3.0 mejora la interoperabilidad nativa de API..NET Core 3.0 improves native API interop.

Tipo: NativeLibraryType: NativeLibrary

System.Runtime.InteropServices.NativeLibrary ofrece una encapsulación para cargar una biblioteca nativa (con la misma lógica de carga que P/Invoke en .NET Core) y proporcionar funciones auxiliares relevantes, como getSymbol.System.Runtime.InteropServices.NativeLibrary provides an encapsulation for loading a native library (using the same load logic as .NET Core P/Invoke) and providing the relevant helper functions such as getSymbol. Para obtener un ejemplo de código, vea la demostración de DLLMap.For a code example, see the DLLMap 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.

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);

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.

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.

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.

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.