Novedades de las bibliotecas de .NET para .NET 11

En este artículo se describen las nuevas características de las bibliotecas de .NET para .NET 11. Se actualizó por última vez para la versión preliminar 3.

Mejoras de cadenas y caracteres

.NET 11 presenta mejoras significativas en las API de manipulación de cadenas y caracteres, lo que facilita el trabajo con caracteres Unicode y runes.

Soporte para rune en métodos String

La String clase ahora incluye métodos que aceptan Rune parámetros, lo que le permite buscar, reemplazar y manipular cadenas mediante valores escalares Unicode directamente. Estos nuevos métodos incluyen:

Muchos de estos métodos incluyen sobrecargas que aceptan un parámetro StringComparison para comparaciones culturalmente conscientes.

Char.Es igual con StringComparison

La Char estructura ahora incluye un Char.Equals(Char, StringComparison) método que acepta un StringComparison parámetro, permitiéndote comparar personajes usando comparaciones culturales o ordinales.

Compatibilidad con la runa en TextInfo

La TextInfo clase ahora proporciona TextInfo.ToLower(Rune) métodos TextInfo.ToUpper(Rune) que aceptan Rune parámetros, permitiéndote realizar conversiones de casos sobre valores escalares Unicode individuales.

Mejoras de codificación en Base64

.NET 11 agrega nuevas API y sobrecargas al tipo de Base64 existente, lo que proporciona compatibilidad completa con la codificación y descodificación de Base64. Estas adiciones ofrecen un rendimiento y flexibilidad mejorados en comparación con los métodos existentes.

Nuevas API de Base64

Las nuevas API admiten operaciones de codificación y descodificación con varios formatos de entrada y salida:

Estos métodos proporcionan métodos de conveniencia de alto nivel (que asignan y devuelven matrices o cadenas) y métodos basados en intervalos de bajo nivel (para escenarios de asignación cero).

Mejoras de compresión

.NET 11 incluye varias mejoras en las API de compresión.

Modos de acceso a elementos de archivos ZIP

La ZipArchiveEntry clase ahora admite la apertura de entradas con modos de acceso a archivos específicos a través de nuevas sobrecargas: ZipArchiveEntry.Open(FileAccess) y ZipArchiveEntry.OpenAsync(FileAccess, CancellationToken). Estas sobrecargas aceptan un FileAccess parámetro y permiten abrir entradas ZIP para acceso de lectura, escritura o lectura-escritura.

Además, una nueva CompressionMethod propiedad expone el método de compresión usado para una entrada a través de la ZipCompressionMethod enumeración , que incluye valores para Stored, Deflatey Deflate64.

Validación ZIP CRC32

A partir de la versión preliminar 3, ZipArchive valida la suma de comprobación CRC32 al leer entradas ZIP. Los archivos dañados o truncados que anteriormente pasaban sin errores ahora producen InvalidDataException, lo que le ayuda a detectar problemas de integridad de datos desde el principio.

Cambio de comportamiento de DeflateStream y GZipStream

Empezando en .NET 11, DeflateStream y GZipStream siempre escribe cabeceras y pies de página en el flujo de salida, incluso cuando no se escribe ningún dato. Esto garantiza que la salida sea una secuencia comprimida válida según las especificaciones Deflate y GZip.

Anteriormente, estos flujos no generaron ninguna salida si no se escribió ningún dato, lo que da lugar a un flujo de salida vacío. Este cambio garantiza la compatibilidad con herramientas que esperan flujos comprimidos con formato correcto.

Para más información, consulte cabeceras y pies de página de escritura DeflateStream y GZipStream para cargaútil vacía.

Compatibilidad con BFloat16 en BitConverter

La BitConverter clase ahora incluye métodos para convertir entre BFloat16 valores y matrices de bytes o representaciones de bits. Estos nuevos métodos incluyen:

BFloat16 (punto flotante del cerebro) es un formato de punto flotante de 16 bits que se usa normalmente en el aprendizaje automático y la computación científica.

