Novità delle librerie di .NET per .NET 11

Questo articolo descrive le nuove funzionalità nelle librerie di .NET per .NET 11. È stato aggiornato per l'ultima volta per l'anteprima 3.

Miglioramenti delle stringhe e dei caratteri

.NET 11 introduce miglioramenti significativi alle API di manipolazione di stringhe e caratteri, semplificando l'uso di caratteri e rune Unicode.

Supporto di Rune nei metodi String

La String classe include ora metodi che accettano Rune parametri, consentendo di cercare, sostituire e modificare le stringhe usando direttamente i valori scalari Unicode. Questi nuovi metodi includono:

Molti di questi metodi includono overload che accettano un StringComparison parametro per confronti che tengono conto delle impostazioni cultura.

Metodo Char.Equals con StringComparison

La Char struct ora include un Char.Equals(Char, StringComparison) metodo che accetta un StringComparison parametro, consentendo di confrontare i caratteri usando confronti ordinali o basati sulla cultura.

Supporto di Rune in TextInfo

La classe TextInfo ora fornisce i metodi TextInfo.ToLower(Rune) e TextInfo.ToUpper(Rune) che accettano parametri Rune, consentendo di eseguire conversioni di maiuscole/minuscole su singoli valori scalari Unicode.

Miglioramenti della codifica Base64

.NET 11 aggiunge nuove API e sovraccarichi al tipo Base64 esistente, fornendo supporto completo per la codifica e la decodifica in Base64. Queste aggiunte offrono prestazioni e flessibilità migliori rispetto ai metodi esistenti.

Nuove API Base64

Le nuove API supportano le operazioni di codifica e decodifica con vari formati di input e output:

Questi metodi forniscono metodi pratici di alto livello (che allocano e restituiscono matrici o stringhe) e metodi basati su intervalli di basso livello (per scenari di allocazione zero).

Miglioramenti della compressione

.NET 11 include diversi miglioramenti alle API di compressione.

Modalità di accesso agli elementi dell'archivio ZIP

La ZipArchiveEntry classe supporta ora l'apertura di voci con modalità di accesso ai file specifiche tramite nuovi overload: ZipArchiveEntry.Open(FileAccess) e ZipArchiveEntry.OpenAsync(FileAccess, CancellationToken). Queste sovraccarichi accettano un parametro FileAccess e consentono di aprire file ZIP per l'accesso di lettura, di scrittura o di lettura/scrittura.

Inoltre, una nuova CompressionMethod proprietà espone il metodo di compressione usato per un elemento tramite l'enumerazione ZipCompressionMethod, che include i valori per Stored, Deflate e Deflate64.

Validazione CRC32 di ZIP

A partire dalla versione Preview 3, ZipArchive convalida il checksum CRC32 durante la lettura delle voci ZIP. Gli archivi danneggiati o troncati passati in precedenza senza errori ora generano InvalidDataException, consentendo di rilevare tempestivamente i problemi di integrità dei dati.

Modifica del comportamento DeflateStream e GZipStream

A partire da .NET 11, DeflateStream e GZipStream scrivono sempre le intestazioni e i piè di pagina del formato nel flusso di output, anche quando non viene scritto alcun dato. In questo modo l'output è un flusso compresso valido in base alle specifiche Deflate e GZip.

In precedenza, questi flussi non producevano alcun output se non è stato scritto alcun dato, generando un flusso di output vuoto. Questa modifica garantisce la compatibilità con gli strumenti che prevedono flussi compressi formattati correttamente.

Per ulteriori informazioni, vedere DeflateStream e GZipStream scrivono intestazioni e piè di pagina per payload vuoti.

Supporto di BFloat16 in BitConverter

La BitConverter classe include ora metodi per la conversione tra BFloat16 valori e matrici di byte o rappresentazioni di bit. Questi nuovi metodi includono:

BFloat16 (Brain Floating Point) è un formato a virgola mobile a 16 bit comunemente usato nell'apprendimento automatico e nel calcolo scientifico.

Miglioramenti delle raccolte

BitArray.PopCount

La BitArray classe include ora un BitArray.PopCount() metodo che restituisce il numero di bit impostati su true nella matrice. In questo modo è possibile contare i bit impostati in modo efficiente senza scorrere manualmente la matrice.

Supporto di IReadOnlySet nella serializzazione JSON

La JsonMetadataServices classe include ora un JsonMetadataServices.CreateIReadOnlySetInfo metodo, abilitando il supporto della serializzazione JSON per IReadOnlySet<T> le raccolte.

