Novità di .NET Core 3.0What's new in .NET Core 3.0

Questo articolo descrive le novità di .NET Core 3,0.This article describes what is new in .NET Core 3.0. Uno dei principali miglioramenti è il supporto per le applicazioni desktop di Windows (solo Windows).One of the biggest enhancements is support for Windows desktop applications (Windows only). Con il componente Windows Desktop di .NET Core 3.0 SDK, è possibile convertire le applicazioni Windows Forms e WPF (Windows Presentation Foundation).By using the .NET Core 3.0 SDK component Windows Desktop, you can port your Windows Forms and Windows Presentation Foundation (WPF) applications. Il componente Windows Desktop è dunque supportato e incluso solo in Windows.To be clear, the Windows Desktop component is only supported and included on Windows. Per altre informazioni, vedere la sezione Desktop di Windows più avanti in questo articolo.For more information, see the Windows desktop section later in this article.

.NET Core 3.0 aggiunge il supporto per C# 8.0..NET Core 3.0 adds support for C# 8.0. È consigliabile usare Visual Studio 2019 versione 16,3 o successive, Visual Studio per Mac 8,3 o versioni successive o Visual Studio Code con l' C# estensionepiù recente.It's highly recommended that you use Visual Studio 2019 version 16.3 or newer, Visual Studio for Mac 8.3 or newer, or Visual Studio Code with the latest C# extension.

Scarica e inizia subito a usare .NET Core 3,0 in Windows, MacOS o Linux.Download and get started with .NET Core 3.0 right now on Windows, macOS, or Linux.

Per ulteriori informazioni sulla versione, vedere l' annuncio di .NET Core 3,0.For more information about the release, see the .NET Core 3.0 announcement.

.NET Core RC1 è stato considerato pronto per la produzione da Microsoft ed è stato completamente supportato..NET Core RC1 was considered production ready by Microsoft and was fully supported. Se si usa una versione di anteprima, è necessario passare alla versione RTM per il supporto continuo.If you're using a preview release, you must move to the RTM version for continued support.

Miglioramenti C# della lingua 8,0Language improvements C# 8.0

C#8,0 fa anche parte di questa versione, che include la funzionalità dei tipi di riferimento Nullable , i flussi asincronie altri modelli.C# 8.0 is also part of this release, which includes the nullable reference types feature, async streams, and more patterns. Per altre informazioni sulle funzionalità di C# 8.0, vedere Novità di C# 8.0.For more information about C# 8.0 features, see What's new in C# 8.0.

Sono stati aggiunti miglioramenti alla lingua per supportare le seguenti funzionalità API descritte di seguito:Language enhancements were added to support the following API features detailed below:

.NET Standard 2.1.NET Standard 2.1

.NET Core 3,0 implementa .NET Standard 2,1..NET Core 3.0 implements .NET Standard 2.1. Tuttavia, il modello di dotnet new classlib predefinito genera un progetto che è ancora destinato .NET Standard 2,0.However, the default dotnet new classlib template generates a project that still targets .NET Standard 2.0. Per destinarlo a .NET Standard 2.1, modificare il file di progetto e la proprietà TargetFramework in 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>

Se si usa Visual Studio, è necessario Visual Studio 2019 perché Visual Studio 2017 non supporta .NET Standard 2.1 o .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.

Compilazione/distribuzioneCompile/Deploy

File eseguibili predefinitiDefault executables

Per impostazione predefinita .NET Core ora compila file eseguibili dipendenti dal framework..NET Core now builds framework-dependent executables by default. Si tratta di una novità per le applicazioni che usano una versione di .NET Core installata a livello globale.This behavior is new for applications that use a globally installed version of .NET Core. In precedenza solo le distribuzioni autonome generavano un file eseguibile.Previously, only self-contained deployments would produce an executable.

Durante dotnet build o dotnet publish, viene creato un file eseguibile che corrisponde all'ambiente e alla piattaforma dell'SDK usato.During dotnet build or dotnet publish, an executable is created that matches the environment and platform of the SDK you're using. Il comportamento di questi file eseguibili è uguale a quello degli altri file eseguibili nativi, ad esempio:You can expect the same things with these executables as you would other native executables, such as:

  • È possibile fare doppio clic sul file eseguibile.You can double-click on the executable.
  • È possibile avviare l'applicazione direttamente da un prompt dei comandi, ad esempio myapp.exe in Windows e ./myapp in Linux e macOS.You can launch the application from a command prompt directly, such as myapp.exe on Windows, and ./myapp on Linux and macOS.

File eseguibili singoliSingle-file executables

Il comando dotnet publish supporta la creazione del pacchetto dell'app come file eseguibile singolo specifico per la piattaforma.The dotnet publish command supports packaging your app into a platform-specific single-file executable. Il file eseguibile è autoestraente e contiene tutte le dipendenze (incluse quelle native) necessarie per eseguire l'app.The executable is self-extracting and contains all dependencies (including native) that are required to run your app. Quando l'app viene eseguita per la prima volta, l'applicazione viene estratta in una directory in base al nome dell'app e all'identificatore di compilazione.When the app is first run, the application is extracted to a directory based on the app name and build identifier. L'avvio dell'applicazione sarà più veloce alla successiva esecuzione.Startup is faster when the application is run again. L'applicazione non dovrà ripetere l'estrazione una seconda volta, a meno che sia stata usata una nuova versione.The application doesn't need to extract itself a second time unless a new version was used.

Per pubblicare un file eseguibile singolo, impostare PublishSingleFile nel progetto o nella riga di comando usando il 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>

oppure-or-

dotnet publish -r win10-x64 -p:PublishSingleFile=true

Per altre informazioni sulla pubblicazione di file singolo, vedere il documento sulla progettazione di un bundler con file singolo.For more information about single-file publishing, see the single-file bundler design document.