Mejoras de colecciones

BitArray.PopCount

La BitArray clase ahora incluye un BitArray.PopCount() método que devuelve el número de bits establecidos a true en la matriz. Esto proporciona una manera eficaz de contar bits establecidos sin tener que recorrer manualmente la matriz.

Compatibilidad con IReadOnlySet en la serialización JSON

La JsonMetadataServices clase ahora incluye un JsonMetadataServices.CreateIReadOnlySetInfo método, lo que permite la compatibilidad con la serialización JSON para IReadOnlySet<T> las colecciones.

Constante de esquema de datos de URI

Se ha agregado una nueva Uri.UriSchemeData constante que representa el data: esquema URI. Esta constante proporciona una manera estandarizada de hacer referencia a los URI de datos.

Mejoras de atributos StringSyntax

La StringSyntaxAttribute clase ahora incluye constantes para lenguajes de programación comunes:

Estas constantes se pueden usar con el StringSyntax atributo para proporcionar una mejor compatibilidad con herramientas para literales de cadena que contienen código en estos lenguajes.

Mejoras de System.Text.Json

Recuperación de información de tipo genérico

Un patrón común al trabajar con metadatos del tipo System.Text.Json consiste en recuperar un JsonTypeInfo<T> de JsonSerializerOptions. Antes, tenías que hacer downcast manualmente desde el método no genérico GetTypeInfo(Type) . Los nuevos métodos genéricos JsonSerializerOptions.GetTypeInfo<T>()JsonSerializerOptions.TryGetTypeInfo<T>(JsonTypeInfo<T>) y métodos devuelven metadatos fuertemente tipados directamente, eliminando el cast.

JsonSerializerOptions options = new(JsonSerializerDefaults.Web);
options.MakeReadOnly();

// Before: manual downcast required
JsonTypeInfo<MyRecord> info1 = (JsonTypeInfo<MyRecord>)options.GetTypeInfo(typeof(MyRecord));

// After: generic method returns the right type directly
JsonTypeInfo<MyRecord> info2 = options.GetTypeInfo<MyRecord>();

// TryGetTypeInfo variant for cases where the type may not be registered
if (options.TryGetTypeInfo<MyRecord>(out JsonTypeInfo<MyRecord>? typeInfo))
{
    // Use typeInfo
    _ = typeInfo;
}

Esto es especialmente útil cuando se trabaja con escenarios de generación de origen, NativeAOT y serialización polimórfica en los que el acceso a metadatos de tipo es común.

Nombrar e ignorar los valores predeterminados

La versión preliminar 3 amplía las opciones de nombres y de exclusión disponibles en System.Text.Json.

  • JsonNamingPolicy.PascalCase: Una nueva política de nombres incorporada que convierte los nombres de propiedades a PascalCase. Se une a las políticas existentes de camelCase, snake_case y kebab-case.
  • Directiva de nomenclatura por miembro: el nuevo [JsonNamingPolicy] atributo le permite invalidar la directiva de nomenclatura en propiedades o campos individuales, lo que proporciona un control específico sin un convertidor personalizado.
  • Condiciones de omisión de nivel de tipo: la aplicación [JsonIgnore(Condition = ...)] en el nivel de clase o estructura establece el comportamiento de omitir predeterminado para todos los miembros, por lo que ya no es necesario repetir el atributo en cada propiedad que acepta valores NULL.
// Type-level JsonIgnore: all members use WhenWritingNull by default
// Per-member JsonNamingPolicy: EventName uses camelCase even though the
// serializer options use PascalCase
var options = new JsonSerializerOptions
{
    PropertyNamingPolicy = JsonNamingPolicy.PascalCase
};

var data = new EventData { EventName = "Launch", Notes = null };
string json = JsonSerializer.Serialize(data, options);
Console.WriteLine(json);
// {"eventName":"Launch"}  -- Notes omitted (null), EventName camel-cased