Costante dello schema dati URI

È stata aggiunta una nuova Uri.UriSchemeData costante che rappresenta lo data: schema URI. Questa costante fornisce un modo standardizzato per fare riferimento agli URI dei dati.

Miglioramenti dell'attributo StringSyntax

La StringSyntaxAttribute classe include ora costanti per i linguaggi di programmazione comuni:

Queste costanti possono essere usate con l'attributo StringSyntax per fornire un migliore supporto degli strumenti per i valori letterali stringa contenenti codice in questi linguaggi.

Miglioramenti di System.Text.Json

Recupero informazioni tipo generico

Un modello comune quando si utilizzano System.Text.Json metadati di tipo consiste nel recuperare un JsonTypeInfo<T> da JsonSerializerOptions. In precedenza, era necessario eseguire manualmente il downcast dal metodo non generico GetTypeInfo(Type). I nuovi metodi generici JsonSerializerOptions.GetTypeInfo<T>() e JsonSerializerOptions.TryGetTypeInfo<T>(JsonTypeInfo<T>) restituiscono direttamente metadati fortemente tipizzati, eliminando il 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;
}

Ciò è particolarmente utile quando si lavora con gli scenari di generazione di origine, NativeAOT e serializzazione polimorfica in cui l'accesso ai metadati dei tipi è comune.

Denominare e ignorare impostazioni predefinite

Anteprima 3 espande le opzioni di denominazione e ignora disponibili in System.Text.Json:

  • JsonNamingPolicy.PascalCase: nuovo criterio di denominazione predefinito che converte i nomi delle proprietà in PascalCase. Unisce i criteri camelCase, snake_case e kebab-case esistenti.
  • Criterio di denominazione per membro: il nuovo [JsonNamingPolicy] attributo consente di eseguire l'override dei criteri di denominazione per singole proprietà o campi, offrendo un controllo con granularità fine senza un convertitore personalizzato.
  • Condizioni di ignorare a livello di tipo: l'applicazione [JsonIgnore(Condition = ...)] a livello di classe o struct imposta il comportamento di ignorare predefinito per tutti i membri, quindi non è più necessario ripetere l'attributo in ogni proprietà nullable.
// 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

Compressione Zstandard

Le API di compressione Zstandard fanno ora parte dello spazio dei nomi System.IO.Compression, insieme a DeflateStream, GZipStream e BrotliStream. Se si fa riferimento al pacchetto di anteprima precedente, rimuovere il riferimento al pacchetto separato:

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

La superficie dell'API è in caso contrario invariata.

Selezione del formato archivio Tar

Nuovi sovraccarichi su CreateFromDirectory e CreateFromDirectoryAsync accettano un parametro TarEntryFormat, offrendo il controllo diretto sul formato di archivio. In precedenza, CreateFromDirectory produceva sempre archivi Pax. I nuovi overload supportano tutti e quattro i formati tar( Pax, Ustar, GNU e V7) per la compatibilità con strumenti e ambienti specifici.

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

Miglioramenti numerici

Prestazioni Matrix4x4

Matrix4x4.GetDeterminant() ora usa un'implementazione con vettorizzazione SSE, migliorando le prestazioni di circa 15%.

Miglioramenti di I/O di basso livello

Supporto della pipe SafeFileHandle

SafeFileHandle ottiene due nuovi membri in Anteprima 3:

  • Type property: segnala se un handle rappresenta un file, una pipe, un socket, una directory o un altro oggetto del sistema operativo, senza richiedere codice specifico della piattaforma.
  • CreateAnonymousPipe Metodo: crea una coppia di handle di pipe anonimi connessi con un comportamento asincrono indipendente per ogni estremità.
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
}

Supporto della pipe di accesso casuale

RandomAccess.Read e RandomAccess.Write ora funzionano con handle non ricercabili, ad esempio pipe, oltre ai normali handle di file.

Su Windows, Process ora utilizza operazioni di I/O sovrapposte per stdout/stderr reindirizzati, riducendo il blocco del pool di thread nelle applicazioni ad alto utilizzo di processi.

Miglioramenti delle espressioni regolari

Opzione AnyNewLine

Un nuovo RegexOptions flag, AnyNewLine, rende ^, $e . considera il set completo di caratteri di nuova riga Unicode come caratteri di terminazione di riga, non solo \n. Ciò consente di analizzare il testo che combina Windows (\r\n), Unix (\n) e le terminazioni di riga specifiche di 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

Vedere anche

  • Last updated on