Collegamento di assemblyAssembly linking

.NET Core SDK 3.0 include uno strumento che consente di ridurre le dimensioni delle app analizzando il linguaggio intermedio (IL) e rimuovendo gli assembly inutilizzati.The .NET core 3.0 SDK comes with a tool that can reduce the size of apps by analyzing IL and trimming unused assemblies.

Le app autonome includono tutti gli elementi necessari per eseguire il codice, senza richiedere l'installazione di .NET nel computer host.Self-contained apps include everything needed to run your code, without requiring .NET to be installed on the host computer. Tuttavia, per il funzionamento dell'app è spesso sufficiente un piccolo subset del framework, mentre altre librerie inutilizzate possono essere rimosse.However, many times the app only requires a small subset of the framework to function, and other unused libraries could be removed.

.NET Core include ora un'impostazione che consente l'uso dello strumento IL Linker per analizzare il linguaggio intermedio dell'app..NET Core now includes a setting that will use the IL linker tool to scan the IL of your app. Questo strumento rileva il codice necessario e quindi Elimina le librerie inutilizzate.This tool detects what code is required, and then trims unused libraries. Può quindi ridurre notevolmente le dimensioni di distribuzione di alcune app.This tool can significantly reduce the deployment size of some apps.

Per abilitare questo strumento, aggiungere l'impostazione <PublishTrimmed> nel progetto e pubblicare un'app autonoma: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

Ad esempio, il nuovo modello predefinito per un progetto di console di base "hello world" ha una dimensione di circa 70 MB quando viene pubblicato.As an example, the basic "hello world" new console project template that is included, when published, hits about 70 MB in size. Usando <PublishTrimmed> la dimensione viene ridotta fino a circa 30 MB.By using <PublishTrimmed>, that size is reduced to about 30 MB.

È importante tenere presente che le applicazioni o i framework, inclusi ASP.NET Core e WPF, che usano la reflection o le funzionalità dinamiche correlate, sono spesso soggetti a interruzioni in caso di rimozione di assembly.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. Le interruzioni si verificano perché il linker non riconosce questo comportamento dinamico e non è in grado di identificare i tipi di framework necessari per la reflection.This breakage occurs because the linker doesn't know about this dynamic behavior and can't determine which framework types are required for reflection. Lo strumento IL Linker può essere configurato in modo da riconoscere questo scenario.The IL Linker tool can be configured to be aware of this scenario.

È importante soprattutto accertarsi di testare l'app dopo la rimozione degli assembly inutilizzati.Above all else, be sure to test your app after trimming.

Per altre informazioni sullo strumento IL Linker, vedere la documentazione o visitare il repository mono/linker.For more information about the IL Linker tool, see the documentation or visit the mono/linker repo.

Compilazione a livelliTiered compilation

Per impostazione predefinita, con .NET Core 3.0 la compilazione a livelli è attiva.Tiered compilation (TC) is on by default with .NET Core 3.0. Questa funzionalità consente al runtime di usare in modo più adattivo il compilatore JIT per ottenere prestazioni migliori.This feature enables the runtime to more adaptively use the Just-In-Time (JIT) compiler to get better performance.

Il vantaggio principale della compilazione a livelli (TC) consiste nell'abilitazione di metodi di ricompilazione JIT con un livello lower-quality-but-faster (di minore qualità ma più veloce) o higher-quality-but-slower (di migliore qualità ma più 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. In questo modo è possibile migliorare le prestazioni di un'applicazione nelle sue vari fasi di esecuzione, dall'avvio allo stato stabile.This helps increase performance of an application as it goes through various stages of execution, from startup through steady-state. Ciò si differenzia dall'approccio che non usa la compilazione a livelli. In questo caso ogni metodo viene compilato in un solo modo (come per il livello alta qualità), che dà priorità allo stato stabile piuttosto che alle prestazioni all'avvio.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.

Quando TC è abilitato, durante l'avvio di un metodo denominato:When TC is enabled, during startup for a method that is called:

  • Se il metodo dispone di codice con compilazione AOT (ReadyToRun), verrà utilizzato il codice pregenerato.If the method has AOT-compiled code (ReadyToRun), the pregenerated code will be used.
  • In caso contrario, il metodo sarà compilato JIT.Otherwise, the method will be jitted. In genere, questi metodi sono attualmente generici sui tipi di valore.Typically, these methods currently are generics over value types.
    • JIT rapido produce codice di qualità inferiore più rapidamente.Quick JIT produces lower-quality code more quickly. JIT rapido è abilitato per impostazione predefinita in .NET Core 3,0 per i metodi che non contengono cicli ed è preferibile durante l'avvio.Quick JIT is enabled by default in .NET Core 3.0 for methods that do not contain loops and is preferred during startup.
    • Il JIT con ottimizzazione completa produce un codice di qualità superiore più lentamente.The fully-optimizing JIT produces higher-quality code more slowly. Per i metodi in cui non è possibile usare JIT rapido (ad esempio, se il metodo è attribuito a [MethodImpl(MethodImplOptions.AggressiveOptimization)]), viene usato l'ottimizzazione JIT completa.For methods where Quick JIT would not be used (for example, if the method is attributed with [MethodImpl(MethodImplOptions.AggressiveOptimization)]), the fully-optimizing JIT is used.

Infine, dopo che i metodi sono stati chiamati un numero di volte, vengono ricompilato JIT con la JIT completamente ottimizzata in background.Eventually, after methods are called a number of times, they are re-jitted with the fully-optimizing JIT in the background.

Il codice generato da Quick JIT può essere eseguito più lentamente, allocare più memoria o usare più spazio dello stack.Code generated by Quick JIT may run slower, allocate more memory, or use more stack space. Se si verificano problemi, è possibile disabilitare Quick JIT usando questa impostazione nel file di progetto:If there are issues, Quick JIT may be disabled using this setting in your project file:

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

