Novidades em bibliotecas de .NET para .NET 11

Este artigo descreve novos recursos nas bibliotecas de .NET para .NET 11. Foi atualizado pela última vez para a Versão Prévia 3.

Aprimoramentos em strings e caracteres

.NET 11 apresenta aprimoramentos significativos nas APIs de manipulação de caracteres e cadeia de caracteres, facilitando o trabalho com caracteres Unicode e runes.

Suporte ao Rune em métodos de cadeia de caracteres

A String classe agora inclui métodos que aceitam Rune parâmetros, permitindo que você pesquise, substitua e manipule cadeias de caracteres usando valores escalares Unicode diretamente. Estes novos métodos incluem:

Muitos desses métodos incluem sobrecargas que aceitam um StringComparison parâmetro para comparações com reconhecimento de cultura.

Char.Equals com StringComparison

O struct Char agora possui um método Char.Equals(Char, StringComparison) que aceita um parâmetro StringComparison, permitindo que você compare caracteres usando comparações ordinais ou com sensibilidade cultural.

Suporte a Rune no TextInfo

A TextInfo classe agora fornece TextInfo.ToLower(Rune) e TextInfo.ToUpper(Rune) métodos que aceitam Rune parâmetros, permitindo que você execute conversões de maiúsculas e minúsculas em valores escalares Unicode individuais.

Melhorias na codificação do Base64

.NET 11 adiciona novas APIs e sobrecargas ao tipo Base64 existente, fornecendo suporte abrangente para codificação e decodificação base64. Essas adições oferecem melhor desempenho e flexibilidade em comparação aos métodos existentes.

Novas APIs Base64

As novas APIs dão suporte a operações de codificação e decodificação com vários formatos de entrada e saída:

Eles fornecem métodos de conveniência de alto nível (que alocam e retornam matrizes ou cadeias de caracteres) e métodos baseados em intervalo de baixo nível (para cenários de alocação zero).

Aprimoramentos de compactação

.NET 11 inclui várias melhorias nas APIs de compactação.

Modos de acesso de entrada em arquivo ZIP

A ZipArchiveEntry classe agora dá suporte à abertura de entradas com modos de acesso a arquivos específicos por meio de novas sobrecargas: ZipArchiveEntry.Open(FileAccess) e ZipArchiveEntry.OpenAsync(FileAccess, CancellationToken). Essas sobrecargas aceitam um FileAccess parâmetro e permitem que você abra entradas ZIP para acesso de leitura, gravação ou leitura/gravação.

Além disso, uma nova CompressionMethod propriedade expõe o método de compactação usado para uma entrada por meio da ZipCompressionMethod enumeração, que inclui valores para Stored, Deflatee Deflate64.

Validação do ZIP CRC32

A partir da Versão Prévia 3, ZipArchive valida a soma de verificação CRC32 ao ler entradas ZIP. Arquivos corrompidos ou truncados que anteriormente passavam sem erros agora geram InvalidDataException, ajudando você a detectar problemas de integridade de dados antecipadamente.

Alteração do comportamento de DeflateStream e GZipStream

A partir do .NET 11, DeflateStream e GZipStream sempre gravam cabeçalhos de formato e rodapés no fluxo de saída, mesmo quando nenhum dado é gravado. Isso garante que a saída seja um fluxo compactado válido de acordo com as especificações Deflate e GZip.

Anteriormente, esses fluxos não produziram nenhuma saída se nenhum dado foi gravado, resultando em um fluxo de saída vazio. Essa alteração garante a compatibilidade com ferramentas que esperam fluxos compactados formatados corretamente.

Para obter mais informações, consulte Cabeçalhos e rodapés de gravação para payload vazio de DeflateStream e GZipStream.

Suporte ao BFloat16 no BitConverter

A BitConverter classe agora inclui métodos para converter entre BFloat16 valores e matrizes de bytes ou representações de bits. Estes novos métodos incluem:

BFloat16 (Brain Floating Point) é um formato de ponto flutuante de 16 bits que é comumente usado no aprendizado de máquina e na computação científica.

Melhorias de coleções

BitArray.PopCount

A BitArray classe agora inclui o método BitArray.PopCount() que retorna o número de bits ajustados para true na matriz. Isso fornece uma maneira eficiente de contar bits definidos sem iterar manualmente através do array.

Suporte a IReadOnlySet na serialização JSON