Compresión Zstandard

Las API de compresión Zstandard ahora forman parte del System.IO.Compression espacio de nombres, junto con DeflateStream, GZipStreamy BrotliStream. Si hace referencia al paquete de versión preliminar anterior, quite la referencia de paquete independiente:

-<PackageReference Include="System.IO.Compression.Zstandard" />

La superficie de la API permanece sin cambios por lo demás.

Selección de formato de archivo tar

New sobrecarga CreateFromDirectory y CreateFromDirectoryAsync acepta un TarEntryFormat parámetro, dándote control directo sobre el formato de archivo. Anteriormente, CreateFromDirectory siempre producía archivos Pax. Los nuevos sobrecargadores soportan los cuatro formatos tar — Pax, Ustar, GNU y V7 — para compatibilidad con herramientas y entornos específicos.

// Create a GNU format tar archive for Linux compatibility
TarFile.CreateFromDirectory("/source/dir", "/dest/archive.tar",
    includeBaseDirectory: true, format: TarEntryFormat.Gnu);

// Create a Ustar format archive for broader compatibility
using Stream outputStream = File.OpenWrite("/dest/ustar.tar");
TarFile.CreateFromDirectory("/source/dir", outputStream,
    includeBaseDirectory: false, format: TarEntryFormat.Ustar);

// Async version
CancellationToken cancellationToken = CancellationToken.None;
await TarFile.CreateFromDirectoryAsync("/source/dir", "/dest/archive.tar",
    includeBaseDirectory: true, format: TarEntryFormat.Pax,
    cancellationToken: cancellationToken);

Mejoras numéricas

Rendimiento de Matrix4x4

Matrix4x4.GetDeterminant() ahora usa una implementación vectorizada de SSE, lo que mejora el rendimiento aproximadamente 15%.

Mejoras de E/S de bajo nivel

Soporte para canalizaciones SafeFileHandle

SafeFileHandle obtiene dos nuevos miembros en la versión preliminar 3:

  • Type property: informa si un identificador representa un archivo, canalización, socket, directorio u otro objeto del sistema operativo, sin necesidad de código específico de la plataforma.
  • CreateAnonymousPipe método: Crea un par de handles anónimos conectados con comportamiento asíncrono independiente para cada extremo.
SafeFileHandle.CreateAnonymousPipe(
    out SafeFileHandle readEnd,
    out SafeFileHandle writeEnd,
    asyncRead: true,
    asyncWrite: false);

using (readEnd)
using (writeEnd)
{
    // SafeFileHandle.Type reports the kind of OS object the handle refers to
    Console.WriteLine(readEnd.Type);   // Pipe
    Console.WriteLine(writeEnd.Type);  // Pipe
}

Compatibilidad con canalizaciones de RandomAccess

RandomAccess.Read y RandomAccess.Write ahora trabajan con asas no buscables como tuberías, además de asas de archivo normales.

En Windows, Process ahora utiliza E/S superpuesta para stdout/stderr redirigido, lo que reduce el bloqueo de pools de hilos en aplicaciones con mucho proceso.

Mejoras de expresiones regulares

Opción de AnyNewLine

Una nueva RegexOptions marca, AnyNewLine, hace que ^, $ y . traten el conjunto completo de caracteres de nueva línea Unicode como terminadores de línea, no solo \n. Esto ayuda a analizar texto que combina Windows (\r\n), Unix (\n) y finales de línea específicos de Unicode (\u0085, \u2028, \u2029).

string text = "line1\r\nline2\u0085line3\u2028line4";

// RegexOptions.AnyNewLine makes ^, $, and . treat all Unicode newline
// sequences as line terminators, not just \n.
MatchCollection matches = Regex.Matches(
    text,
    @"^line\d$",
    RegexOptions.Multiline | RegexOptions.AnyNewLine);

Console.WriteLine(matches.Count); // 4

Consulte también

  • Last updated on