Per disabilitare completamente la compilazione a livelli, usare questa impostazione nel file di progetto:To disable TC completely, use this setting in your project file:

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

Tutte le modifiche apportate alle impostazioni precedenti nel file di progetto possono richiedere la reflection di una compilazione pulita (eliminare le directory obj e bin e ricompilare).Any changes to the above settings in the project file may require a clean build to be reflected (delete the obj and bin directories and rebuild).

Immagini ReadyToRunReadyToRun images

È possibile migliorare il tempo di avvio delle applicazioni .NET Core compilando gli assembly nel formato ReadyToRun (R2R).You can improve the startup time of your .NET Core application by compiling your application assemblies as ReadyToRun (R2R) format. R2R è un formato di compilazione AOT (Ahead-of-time).R2R is a form of ahead-of-time (AOT) compilation.

I file binari R2R migliorano le prestazioni di avvio riducendo la quantità di lavoro che deve eseguire il compilatore JIT (Just-in-time) durante il caricamento dell'applicazione.R2R binaries improve startup performance by reducing the amount of work the just-in-time (JIT) compiler needs to do as your application loads. I file binari contengono codice nativo simile a ciò che viene generato dal compilatore JIT.The binaries contain similar native code compared to what the JIT would produce. I file binari R2R, tuttavia, sono più grandi poiché contengono sia il codice in linguaggio intermedio, che è comunque necessario per alcuni scenari, sia la versione nativa dello stesso codice.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 è disponibile solo quando si pubblica un'app autonoma che fa riferimento ad ambienti di runtime specifici (RID), ad esempio 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.

Per compilare il progetto come ReadyToRun, seguire questa procedura:To compile your project as ReadyToRun, do the following:

  1. Aggiungere l'impostazione <PublishReadyToRun> al progetto:Add the <PublishReadyToRun> setting to your project:

    <PropertyGroup>
      <PublishReadyToRun>true</PublishReadyToRun>
    </PropertyGroup>
    
  2. Pubblicare un'app autonoma.Publish a self-contained app. Questo comando, ad esempio, crea un'app autonoma per la versione a 64 bit di 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
    

Limitazioni per ambienti con più piattaforme o architettureCross platform/architecture restrictions

Il compilatore ReadyToRun attualmente non supporta la definizione di più destinazioni.The ReadyToRun compiler doesn't currently support cross-targeting. La compilazione deve essere eseguita per una determinata destinazione.You must compile on a given target. Se, ad esempio, si vogliono immagini R2R per Windows x64, è necessario eseguire il comando di pubblicazione in tale ambiente.For example, if you want R2R images for Windows x64, you need to run the publish command on that environment.

Eccezioni relative all'uso di più destinazioni:Exceptions to cross-targeting:

  • Windows x64 può essere usato per compilare immagini Windows ARM32, ARM64 e x86.Windows x64 can be used to compile Windows ARM32, ARM64, and x86 images.
  • Windows x86 può essere usato per compilare immagini Windows ARM32.Windows x86 can be used to compile Windows ARM32 images.
  • Linux x64 può essere usato per compilare immagini Linux ARM32 e ARM64.Linux x64 can be used to compile Linux ARM32 and ARM64 images.

Runtime/SDKRuntime/SDK

Roll forward alla versione principaleMajor-version Roll Forward

.NET core 3.0 introduce una funzionalità con consenso esplicito che consente all'app di eseguire il roll forward alla versione principale più recente di 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. È stata aggiunta anche una nuova impostazione per controllare come applicare il roll forward all'app.Additionally, a new setting has been added to control how roll forward is applied to your app. Questa funzionalità può essere configurata nei modi seguenti:This can be configured in the following ways:

  • Proprietà file di progetto: RollForwardProject file property: RollForward
  • Proprietà file di configurazione runtime: rollForwardRuntime configuration file property: rollForward
  • Variabile di ambiente: DOTNET_ROLL_FORWARDEnvironment variable: DOTNET_ROLL_FORWARD
  • Argomento della riga di comando: --roll-forwardCommand-line argument: --roll-forward

È necessario specificare uno dei valori seguenti.One of the following values must be specified. Se non viene impostato un valore, l'impostazione Minor sarà quella predefinita.If the setting is omitted, Minor is the default.

  • LatestPatchLatestPatch
    Esegue il roll forward alla versione di patch più recente.Roll forward to the highest patch version. Disabilita il roll forward della versione secondaria.This disables minor version roll forward.
  • MinorMinor
    Esegue il roll forward alla versione secondaria successiva minima, se la versione secondaria richiesta non esiste.Roll forward to the lowest higher minor version, if requested minor version is missing. Se la versione secondaria richiesta è presente, viene usato il criterio LatestPatch.If the requested minor version is present, then the LatestPatch policy is used.
  • MajorMajor
    Esegue il roll forward alla versione principale successiva minima e alla versione secondaria minima, se la versione principale richiesta non esiste.Roll forward to lowest higher major version, and lowest minor version, if requested major version is missing. Se la versione principale richiesta è presente, viene usato il criterio Minor.If the requested major version is present, then the Minor policy is used.
  • LatestMinorLatestMinor
    Esegue il roll forward alla versione secondaria più recente, anche se la versione secondaria richiesta è presente.Roll forward to highest minor version, even if requested minor version is present. È destinata a scenari di hosting dei componenti.Intended for component hosting scenarios.
  • LatestMajorLatestMajor
    Esegue il roll forward alla versione principale e secondaria più recente, anche se la versione principale richiesta è presente.Roll forward to highest major and highest minor version, even if requested major is present. È destinata a scenari di hosting dei componenti.Intended for component hosting scenarios.
  • DisableDisable
    Non esegue il roll forward.Don't roll forward. Esegue solo un'associazione alla versione specificata.Only bind to specified version. Non è consigliato usare questo criterio per scopi generali poiché disabilita la possibilità di eseguire il roll forward alle patch più recenti.This policy isn't recommended for general use because it disables the ability to roll forward to the latest patches. Questo valore è consigliato solo a scopo di test.This value is only recommended for testing.