A JsonMetadataServices classe agora inclui um JsonMetadataServices.CreateIReadOnlySetInfo método, habilitando o suporte de serialização JSON para IReadOnlySet<T> coleções.

Constante de esquema de dados de URI

Uma nova Uri.UriSchemeData constante foi adicionada, representando o data: esquema de URI. Essa constante fornece uma maneira padronizada de referenciar URIs de dados.

Aprimoramentos do atributo StringSyntax

A StringSyntaxAttribute classe agora inclui constantes para linguagens de programação comuns:

Essas constantes podem ser usadas com o StringSyntax atributo para fornecer melhor suporte de ferramentas para literais de cadeia de caracteres que contêm código nesses idiomas.

Melhorias de System.Text.Json

Recuperação de informações de tipo genérico

Um padrão comum ao trabalhar com System.Text.Json tipo de metadados é obter um JsonTypeInfo<T> de JsonSerializerOptions. Antes, era necessário fazer manualmente o downcast do método não genérico GetTypeInfo(Type). Novos métodos genéricos JsonSerializerOptions.GetTypeInfo<T>() e JsonSerializerOptions.TryGetTypeInfo<T>(JsonTypeInfo<T>) retornam metadados fortemente tipados de maneira direta, eliminando o 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;
}

Isso é particularmente útil ao trabalhar com a geração de código, NativeAOT e em cenários de serialização polimórfica onde o acesso a metadados de tipo é comum.

Nomeando e ignorando os padrões predefinidos

A versão prévia 3 expande as opções de nomeação e de exclusão disponíveis em System.Text.Json.

  • JsonNamingPolicy.PascalCase: Uma nova política de nomenclatura integrada que converte nomes de propriedade em PascalCase. Ele adere às políticas existentes camelCase, snake_case e kebab-case.
  • Política de nomenclatura por membro: o novo [JsonNamingPolicy] atributo permite substituir a política de nomenclatura em propriedades ou campos individuais, oferecendo controle refinado sem um conversor personalizado.
  • Condições de ignorar no nível de tipo: aplicar [JsonIgnore(Condition = ...)] no nível de classe ou struct define o comportamento de ignorar padrão para todos os membros, portanto, você não precisa mais repetir o atributo em cada propriedade anulável.
// 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

Compactação Zstandard

As APIs de compactação Zstandard agora fazem parte do System.IO.Compression namespace, juntamente com DeflateStream, GZipStreame BrotliStream. Se você referenciou o pacote de prévia anterior, remova a referência separada ao pacote:

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

A superfície da API permanece inalterada.

Seleção de formato de arquivo tar

Novas sobrecargas em CreateFromDirectory e CreateFromDirectoryAsync aceitam um parâmetro TarEntryFormat, oferecendo controle direto sobre o formato de arquivo. Anteriormente, CreateFromDirectory sempre produzia arquivos Pax. As novas funcionalidades adicionais dão suporte a todos os quatro formatos tar (Pax, Ustar, GNU e V7) para compatibilidade com ferramentas e ambientes 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);

Aperfeiçoamentos numéricos

Desempenho de Matrix4x4

Matrix4x4.GetDeterminant() agora usa uma implementação vetorizada por SSE, melhorando o desempenho em aproximadamente 15%.

Melhorias de E/S de baixo nível

Suporte ao pipe SafeFileHandle

SafeFileHandle obtém dois novos membros na versão prévia 3:

  • Type propriedade: relata se um identificador representa um arquivo, pipe, soquete, diretório ou outro objeto do sistema operacional, sem a necessidade de código específico da plataforma.
  • CreateAnonymousPipe método: Cria um par de manipuladores de pipe anônimos conectados com comportamento assíncrono de forma independente para cada extremidade.
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
}

Suporte ao pipe RandomAccess

RandomAccess.Read e RandomAccess.Write agora funcionam com identificadores não buscáveis, como pipes, além dos identificadores de arquivo regulares.

No Windows, Process agora usa E/S sobreposta para stdout/stderr redirecionado, o que reduz o bloqueio de pool de threads em aplicativos com processos pesados.

Aprimoramentos de expressões regulares

Opção AnyNewLine

Um novo RegexOptions sinalizador, AnyNewLine, faz com que ^, $ e . tratem o conjunto completo de caracteres de nova linha Unicode como terminadores de linha, não apenas \n. Isso ajuda no processamento de texto que combina terminações de linha Windows (\r\n), Unix (\n) e específicas do 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 também

  • Last updated on