Ad eccezione dell'impostazione Disable, tutte le impostazioni useranno la versione di patch disponibile più recente.Besides the Disable setting, all settings will use the highest available patch version.

Copia delle dipendenze tramite la compilazioneBuild copies dependencies

Il comando dotnet build ora copia le dipendenze NuGet per l'applicazione dalla cache NuGet nella cartella di output per la compilazione.The dotnet build command now copies NuGet dependencies for your application from the NuGet cache to the build output folder. In precedenza, le dipendenze venivano copiate solo come parte di dotnet publish.Previously, dependencies were only copied as part of dotnet publish.

Esistono alcune operazioni, ad esempio il collegamento e la pubblicazione della pagina razor per cui sarà comunque necessaria la pubblicazione.There are some operations, like linking and razor page publishing that will still require publishing.

Strumenti localiLocal tools

.NET core 3.0 introduce gli strumenti locali..NET Core 3.0 introduces local tools. Gli strumenti locali sono simili agli strumenti globali, ma sono associati a una determinata posizione sul disco.Local tools are similar to global tools but are associated with a particular location on disk. Gli strumenti locali non sono disponibili a livello globale e vengono distribuiti come pacchetti NuGet.Local tools aren't available globally and are distributed as NuGet packages.

Avviso

Se è stata eseguita una prova degli strumenti locali in .NET Core 3.0 Preview 1, ad esempio eseguendo dotnet tool restore o dotnet tool install, eliminare la cartella della cache degli strumenti locali.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. In caso contrario, gli strumenti locali non funzioneranno in una versione più recente.Otherwise, local tools won't work on any newer release. Questa cartella si trova in:This folder is located at:

In macOS: Linux: rm -r $HOME/.dotnet/toolResolverCacheOn macOS, Linux: rm -r $HOME/.dotnet/toolResolverCache

In Windows: rmdir /s %USERPROFILE%\.dotnet\toolResolverCacheOn Windows: rmdir /s %USERPROFILE%\.dotnet\toolResolverCache

Gli strumenti locali si basano sul nome file manifesto dotnet-tools.json nella directory corrente.Local tools rely on a manifest file name dotnet-tools.json in your current directory. Questo file manifesto definisce gli strumenti che devono essere disponibili in tale cartella e relative sottocartelle.This manifest file defines the tools to be available at that folder and below. È possibile distribuire il file manifesto con il codice per assicurarsi che tutti gli utenti che usano il codice possano ripristinare e usare gli stessi strumenti.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.

Per gli strumenti sia locali che globali, è necessaria una versione compatibile del runtime.For both global and local tools, a compatible version of the runtime is required. Molti strumenti attualmente presenti su NuGet.org hanno come destinazione .NET Core Runtime 2.1.Many tools currently on NuGet.org target .NET Core Runtime 2.1. Per installare questi strumenti a livello globale o locale, è comunque necessario installare il runtime di NET Core 2.1.To install these tools globally or locally, you would still need to install the NET Core 2.1 Runtime.

Riduzione delle dimensioni heap del Garbage CollectorSmaller Garbage Collection heap sizes

Le dimensioni heap predefinite del Garbage Collector sono state ridotte tanto che .NET Core usa ora meno memoria.The Garbage Collector's default heap size has been reduced resulting in .NET Core using less memory. Questa modifica consente un migliore allineamento del budget di allocazione di generazione 0 con le dimensioni della cache dei processori moderni.This change better aligns with the generation 0 allocation budget with modern processor cache sizes.

Supporto per pagine grandi in Garbage CollectionGarbage Collection Large Page support

Le pagine di grandi dimensioni, dette anche huge page in Linux, consentono al sistema operativo di creare aree di memoria più grandi rispetto alle dimensioni di pagina native (spesso 4K). In questo modo si migliorano le prestazioni dell'applicazione che richiede pagine di grandi dimensioni.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.

Il Garbage Collector può ora essere configurato con l'impostazione GCLargePages come funzionalità con consenso esplicito per scegliere di allocare le pagine di grandi dimensioni in 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.

Windows Desktop & COMWindows Desktop & COM

Programma di installazione .NET Core SDK per Windows.NET Core SDK Windows Installer

Il programma di installazione di Windows Installer (MSI) per Windows è stato modificato a partire da .NET Core 3.0.The MSI installer for Windows has changed starting with .NET Core 3.0. I programmi di installazione di SDK aggiorneranno ora le versioni della banda di funzionalità sul posto.The SDK installers will now upgrade SDK feature-band releases in place. Le bande di funzionalità vengono definite nei gruppi centinaia nella sezione patch del numero di versione.Feature bands are defined in the hundreds groups in the patch section of the version number. Ad esempio, 3.0.101 e 3.0.201 sono versioni in due diverse bande di funzionalità, mentre 3.0.101 e 3.0.199 appartengono alla stessa banda.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. Quindi, quando viene installato .NET Core SDK 3.0.101 , .NET Core SDK 3.0.100 verrà rimosso dal computer se è esistente.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. Quando viene installato .NET Core SDK 3.0.200 nello stesso computer, .NET Core SDK 3.0.101 non verrà rimosso.When .NET Core SDK 3.0.200 is installed on the same machine, .NET Core SDK 3.0.101 won't be removed.

Per altre informazioni sul controllo delle versioni, vedere Panoramica di come viene specificata la versione di .NET Core.For more information about versioning, see Overview of how .NET Core is versioned.

Desktop di WindowsWindows desktop

.NET Core 3.0 supporta applicazioni desktop di Windows che usano Windows Forms e WPF (Windows Presentation Foundation)..NET Core 3.0 supports Windows desktop applications using Windows Presentation Foundation (WPF) and Windows Forms. Questi framework supportano anche l'uso di controlli moderni e dello stile Fluent dalla libreria XAML dell'interfaccia utente di Windows tramite isole XAML.These frameworks also support using modern controls and Fluent styling from the Windows UI XAML Library (WinUI) via XAML islands.

Il componente Windows Desktop fa parte di Windows .NET Core 3.0 SDK.The Windows Desktop component is part of the Windows .NET Core 3.0 SDK.

È possibile creare una nuova app WPF o Windows Form con i comandi dotnet seguenti:You can create a new WPF or Windows Forms app with the following dotnet commands:

dotnet new wpf
dotnet new winforms

Visual Studio 2019 aggiunge modelli Nuovo progetto per .NET Core 3.0 Windows Forms e WPF.Visual Studio 2019 adds New Project templates for .NET Core 3.0 Windows Forms and WPF.

Per altre informazioni su come convertire un'applicazione .NET Framework esistente, vedere Convertire progetti WPF e Convertire progetti Windows Forms.For more information about how to port an existing .NET Framework application, see Port WPF projects and Port Windows Forms projects.

Modalità con valori DPI alti per WinFormsWinForms high DPI

Le applicazioni di Windows Forms in .NET Core possono impostare la modalità con valori DPI alti usando Application.SetHighDpiMode(HighDpiMode)..NET Core Windows Forms applications can set high DPI mode with Application.SetHighDpiMode(HighDpiMode). Il metodo SetHighDpiMode imposta la modalità con valori DPI alti corrispondente a meno che l'impostazione sia stata configurata in altro modo, ad esempio con App.Manifest o P/Invoke prima di 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.

I valori possibili per highDpiMode, espressi dall'enumerazione System.Windows.Forms.HighDpiMode, sono i seguenti:The possible highDpiMode values, as expressed by the System.Windows.Forms.HighDpiMode enum are:

  • DpiUnaware
  • SystemAware
  • PerMonitor
  • PerMonitorV2
  • DpiUnawareGdiScaled

Per altre informazioni sulle modalità con valori DPI alti, vedere Sviluppo di applicazioni desktop con valori DPI alti in Windows.For more information about high DPI modes, see High DPI Desktop Application Development on Windows.

Creazione di componenti COMCreate COM components

In Windows è ora possibile creare componenti gestiti COM-Callable.On Windows, you can now create COM-callable managed components. Questa funzionalità è essenziale per usare .NET Core con modelli del componente aggiuntivo COM e anche per assicurare parità 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 differenza di .NET Framework in cui mscoree.dll era usato come server COM, .NET Core aggiungerà un file dll di avvio nativo alla directory bin quando si compilerà il 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.

Per un esempio su come creare e usare un componente COM, vedere la demo COM.For an example of how to create a COM component and consume it, see the COM Demo.

Interoperabilità nativa di WindowsWindows Native Interop

Windows offre un'API nativa completa, sotto forma di API C semplici, COM e WinRT.Windows offers a rich native API in the form of flat C APIs, COM, and WinRT. Mentre .NET Core supporta P/Invoke, .NET Core 3.0 aggiunge la possibilità di generare contestualmente API COM e di attivare API WinRT.While .NET Core supports P/Invoke, .NET Core 3.0 adds the ability to CoCreate COM APIs and Activate WinRT APIs. Per un esempio di codice, vedere la demo Excel.For a code example, see the Excel Demo.

Distribuzione di MSIXMSIX Deployment

MSIX è un nuovo formato di pacchetto di applicazioni Windows.MSIX is a new Windows application package format. Può essere usato per distribuire applicazioni desktop di .NET Core 3.0 in Windows 10.It can be used to deploy .NET Core 3.0 desktop applications to Windows 10.

Il Progetto di creazione pacchetti di applicazione Windows, disponibile in Visual Studio 2019, consente di creare pacchetti MSIX con applicazioni .NET Core autonome.The Windows Application Packaging Project, available in Visual Studio 2019, allows you to create MSIX packages with self-contained .NET Core applications.

Il file di progetto .NET Core deve specificare i runtime supportati nella proprietà <RuntimeIdentifiers>:The .NET Core project file must specify the supported runtimes in the <RuntimeIdentifiers> property:

<RuntimeIdentifiers>win-x86;win-x64</RuntimeIdentifiers>

Miglioramenti per LinuxLinux improvements

SerialPort per LinuxSerialPort for Linux

.NET Core 3.0 include il supporto di base per System.IO.Ports.SerialPort in Linux..NET Core 3.0 provides basic support for System.IO.Ports.SerialPort on Linux.

In precedenza, .NET Core supportava solo l'uso di SerialPort in Windows.Previously, .NET Core only supported using SerialPort on Windows.

Per altre informazioni sul supporto limitato per la porta seriale in Linux, vedere il problema 33146 su GitHub.For more information about the limited support for the serial port on Linux, see GitHub issue #33146.

Docker e limiti di memoria cgroupDocker and cgroup memory Limits

L'esecuzione di .NET Core 3,0 in Linux con Docker funziona meglio con i limiti di memoria cgroup.Running .NET Core 3.0 on Linux with Docker works better with cgroup memory limits. Eseguendo un contenitore Docker con limiti di memoria, ad esempio docker run -m, il comportamento di .NET Core cambia.Running a Docker container with memory limits, such as with docker run -m, changes how .NET Core behaves.

  • Dimensioni heap predefinite del Garbage Collector: massimo 20 MB o il 75% del limite di memoria nel contenitore.Default Garbage Collector (GC) heap size: maximum of 20 mb or 75% of the memory limit on the container.
  • È possibile impostare dimensioni esplicite come numero assoluto o percentuale di un limite cgroup.Explicit size can be set as an absolute number or percentage of cgroup limit.
  • Le dimensioni minime del segmento riservato per ogni heap del Garbage Collection sono pari a 16 MB.Minimum reserved segment size per GC heap is 16 mb. Le dimensioni riducono il numero di heap creati nei computer.This size reduces the number of heaps that are created on machines.

Supporto di GPIO per Raspberry PiGPIO Support for Raspberry Pi

Sono stati rilasciati due pacchetti NuGet che è possibile usare per la programmazione GPIO:Two packages have been released to NuGet that you can use for GPIO programming:

I pacchetti GPIO includono le API per i dispositivi GPIO, SPI, I2C e PWM.The GPIO packages include APIs for GPIO, SPI, I2C, and PWM devices. Il pacchetto di binding IoT include i binding di dispositivi.The IoT bindings package includes device bindings. Per altre informazioni, vedere il repository GitHub dei dispositivi.For more information, see the devices GitHub repo.

Supporto ARM64 per LinuxARM64 Linux support

.NET Core 3.0 aggiunge il supporto per ARM64 per Linux..NET Core 3.0 adds support for ARM64 for Linux. Il caso d'uso principale per ARM64 è attualmente con gli scenari IoT.The primary use case for ARM64 is currently with IoT scenarios. Per altre informazioni, vedere .NET Core ARM64 Status (Stato di ARM64 per .NET Core).For more information, see .NET Core ARM64 Status.

Sono disponibili immagini Docker per .NET Core in ARM64 per Alpine, Debian e Ubuntu.Docker images for .NET Core on ARM64 are available for Alpine, Debian, and Ubuntu.

Nota

Il supporto ARM64 per Windows non è ancora disponibile.ARM64 Windows support isn't yet available.

Sicurezza -Security

TLS 1.3 e OpenSSL 1.1.1 in LinuxTLS 1.3 & OpenSSL 1.1.1 on Linux

.NET Core sfrutta ora il supporto di TLS 1.3 in OpenSSL 1.1.1, quando è disponibile in un determinato ambiente..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:

  • La durata della connessione è migliorata grazie alla riduzione del numero di round trip necessari tra il client e il server.Connection times are improved with reduced round trips required between the client and server.
  • La sicurezza è migliorata grazie alla rimozione di vari algoritmi di crittografia obsoleti e non sicuri.Improved security because of the removal of various obsolete and insecure cryptographic algorithms.

Quando è disponibile, .NET Core 3.0 usa OpenSSL 1.1.1, OpenSSL 1.1.0 o OpenSSL 1.0.2 in 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. Quando OpenSSL 1.1.1 è disponibile, entrambi i tipi System.Net.Security.SslStream e System.Net.Http.HttpClient useranno TLS 1.3, supponendo che sia il client sia il server supportino 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 e macOS non supportano ancora TLS 1.3.Windows and macOS do not yet support TLS 1.3. .NET Core 3.0 supporterà TLS 1.3 in questi sistemi operativi quando il supporto sarà disponibile..NET Core 3.0 will support TLS 1.3 on these operating systems when support becomes available.

L'esempio seguente di C# 8.0 illustra .NET Core 3.0 in Ubuntu 18.10 che si connette 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}");
        }
    }
}

CrittografiaCryptography ciphers

.NET 3.0 aggiunge supporto per le crittografie AES-GCM e AES-CCM implementate rispettivamente con System.Security.Cryptography.AesGcm e System.Security.Cryptography.AesCcm..NET 3.0 adds support for AES-GCM and AES-CCM ciphers, implemented with System.Security.Cryptography.AesGcm and System.Security.Cryptography.AesCcm respectively. Sono entrambi algoritmi di cifratura autenticata con dati di associazione.These algorithms are both Authenticated Encryption with Association Data (AEAD) algorithms.

Il codice seguente illustra l'uso della crittografia AesGcm per crittografare e decrittografare dati casuali.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.");
        }
    }
}

Importazione/Esportazione di chiavi crittograficheCryptographic Key Import/Export

.NET core 3.0 supporta l'importazione e l'esportazione di chiavi pubbliche e private asimmetriche da formati standard..NET Core 3.0 supports the import and export of asymmetric public and private keys from standard formats. Non è necessario usare un certificato X.509.You don't need to use an X.509 certificate.

Tutti i tipi di chiave, ad esempio RSA, DSA, ECDsa e ECDiffieHellman, supportano i formati seguenti:All key types, such as RSA, DSA, ECDsa, and ECDiffieHellman, support the following formats:

  • Chiave pubblicaPublic Key

    • X.509 SubjectPublicKeyInfoX.509 SubjectPublicKeyInfo
  • Chiave privataPrivate key

    • PKCS#8 PrivateKeyInfoPKCS#8 PrivateKeyInfo
    • PKCS#8 EncryptedPrivateKeyInfoPKCS#8 EncryptedPrivateKeyInfo

Le chiavi RSA supportano anche i tipi seguenti:RSA keys also support:

  • Chiave pubblicaPublic Key

    • PKCS#1 RSAPublicKeyPKCS#1 RSAPublicKey
  • Chiave privataPrivate key

    • PKCS#1 RSAPrivateKeyPKCS#1 RSAPrivateKey

I metodi di esportazione generano dati binari con codifica DER e i metodi di importazione prevedono lo stesso tipo di comportamento.The export methods produce DER-encoded binary data, and the import methods expect the same. Se una chiave viene archiviata nel formato PEM per il testo, il chiamante dovrà applicare la decodifica Base 64 al contenuto prima di chiamare un metodo di importazione.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));
        }
    }
}

I file PKCS#8 possono essere esaminati con la classe System.Security.Cryptography.Pkcs.Pkcs8PrivateKeyInfo e i file PFX/PKCS#12 possono essere esaminati con la classe 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. I file PFX/PKCS#12 possono essere modificati con la classe System.Security.Cryptography.Pkcs.Pkcs12Builder.PFX/PKCS#12 files can be manipulated with System.Security.Cryptography.Pkcs.Pkcs12Builder.

Modifiche all'API di .NET Core 3,0.NET Core 3.0 API changes

Gli intervalli e indiciRanges and indices

Il nuovo tipo System.Index può essere usato per l'indicizzazione.The new System.Index type can be used for indexing. È possibile crearne uno da int, che esegue il conteggio dall'inizio, o con un operatore prefisso ^ (C#), che esegue il conteggio dalla fine: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"

Esiste anche il tipo System.Range, costituito da due valori Index, uno per l'inizio e uno per la fine, e può essere scritto con un'espressione intervallo 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#). È anche possibile poi indicizzare usano un oggetto Range, che genera una sezione:You can then index with a Range, which produces a slice:

var slice = a[i1..i2]; // { 3, 4, 5 }

Per altre informazioni, vedere l'esercitazione su intervalli e indici.For more information, see the ranges and indices tutorial.

Flussi asincroniAsync streams

Il tipo IAsyncEnumerable<T> è una nuova versione asincrona di IEnumerable<T>.The IAsyncEnumerable<T> type is a new asynchronous version of IEnumerable<T>. Il linguaggio consente di usare await foreach su IAsyncEnumerable<T> per utilizzarne gli elementi e di usare yield return per generare gli elementi.The language lets you await foreach over IAsyncEnumerable<T> to consume their elements, and use yield return to them to produce elements.

L'esempio seguente illustra sia la produzione che l'utilizzo dei flussi asincroni.The following example demonstrates both production and consumption of async streams. L'istruzione foreach è asincrona e usa yield return per produrre un flusso asincrono per i chiamanti.The foreach statement is async and itself uses yield return to produce an async stream for callers. Questo modello (con yield return) è quello consigliato per la produzione di flussi asincroni.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;
    }
}

Oltre a poter usare await foreach, è anche possibile creare iteratori asincroni, ad esempio un iteratore che restituisce IAsyncEnumerable/IAsyncEnumerator in cui è possibile usare sia await che 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. Per gli oggetti che devono essere eliminati, è possibile usare IAsyncDisposable, implementato da diversi tipi BCL, ad esempio Stream e Timer.For objects that need to be disposed, you can use IAsyncDisposable, which various BCL types implement, such as Stream and Timer.

Per altre informazioni, vedere l'esercitazione sui flussi asincroni.For more information, see the async streams tutorial.

Virgola mobile IEEEIEEE Floating-point

È in corso l'aggiornamento di API virgola mobile per conformità alla revisione IEEE 754-2008.Floating point APIs are being updated to comply with IEEE 754-2008 revision. L'obiettivo di queste modifiche consiste nell'esporre tutte le operazioni necessarie e garantire che siano conformi alla specifica IEEE. Per altre informazioni sui miglioramenti a virgola mobile, vedere il post di Blog relativo all' analisi a virgola mobile e alla formattazione in .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.

Di seguito sono riportate le correzioni per analisi e formattazione:Parsing and formatting fixes include:

  • Analisi corretta e arrotondamento degli input di qualsiasi lunghezza.Correctly parse and round inputs of any length.
  • Analisi corretta e formattazione dello zero negativo.Correctly parse and format negative zero.
  • Analisi corretta di valori Infinity e NaN con l'esecuzione di un controllo senza distinzione tra maiuscole e minuscole e consentendo un + precedente facoltativo, ove applicabile.Correctly parse Infinity and NaN by doing a case-insensitive check and allowing an optional preceding + where applicable.

Le nuovi API System.Math includono gli elementi seguenti:New System.Math APIs include:

  • BitIncrement(Double) e BitDecrement(Double)BitIncrement(Double) and BitDecrement(Double)
    Corrispondono alle operazioni IEEE nextUp e nextDown.Corresponds to the nextUp and nextDown IEEE operations. Restituiscono il numero a virgola mobile più piccolo che risulta maggiore o minore rispetto all'input (rispettivamente).They return the smallest floating-point number that compares greater or lesser than the input (respectively). Ad esempio, Math.BitIncrement(0.0) restituirebbe double.Epsilon.For example, Math.BitIncrement(0.0) would return double.Epsilon.

  • MaxMagnitude(Double, Double) e MinMagnitude(Double, Double)MaxMagnitude(Double, Double) and MinMagnitude(Double, Double)
    Corrispondono alle operazioni IEEE maxNumMag e minNumMag e restituiscono il valore maggiore o minore in termini di grandezza dei due input (rispettivamente).Corresponds to the maxNumMag and minNumMag IEEE operations, they return the value that is greater or lesser in magnitude of the two inputs (respectively). Ad esempio, Math.MaxMagnitude(2.0, -3.0) restituirebbe -3.0.For example, Math.MaxMagnitude(2.0, -3.0) would return -3.0.

  • ILogB(Double)
    Corrispondono all'operazione IEEE logB che restituisce un valore integrale, restituisce il logaritmo in base 2 integrale del parametro di input.Corresponds to the logB IEEE operation that returns an integral value, it returns the integral base-2 log of the input parameter. Questo metodo equivale in effetti a floor(log2(x)), ma con errori minimi di arrotondamento.This method is effectively the same as floor(log2(x)), but done with minimal rounding error.

  • ScaleB(Double, Int32)
    Corrisponde all'operazione IEEE scaleB che accetta un valore integrale, restituisce in effetti x * pow(2, n), ma con errori minimi di arrotondamento.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)
    Corrisponde all'operazione IEEE log2 e restituisce il logaritmo in base 2.Corresponds to the log2 IEEE operation, it returns the base-2 logarithm. Gli errori di arrotondamento sono ridotti al minimo.It minimizes rounding error.

  • FusedMultiplyAdd(Double, Double, Double)
    Corrisponde all'operazione IEEE fma ed esegue un'operazione FMA (Fused Multiply-Add).Corresponds to the fma IEEE operation, it performs a fused multiply add. Vale a dire, esegue (x * y) + z come una singola operazione, riducendo così al minimo gli errori di arrotondamento.That is, it does (x * y) + z as a single operation, thereby minimizing the rounding error. Un esempio è FusedMultiplyAdd(1e308, 2.0, -1e308) che restituisce 1e308.An example would be FusedMultiplyAdd(1e308, 2.0, -1e308) which returns 1e308. L'operazione normale (1e308 * 2.0) - 1e308 restituisce double.PositiveInfinity.The regular (1e308 * 2.0) - 1e308 returns double.PositiveInfinity.

  • CopySign(Double, Double)
    Corrisponde all'operazione IEEE copySign e restituisce il valore di x, ma con il segno di y.Corresponds to the copySign IEEE operation, it returns the value of x, but with the sign of y.

Intrinseci dipendenti dalla piattaforma .NET.NET Platform-Dependent Intrinsics

Sono state aggiunte API che consentono l'accesso a determinate istruzioni CPU orientate alle prestazioni, ad esempio i set di istruzioni SIMD oppure di istruzioni di manipolazione dei bit.APIs have been added that allow access to certain perf-oriented CPU instructions, such as the SIMD or Bit Manipulation instruction sets. Queste istruzioni consentono di ottenere miglioramenti delle prestazioni significativi in determinati scenari, ad esempio l'elaborazione dei dati in modo efficiente in parallelo.These instructions can help achieve significant performance improvements in certain scenarios, such as processing data efficiently in parallel.

Ove appropriato, le librerie .NET hanno iniziato a usare queste istruzioni per migliorare le prestazioni.Where appropriate, the .NET libraries have begun using these instructions to improve performance.

Per altre informazioni, vedere .NET Platform Dependent Intrinsics (Intrinseci dipendenti dalla piattaforma .NET).For more information, see .NET Platform Dependent Intrinsics.

Miglioramento delle API della versione .NET CoreImproved .NET Core Version APIs

A partire da .NET Core 3.0, le API della versione di .NET Core restituiscono le informazioni previste.Starting with .NET Core 3.0, the version APIs provided with .NET Core now return the information you expect. Ad esempio:For example:

System.Console.WriteLine($"Environment.Version: {System.Environment.Version}");

// Old result
//   Environment.Version: 4.0.30319.42000
//
// New result
//   Environment.Version: 3.0.0
System.Console.WriteLine($"RuntimeInformation.FrameworkDescription: {System.Runtime.InteropServices.RuntimeInformation.FrameworkDescription}");

// Old result
//   RuntimeInformation.FrameworkDescription: .NET Core 4.6.27415.71
//
// New result (notice the value includes any preview release information)
//   RuntimeInformation.FrameworkDescription: .NET Core 3.0.0-preview4-27615-11

Avviso

Modifica importante:Breaking change. si tratta di una modifica tecnicamente importante perché è cambiato lo schema di controllo delle versioni.This is technically a breaking change because the versioning scheme has changed.

Supporto JSON predefinito rapidoFast built-in JSON support

Gli utenti .NET si sono ampiamente basati su Json.NET e altre librerie JSON molto diffuse, che rimangono sempre scelte valide..NET users have largely relied on Json.NET and other popular JSON libraries, which continue to be good choices. Come tipo di dati di base, Json.NET usa le stringhe .NET, che in realtà sono UTF-16.Json.NET uses .NET strings as its base datatype, which is UTF-16 under the hood.

Il nuovo supporto JSON predefinito offre prestazioni elevate, bassa allocazione ed è basato su Span<byte>.The new built-in JSON support is high-performance, low allocation, and based on Span<byte>. Per altre informazioni sullo spazio dei nomi e sui tipi di System.Text.Json, vedere serializzazione JSON in .NET-Panoramica.For more information about the System.Text.Json namespace and types, see JSON serialization in .NET - overview. Per esercitazioni sugli scenari comuni di serializzazione JSON, vedere come serializzare e deserializzare JSON in .NET.For tutorials on common JSON serialization scenarios, see How to serialize and deserialize JSON in .NET.

Supporto per HTTP/2HTTP/2 support

Il tipo System.Net.Http.HttpClient supporta il protocollo HTTP/2.The System.Net.Http.HttpClient type supports the HTTP/2 protocol. Se HTTP/2 è abilitato, la versione del protocollo HTTP viene negoziata tramite TLS/ALPN e HTTP/2 viene usato solo in base alla decisione del server.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.

Il protocollo predefinito rimane HTTP/1.1, anche se HTTP/2 può essere abilitato in due modi diversi.The default protocol remains HTTP/1.1, but HTTP/2 can be enabled in two different ways. In primo luogo, è possibile impostare il messaggio di richiesta HTTP per usare 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);

In secondo luogo, è possibile modificare HttpClient in modo da usare HTTP/2 per impostazione predefinita: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);

Molto spesso, quando si sviluppa un'applicazione, si vuole usare una connessione non crittografata.Many times when you're developing an application, you want to use an unencrypted connection. Se si è a conoscenza del fatto che l'endpoint di destinazione userà HTTP/2, è possibile attivare connessioni non crittografate per HTTP/2.If you know the target endpoint will be using HTTP/2, you can turn on unencrypted connections for HTTP/2. Per attivare queste connessioni è possibile impostare la variabile di ambiente DOTNET_SYSTEM_NET_HTTP_SOCKETSHTTPHANDLER_HTTP2UNENCRYPTEDSUPPORT su 1 o abilitarla nel contesto dell'app: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);

Passaggi successiviNext steps