Novità di .NET Core 3.0 (Preview 2)What's new in .NET Core 3.0 (Preview 2)

Questo articolo descrive le novità di .NET Core 3.0 (Preview 2).This article describes what is new in .NET Core 3.0 (preview 2). 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). Utilizzando un componente di .NET Core 3.0 SDK denominato Windows Desktop, è possibile convertire le applicazioni Windows Forms e WPF (Windows Presentation Foundation).By utilizing a .NET Core 3.0 SDK component called 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 riportata di seguito.For more information, see the section Windows desktop below.

.NET Core 3.0 aggiunge il supporto per C# 8.0..NET Core 3.0 adds support for C# 8.0.

Scaricare e iniziare subito a usare .NET Core 3.0 Preview 2 in Windows, Mac e Linux.Download and get started with .NET Core 3.0 Preview 2 right now on Windows, Mac and Linux. È possibile visualizzare i dettagli completi della versione nelle note sulla versione di .NET Core 3.0 Preview 2.You can see complete details of the release in the .NET Core 3.0 Preview 2 release notes.

Per altre informazioni sulle funzionalità incluse in ogni versione, vedere gli annunci seguenti:For more information about what was released with each version, see the following announcements:

C# 8C# 8

.NET Core 3.0 supporta C# 8 e a partire da .NET Core 3.0 Preview 2 supporta queste nuove funzionalità..NET Core 3.0 supports C# 8, and as of .NET Core 3.0 Preview 2, supports these new features. Per altre informazioni sulle funzionalità di C# 8.0, vedere i post di blog seguenti:For more information about C# 8.0 features, see the following blog posts:

Gli intervalli e indiciRanges and indices

Il nuovo tipo Index può essere usato per l'indicizzazione.The new 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 un tipo Range, costituito da due valori Index, uno per l'inizio e uno per la fine, che può essere scritto con un'espressione intervallo x..y (C#).There is also a 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#). È quindi possibile eseguire l'indicizzazione con Range per generare una sezione:You can then index with a Range in order to produce a slice:

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

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.

Nota

È necessario .NET Core 3.0 Preview 2 per usare flussi asincroni se si vuole sviluppare con Visual Studio 2019 o con l'anteprima più recente dell'estensione C# per Visual Studio Code.You need .NET Core 3.0 Preview 2 to use async streams if you want to develop with either Visual Studio 2019 or the latest preview of the C# extension for Visual Studio Code. Se si usa .NET Core 3.0 Preview 2 dalla riga di comando, tutto funzionerà come previsto.If you are using .NET Core 3.0 Preview 2 at the command line, then everything will work as expected.

Dichiarazioni usingUsing Declarations

Le dichiarazioni using sono un nuovo modo per assicurarsi che l'oggetto venga eliminato correttamente.Using declarations are a new way to ensure your object is properly disposed. Una dichiarazione using mantiene attivo l'oggetto mentre è ancora nell'ambito.A using declaration keeps the object alive while it is still in scope. Quando l'oggetto diventa esterno all'ambito, viene eliminato automaticamente.Once the object becomes out of scope, it is automatically disposed. In questo modo si riducono le istruzioni using annidate e il codice diventa più chiaro.This will reduce nested using statements and make your code cleaner.

static void Main(string[] args)
{
    using var options = Parse(args);
    if (options["verbose"]) { WriteLine("Logging..."); }

} // options disposed here

Espressioni switchSwitch Expressions

Le espressioni switch sono un modo più pulito per eseguire un'istruzione switch ma, trattandosi di un'espressione, restituisce un valore.Switch expressions are a cleaner way of doing a switch statement but, since it's an expression, returns a value. Le espressioni switch sono anche completamente integrate con i criteri di ricerca e usano il criterio di rimozione _ per rappresentare il valore default.Switch expressions are also fully integrated with pattern matching, and use the discard pattern, _, to represent the default value.

È possibile visualizzare la sintassi per le espressioni switch nell'esempio seguente:You can see the syntax for switch expressions in the following example:

static string Display(object o) => o switch
{
    Point { X: 0, Y: 0 }         => "origin",
    Point { X: var x, Y: var y } => $"({x}, {y})",
    _                            => "unknown"
};

In questo esempio entrano in gioco due criteri.There are two patterns at play in this example. o corrisponde prima di tutto al criterio di tipo Point e poi al criterio di proprietà all'interno delle {parentesi graffe}.o first matches with the Point type pattern and then with the property pattern inside the {curly braces}. _ descrive discard pattern, uguale a default per le istruzioni switch.The _ describes the discard pattern, which is the same as default for switch statements.

I criteri consentono di scrivere codice dichiarativo che definisce la finalità anziché codice procedurale che implementa i test.Patterns enable you to write declarative code that captures your intent instead of procedural code that implements tests for it. Il compilatore diventa responsabile dell'implementazione di tale codice procedurale noioso e viene garantito che l'operazione sia sempre eseguita in modo corretto.The compiler becomes responsible for implementing that boring procedural code and is guaranteed to always do it correctly.

Esistono comunque casi in cui le istruzioni switch saranno preferibili rispetto alle espressioni switch e i criteri possono essere usati con entrambi gli stili di sintassi.There will still be cases where switch statements will be a better choice than switch expressions and patterns can be used with both syntax styles.

Per altre informazioni, vedere Do more with patterns in C# 8.0 (Nuove potenzialità con i modelli in C# 8.0).For more information, see Do more with patterns in C# 8.0.

Miglioramenti per le API a virgola mobile IEEEIEEE Floating-point improvements

Le API a virgola mobile sono in corso di aggiornamento per soddisfare i requisiti della revisione IEEE 754-2008.Floating point APIs are in the process of being updated to comply with IEEE 754-2008 revision. L'obiettivo di queste modifiche è esporre tutte le operazioni "obbligatorie" e assicurarsi che siano compatibili a livello di comportamento con la specifica IEEE.The goal of these changes is to expose all "required" operations and ensure that they are behaviorally compliant with the IEEE spec.

Correzioni per analisi e formattazione:Parsing and formatting fixes:

  • 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 performing a case-insensitive check and allowing an optional preceding + where applicable.

Le nuove API per operazioni matematiche:New Math APIs have:

  • BitIncrement/BitDecrement
    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/MinMagnitude
    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
    Corrispondono all'operazione IEEE logB che restituisce il logaritmo in base 2 integrale del parametro di input.Corresponds to the logB IEEE operation which returns an integral value, it returns the integral base-2 log of the input parameter. Equivale in effetti a floor(log2(x)), ma con errori minimi di arrotondamento.This is effectively the same as floor(log2(x)), but done with minimal rounding error.

  • ScaleB
    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 which takes an integral value, it returns effectively x * pow(2, n), but is done with minimal rounding error.

  • Log2
    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
    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, there-by 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
    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 notevoli in determinati scenari, ad esempio l'elaborazione dei dati in modo efficiente in parallelo.These instructions can help achieve big performance improvements in certain scenarios, such as processing data efficiently in parallel. Oltre a esporre le API per i programmi, le librerie .NET hanno iniziato a usare queste istruzioni per migliorare le prestazioni.In addition to exposing the APIs for your programs to use, the .NET libraries have begun using these instructions to improve performance.

Le richieste pull CoreCLR seguenti illustrano alcuni degli intrinseci, tramite implementazione o uso:The following CoreCLR PRs demonstrate a few of the intrinsics, either via implementation or use:

Per altre informazioni, vedere .NET Platform Dependent Intrinsics (Intrinseci dipendenti dalla piattaforma .NET), che definisce un approccio per la definizione di questa infrastruttura hardware, che consente a Microsoft, fornitori di chip o altre società o singoli di definire API per hardware/chip che devono essere esposte al codice .NET.For more information, see .NET Platform Dependent Intrinsics, which defines an approach for defining this hardware infrastructure, allowing Microsoft, chip vendors, or any other company or individual to define hardware/chip APIs that should be exposed to .NET code.

File eseguibili predefinitiDefault executables

Per impostazione predefinita .NET Core compilerà ora i file eseguibili dipendenti dal framework..NET Core will now build 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 is new for applications that use a globally installed version of .NET Core. Finora solo le distribuzioni autonome producevano un file eseguibile.Until now, only self-contained deployments would produce an executable.

Durante dotnet build o dotnet publish, viene creato un file eseguibile purché corrisponda all'ambiente e alla piattaforma dell'SDK usato.During dotnet build or dotnet publish, an executable is created provided that matches the environment and platform of the SDK you are 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.

Copia delle dipendenze tramite la compilazioneBuild copies dependencies

dotnet build ora copia le dipendenze NuGet per l'applicazione dalla cache NuGet alla cartella di output per la compilazione.dotnet build 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 dotnet localiLocal dotnet tools

Avviso

È stata introdotta una modifica per gli strumenti .NET Core locali tra .NET Core 3.0 Preview 1 e .NET Core 3.0 Preview 2.There was a change in .NET Core Local Tools between .NET Core 3.0 Preview 1 and .NET Core 3.0 Preview 2. Se sono stati provati gli strumenti locali nella versione Preview 1 eseguendo un comando come dotnet tool restore o dotnet tool install, è necessario eliminare la cartella della cache degli strumenti locali prima che gli strumenti locali funzionino correttamente nella versione Preview 2.If you tried out local tools in Preview 1 by running a command like dotnet tool restore or dotnet tool install, you need to delete your local tools cache folder before local tools will work correctly in Preview 2. Questa cartella si trova in:This folder is located at:

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

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

Se non si elimina questa cartella, si riceverà un errore.If you do not delete this folder, you will receive an error.

Mentre .NET Core 2.1 supportava strumenti globali, .NET Core 3.0 ha ora strumenti locali.While .NET Core 2.1 supported global tools, .NET Core 3.0 now has 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. Ciò consente di usare strumenti specifici per ogni progetto e ogni repository.This enables per-project and per-repository tooling. Gli strumenti installati in locale non sono disponibili a livello globale.Any tool installed locally isn't available globally. Gli strumenti vengono distribuiti come pacchetti NuGet.Tools are distributed as NuGet packages.

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. Creando questo file manifesto nella radice del repository, si ha la certezza che chiunque cloni il codice non possa ripristinare e usare gli strumenti necessari per lavorare in modo corretto con il codice.By creating this manifest file at the root of your repository, you ensure anyone cloning your code can restore and use the tools that are needed to successfully work with your code.

Per creare un file manifesto dotnet-tools.json, usare:To create a dotnet-tools.json manifest file, use:

dotnet new tool-manifest

Aggiungere un nuovo strumento al manifesto locale con:Add a new tool to the local manifest with:

dotnet tool install <packageId>

È anche possibile elencare gli strumenti nel manifesto locale con:You can also list the tools in the local manifest with:

dotnet tool list

Per vedere quali strumenti vengono installati a livello globale, usare:To see what tools are installed globally, use:

dotnet tool list -g

Quando il file manifesto degli strumenti locali è disponibile, ma gli strumenti definiti nel manifesto non sono stati installati, usare il comando seguente per scaricare e installare automaticamente tali strumenti in locale:When the local tools manifest file is available, but the tools defined in the manifest have not been installed, use the following command to automatically download and install those tools:

dotnet tool restore

Eseguire uno strumento locale con il comando seguente:Run a local tool with the following command:

dotnet tool run <tool-command-name>

Quando viene eseguito uno strumento locale, dotnet cerca un manifesto nella struttura di directory corrente.When a local tool is run, dotnet searches for a manifest up the current directory structure. Quando viene trovato un file manifesto degli strumenti, viene eseguita la ricerca dello strumento richiesto.When a tool manifest file is found, it is searched for the requested tool. Se lo strumento viene trovato nel manifesto, ma non la cache, l'utente riceve un errore e deve eseguire dotnet tool restore.If the tool is found in the manifest, but not the cache, the user receives an error and needs to run dotnet tool restore.

Per rimuovere uno strumento dal file manifesto dello strumento locale, eseguire il comando seguente:To remove a tool from the local tool manifest file, run the following command:

dotnet tool uninstall <packageId>

Il file manifesto dello strumento è progettato per consentire la modifica manuale, ad esempio per aggiornare la versione necessaria per usare il repository.The tool manifest file is designed to allow hand editing – which you might do to update the required version for working with the repository. Ecco un file dotnet-tools.json di esempio:Here is an example dotnet-tools.json file:

{
  "version": 1,
  "isRoot": true,
  "tools": {
    "dotnetsay": {
      "version": "2.1.4",
      "commands": [
        "dotnetsay"
      ]
    },
    "t-rex": {
      "version": "1.0.103",
      "commands": [
        "t-rex"
      ]
    }
  }
}

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 installarli a livello globale o locale, è ancora necessario installare il runtime di NET Core 2.1.To install those globally or locally, you would still need to install the NET Core 2.1 Runtime.

Desktop di WindowsWindows desktop

A partire da .NET Core 3.0 Preview 1, è possibile compilare applicazioni desktop di Windows con WPF e Windows Form.Starting with .NET Core 3.0 Preview 1, you can build Windows desktop applications using 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. Le finestre di progettazione non sono ancora supportate.Designers are still not yet supported. È possibile aprire, avviare ed eseguire il debug di questi progetti in Visual Studio 2019.And you can open, launch, and debug these projects in Visual Studio 2019.

Visual Studio 2017 15.9 aggiunge la possibilità di abilitare le anteprime di .NET Core, ma è necessario attivare questa funzionalità e non è uno scenario supportato.Visual Studio 2017 15.9 adds the ability to enable .NET Core previews, but you need to turn that feature on, and it's not a supported scenario.

I nuovi progetti sono uguali ai progetti .NET Core esistenti, con alcune aggiunte.The new projects are the same as existing .NET Core projects, with a couple additions. Di seguito è riportato il confronto tra il progetto console .NET Core di base e un progetto Windows Form e WPF di base.Here is the comparison of the basic .NET Core console project and a basic Windows Forms and WPF project.

In un progetto console .NET Core il progetto usa l'SDK Microsoft.NET.Sdk e dichiara una dipendenza da .NET Core 3.0 tramite il framework di destinazione netcoreapp3.0.In a .NET Core console project, the project uses the Microsoft.NET.Sdk SDK and declares a dependency on .NET Core 3.0 via the netcoreapp3.0 target framework. Per creare un'app desktop di Windows, usare l'SDK Microsoft.NET.Sdk.WindowsDesktop e scegliere quale framework interfaccia utente usare:To create a Windows Desktop app, use the Microsoft.NET.Sdk.WindowsDesktop SDK and choose which UI framework to use:

-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk.WindowsDesktop">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>netcoreapp3.0</TargetFramework>
+   <UseWPF>true</UseWPF>
  </PropertyGroup>
</Project>

Per scegliere Windows Form invece di WPF, impostare UseWindowsForms invece che UseWPF:To choose Windows Forms over WPF, set UseWindowsForms instead of UseWPF:

<Project Sdk="Microsoft.NET.Sdk.WindowsDesktop">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>netcoreapp3.0</TargetFramework>
-   <UseWPF>true</UseWPF>
+   <UseWindowsForms>true</UseWindowsForms>
  </PropertyGroup>
</Project>

Sia UseWPF che UseWindowsForms possono essere impostati su true se l'app usa entrambi i framework, ad esempio quando una finestra di dialogo di Windows Form ospita un controllo WPF.Both UseWPF and UseWindowsForms can be set to true if the app uses both frameworks, for example when a Windows Forms dialog is hosting a WPF control.

Condividere commenti e suggerimenti nei repository dotnet/winforms, dotnet/wpf e dotnet/core.Please share your feedback on the dotnet/winforms, dotnet/wpf and dotnet/core repos.

Distribuzione MSIX per Windows DesktopMSIX Deployment for Windows Desktop

MSIX è un nuovo formato di pacchetto di app Windows.MSIX is a new Windows app 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.

Nota

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>

Supporto JSON predefinito rapidoFast built-in JSON support

L'ecosistema .NET si è basato su Json.NET e altre librerie JSON molto diffuse, che rimangono sempre scelte valide.The .NET ecosystem has 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 are 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>. Sono stati aggiunti tre nuovi tipi correlati principali JSON a .NET Core 3.0 nello spazio dei nomi System.Text.Json.Three new main JSON-related types have been added to .NET Core 3.0 the System.Text.Json namespace.

Utf8JsonReaderUtf8JsonReader

System.Text.Json.Utf8JsonReader è un lettore forward-only a prestazioni elevate e allocazione ridotta per il testo JSON con codifica UTF-8, letto da 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 è un tipo di base di basso livello, che può essere sfruttato per compilare parser e deserializzatori personalizzati.The Utf8JsonReader is a foundational, low-level type, that can be leveraged to build custom parsers and deserializers. La lettura di un payload JSON con il nuovo Utf8JsonReader è due volte più veloce che con il lettore di Json.NET.Reading through a JSON payload using the new Utf8JsonReader is 2x faster than using the reader from Json.NET. Non viene allocato fino a quando non è necessario realizzare i token JSON come stringhe (UTF-16).It does not allocate until you need to actualize JSON tokens as (UTF-16) strings.

Questa nuova API includerà i componenti seguenti:This new API will include the following components:

  • Nell'anteprima 1: lettore JSON (accesso sequenziale)In Preview 1: JSON reader (sequential access)
  • Presto disponibili: writer JSON, DOM (accesso casuale), serializzatore poco, deserializzatore pocoComing next: JSON writer, DOM (random access), poco serializer, poco deserializer

Ecco il ciclo del lettore di base per Utf8JsonReader che può essere usato come punto iniziale:Here is the basic reader loop for the Utf8JsonReader that can be used as a starting point:

using System.Text.Json;

public static void Utf8JsonReaderLoop(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:
                string valueString = json.GetStringValue();
                break;
            case JsonTokenType.Number:
                if (!json.TryGetInt32Value(out int valueInteger))
                {
                    throw new FormatException();
                }
                break;
            case JsonTokenType.True:
            case JsonTokenType.False:
                bool valueBool = json.GetBooleanValue();
                break;
            case JsonTokenType.Null:
                break;
            default:
                throw new ArgumentException();
        }
    }

    dataUtf8 = dataUtf8.Slice((int)json.BytesConsumed);
    JsonReaderState state = json.CurrentState;
}

Utf8JsonWriterUtf8JsonWriter

System.Text.Json.Utf8JsonWriter rende disponibile un metodo ad alte prestazioni, senza memorizzazione nella cache e forward-only per la scrittura di test JSON con codifica UTF-8 da tipi .NET comuni, come String, Int32 e 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. Come il lettore, il writer è un tipo di base di basso livello, che può essere sfruttato per creare serializzatori personalizzati.Like the reader, the writer is a foundational, low-level type, that can be leveraged to build custom serializers. La scrittura di un payload JSON con il nuovo Utf8JsonWriter offre velocità maggiori del 30-80% rispetto all'uso del writer da Json.NET e non prevede allocazione.Writing a JSON payload using the new Utf8JsonWriter is 30-80% faster than using the writer from Json.NET and does not allocate.

Ecco un esempio di utilizzo di Utf8JsonWriter che può essere usato come punto di partenza:Here is a sample usage of the Utf8JsonWriter that can be used as a starting point:

static int WriteJson(IBufferWriter<byte> output, long[] extraData)
{
    var json = new Utf8JsonWriter(output, state: default);

    json.WriteStartObject();

    json.WriteNumber("age", 15, escape: false);
    json.WriteString("date", DateTime.Now);
    json.WriteString("first", "John");
    json.WriteString("last", "Smith");

    json.WriteStartArray("phoneNumbers", escape: false);
    json.WriteStringValue("425-000-1212", escape: false);
    json.WriteStringValue("425-000-1213");
    json.WriteEndArray();

    json.WriteStartObject("address");
    json.WriteString("street", "1 Microsoft Way");
    json.WriteString("city", "Redmond");
    json.WriteNumber("zip", 98052);
    json.WriteEndObject();

    json.WriteStartArray("ExtraArray");
    for (var i = 0; i < extraData.Length; i++)
    {
        json.WriteNumberValue(extraData[i]);
    }
    json.WriteEndArray();

    json.WriteEndObject();

    json.Flush(isFinalBlock: true);

    return (int)json.BytesWritten;
}

Utf8JsonWriter accetta IBufferWriter<byte> come posizione di output per la scrittura sincrona dei dati JSON ed è il chiamante a dover fornire un'implementazione concreta.The Utf8JsonWriter accepts IBufferWriter<byte> as the output location to synchronously write the json data into, and you as the caller need to provide a concrete implementation. Attualmente la piattaforma non include un'implementazione di questa interfaccia.The platform does not currently include an implementation of this interface. Per un esempio di IBufferWriter<byte>, vedere https://gist.github.com/ahsonkhan/c76a1cc4dc7107537c3fdc0079a68b35.For an example of IBufferWriter<byte>, see https://gist.github.com/ahsonkhan/c76a1cc4dc7107537c3fdc0079a68b35.

JsonDocumentJsonDocument

System.Text.Json.JsonDocument è basato su Utf8JsonReader.System.Text.Json.JsonDocument is built on top of the Utf8JsonReader. JsonDocument offre la possibilità di analizzare i dati JSON e compilare un modello DOM (Document Object Model) di sola lettura su cui è possibile eseguire query per supportare l'accesso casuale e l'enumerazione.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. Gli elementi JSON che compongono i dati sono accessibili tramite il tipo JsonElement che viene esposto da JsonDocument come una proprietà denominata RootElement.The JSON elements that compose the data can be accessed via the JsonElement type which is exposed by the JsonDocument as a property called RootElement. JsonElement contiene gli enumeratori di matrice e oggetto JSON insieme alle API per convertire il testo JSON in tipi .NET comuni.The JsonElement contains the JSON array and object enumerators along with APIs to convert JSON text to common .NET types. L'analisi di un payload JSON tipico e l'accesso a tutti i relativi membri tramite JsonDocument è 2-3 volte più veloce rispetto a Json.NET con allocazioni minime per dati di dimensioni ragionevoli, ovvero inferiori a 1 MB.Parsing a typical JSON payload and accessing all its members using the JsonDocument is 2-3x faster than Json.NET with very little allocations for data that is reasonably sized (i.e. < 1 MB).

Ecco un esempio di utilizzo di JsonDocument e JsonElement che può essere usato come punto di partenza:Here is a sample usage of the JsonDocument and JsonElement that can be used as a starting point:

static double ParseJson()
{
    const string json = " [ { \"name\": \"John\" }, [ \"425-000-1212\", 15 ], { \"grades\": [ 90, 80, 100, 75 ] } ]";

    double average = -1;

    using (JsonDocument doc = JsonDocument.Parse(json))
    {
        JsonElement root = doc.RootElement;
        JsonElement info = root[1];

        string phoneNumber = info[0].GetString();
        int age = info[1].GetInt32();

        JsonElement grades = root[2].GetProperty("grades");

        double sum = 0;
        foreach (JsonElement grade in grades.EnumerateArray())
        {
            sum += grade.GetInt32();
        }

        int numberOfCourses = grades.GetArrayLength();
        average = sum / numberOfCourses;
    }

    return average;
}

Assembly non caricabiliAssembly Unloadability

Gli assembly non caricabili sono una nuova funzionalità di AssemblyLoadContext.Assembly unloadability is a new capability of AssemblyLoadContext. Questa nuova funzionalità è in gran parte trasparente dal punto di vista di un'API ed è esposta solo con poche nuove API.This new feature is largely transparent from an API perspective, exposed with just a few new APIs. Consente di scaricare il contesto di un caricatore, rilasciando tutta la memoria per tipi istanziati, i campi statici e per l'assembly stesso.It enables a loader context to be unloaded, releasing all memory for instantiated types, static fields and for the assembly itself. Un'applicazione deve essere in grado di caricare e scaricare gli assembly tramite questo meccanismo a tempo indefinito senza riscontrare una perdita di memoria.An application should be able to load and unload assemblies via this mechanism forever without experiencing a memory leak.

Questa nuova funzionalità può essere usata per scenari simili ai seguenti:This new capability can be used for scenarios similar to:

  • Scenari con plug-in in cui sono richiesti il caricamento e lo scaricamento dinamico del plug-in.Plugin scenarios where dynamic plugin loading and unloading is required.
  • Compilazione, esecuzione e scaricamento dinamici del codice.Dynamically compiling, running and then flushing code. Utile per siti Web, motori di scripting e così via.Useful for web sites, scripting engines, etc.
  • Il caricamento degli assembly per introspezione (ad esempio ReflectionOnlyLoad), nonostante MetadataLoadContext (rilasciato nella versione Preview 1) sia una scelta migliore in molti casi.Loading assemblies for introspection (like ReflectionOnlyLoad), although MetadataLoadContext (released in Preview 1) will be a better choice in many cases.

Per altre informazioni, vedere il documento Using Unloadability (Usare la funzionalità che impedisce lo scaricamento).For more information, see the Using Unloadability document.

Lo scaricamento degli assembly richiede notevole attenzione per assicurare che tutti i riferimenti agli oggetti gestiti dall'esterno del contesto di un caricatore vengano riconosciuti e gestiti.Assembly unloading requires significant care to ensure that all references to managed objects from outside a loader context are understood and managed. Quando è richiesto lo scaricamento del contesto del caricatore, occorre rimuovere tutti gli eventuali riferimenti esterni in modo che il contesto del caricatore sia intrinsecamente coerente solo con se stesso.When the loader context is requested to be unloaded, any outside references need to have been unreferenced so that the loader context is self-consistent only to itself.

La funzionalità per impedire lo scaricamento degli assembly era inclusa in .NET Framework tramite i domini dell'applicazione (AppDomain), non supportati in .NET Core.Assembly unloadability was provided in the .NET Framework by Application Domains (AppDomains), which are not supported with .NET Core. AppDomain presenta sia vantaggi che limiti rispetto a questo nuovo modello.AppDomains had both benefits and limitations compared to this new model. Prendere in considerazione questo nuovo modello di caricatore per ottenere maggiore flessibilità e prestazioni più elevate rispetto ad AppDomain.Consider this new loader model to be more flexible and higher performant when compared to AppDomains.

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. P/Invoke è supportato a partire da .NET Core 1.0.Since .NET Core 1.0, P/Invoke has been supported. Con .NET Core 3.0 è stato ora aggiunto il supporto della possibilità di generare contestualmente API COM e di attivare API WinRT.Now with .NET Core 3.0, support for the ability to CoCreate COM APIs and Activate WinRT APIs has been added.

È possibile vedere un esempio dell'uso di COM con il codice sorgente per la demo con Excel.You can see an example of using COM with the Excel Demo source code.

Tipo: SequenceReaderType: SequenceReader

In .NET Core 3.0 è stato aggiunto System.Buffers.SequenceReader che può essere usato come lettore per ReadOnlySequence<T>.In .NET Core 3.0, System.Buffers.SequenceReader has been added which can be used as a reader for ReadOnlySequence<T>. Ciò consente un'analisi semplice, a prestazioni elevate e allocazione ridotta dei dati di System.IO.Pipelines che possono attraversare più buffer sottostanti.This allows easy, high performance, low allocation parsing of System.IO.Pipelines data that can cross multiple backing buffers.

L'esempio seguente suddivide un elemento Sequence di input in righe delimitate da CR/LF valide:The following example breaks an input Sequence into valid CR/LF delimited lines:

private static ReadOnlySpan<byte> CRLF => new byte[] { (byte)'\r', (byte)'\n' };

public static void ReadLines(ReadOnlySequence<byte> sequence)
{
    SequenceReader<byte> reader = new SequenceReader<byte>(sequence);

    while (!reader.End)
    {
        if (!reader.TryReadToAny(out ReadOnlySpan<byte> line, CRLF, advancePastDelimiter:false))
        {
            // Couldn't find another delimiter
            // ...
        }

        if (!reader.IsNext(CRLF, advancePast: true))
        {
            // Not a good CR/LF pair
            // ...
        }

        // line is valid, process
        ProcessLine(line);
    }
}

Tipo: MetadataLoadContextType: MetadataLoadContext

È stato aggiunto il tipo MetadataLoadContext che consente la lettura dei metadati dell'assembly senza impatto sul dominio dell'applicazione del chiamante.The MetadataLoadContext type has been added that enables reading assembly metadata without affecting the caller’s application domain. Gli assembly vengono letti come dati, inclusi gli assembly compilati per architetture e piattaforme diverse da quelle dell'ambiente di runtime corrente.Assemblies are read as data, including assemblies built for different architectures and platforms than the current runtime environment. MetadataLoadContext si sovrappone a ReflectionOnlyLoad, che è disponibile solo in .NET Framework.MetadataLoadContext overlaps with the ReflectionOnlyLoad, which is only available in the .NET Framework.

MetdataLoadContext è disponibile nel pacchetto System.Reflection.MetadataLoadContext.MetdataLoadContext is available in the System.Reflection.MetadataLoadContext package. Si tratta di un pacchetto .NET Standard 2.0.It is a .NET Standard 2.0 package.

MetadataLoadContext espone API simili al tipo AssemblyLoadContext, ma non si basa su tale tipo.The MetadataLoadContext exposes APIs similar to the AssemblyLoadContext type, but is not based on that type. In modo analogo a AssemblyLoadContext, MetadataLoadContext consente il caricamento degli assembly all'interno di un universo di caricamento di assembly isolato.Much like AssemblyLoadContext, the MetadataLoadContext enables loading assemblies within an isolated assembly loading universe. Le API MetdataLoadContext restituiscono oggetti Assembly, consentendo l'uso di API di reflection familiari.MetdataLoadContext APIs return Assembly objects, enabling the use of familiar reflection APIs. Le API orientate all'esecuzione, ad esempio MethodBase.Invoke, non sono consentite e genereranno l'eccezione InvalidOperationException.Execution-oriented APIs, such as MethodBase.Invoke, are not allowed and will throw InvalidOperationException.

L'esempio seguente illustra come trovare tipi concreti in un assembly che implementa una determinata interfaccia:The following sample demonstrates how to find concrete types in an assembly that implements a given interface:

var paths = new string[] {@"C:\myapp\mscorlib.dll", @"C:\myapp\myapp.dll"};
var resolver = new PathAssemblyResolver(paths);
using (var lc = new MetadataLoadContext(resolver))
{
    Assembly a = lc.LoadFromAssemblyName("myapp");
    Type myInterface = a.GetType("MyApp.IPluginInterface");
    foreach (Type t in a.GetTypes())
    {
        if (t.IsClass && myInterface.IsAssignableFrom(t))
            Console.WriteLine($"Class {t.FullName} implements IPluginInterface");
    }
}

Gli scenari per MetadataLoadContext includono funzionalità della fase di progettazione, strumenti della fase di compilazione e funzionalità esclusive di runtime che devono esaminare un set di assembly come dati e i cui blocchi di file e la cui memoria vengono liberati dopo l'esecuzione dell'ispezione.Scenarios for MetadataLoadContext include design-time features, build-time tooling, and runtime light-up features that need to inspect a set of assemblies as data and have all file locks and memory freed after inspection is performed.

MetadataLoadContext ha una classe resolver passata al costruttore.The MetadataLoadContext has a resolver class passed to its constructor. Il processo del resolver consiste nel caricare un Assembly, dato il relativo AssemblyName.The resolver's job is to load an Assembly given its AssemblyName. La classe resolver deriva dalla classe astratta MetadataAssemblyResolver.The resolver class derives from the abstract MetadataAssemblyResolver class. Con PathAssemblyResolver viene fornita un'implementazione del resolver per gli scenari basati sul percorso.An implementation of the resolver for path-based scenarios is provided with PathAssemblyResolver.

I test di MetadataLoadContext illustrano numerosi casi d'uso.The MetadataLoadContext tests demonstrate many use cases. I test di Assembly sono un buon punto di partenza.The Assembly tests are a good place to start.

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

.NET Core sfrutterà ora il supporto di TLS 1.3 in OpenSSL 1.1.1, quando è disponibile in un determinato ambiente..NET Core will now take advantage of TLS 1.3 support in OpenSSL 1.1.1, when it is available in a given environment. I vantaggi di TLS 1.3 sono diversi, secondo il team di OpenSSL:There are multiple benefits of TLS 1.3, per the OpenSSL team:

  • Durata della connessione migliorata grazie alla riduzione del numero di round trip necessari tra il client e il server.Improved connection times due to a reduction in the number of round trips required between the client and server.

  • Maggiore sicurezza grazie alla rimozione di algoritmi di crittografia obsoleti e non sicuri e alla crittografia di più elementi dell'handshake della connessione.Improved security due to the removal of various obsolete and insecure cryptographic algorithms and encryption of more of the connection handshake.

.NET Core 3.0 Preview 1 può utilizzare OpenSSL 1.1.1, OpenSSL 1.1.0 o OpenSSL 1.0.2 (a seconda della versione migliore trovata, in un sistema Linux)..NET Core 3.0 Preview 1 is capable of utilizing OpenSSL 1.1.1, OpenSSL 1.1.0, or OpenSSL 1.0.2 (whatever the best version found is, on a Linux system). Quando OpenSSL 1.1.1 è disponibile, i tipi SslStream e HttpClient useranno TLS 1.3 quando si usa SslProtocols.None (protocolli predefiniti di sistema), presupponendo che sia il client che il server supportino TLS 1.3.When OpenSSL 1.1.1 is available the SslStream and HttpClient types will use TLS 1.3 when using SslProtocols.None (system default protocols), assuming both the client and server support TLS 1.3.

L'esempio seguente illustra .NET Core 3.0 Preview 1 in Ubuntu 18.10 che si connette a https://www.cloudflare.com:The following sample demonstrates .NET Core 3.0 Preview 1 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 tlstest
{
    class Program
    {
        static async Task Main()
        {
            using (TcpClient tcpClient = new TcpClient())
            {
                string targetHost = "www.cloudflare.com";

                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}");
                }
            }
        }
    }
}
user@comp-ubuntu1810:~/tlstest$ dotnet run
Connected to www.cloudflare.com with Tls13
user@comp-ubuntu1810:~/tlstest$ openssl version
OpenSSL 1.1.1  11 Sep 2018

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.

CrittografiaCryptography

È stato aggiunto il supporto per le modalità di crittografia AES-GCM e AES-CCM, implementate tramite System.Security.Cryptography.AesGcm e System.Security.Cryptography.AesCcm.Support has been added for AES-GCM and AES-CCM ciphers, implemented via System.Security.Cryptography.AesGcm and System.Security.Cryptography.AesCcm. Questi algoritmi sono entrambi algoritmi di cifratura autenticata con dati di associazione nonché i primi algoritmi di cifratura autenticata aggiunti a .NET Core.These algorithms are both Authenticated Encryption with Association Data (AEAD) algorithms, and the first Authenticated Encryption (AE) algorithms added to .NET Core.

Il codice seguente illustra l'uso della modalità di crittografia AesGcm per crittografare e decrittografare dati casuali.The following code demonstrates using AesGcm cipher to encrypt and decrypt random data.

Il codice per AesCcm sarà pressoché identico, con la sola differenza dei nomi di variabile di classe.The code for AesCcm would look almost identical (only the class variable names would be different).

// 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 Preview 1 supporta l'importazione e l'esportazione di chiavi pubbliche e private asimmetriche dai formati standard, senza bisogno usare un certificato X.509..NET Core 3.0 Preview 1 supports the import and export of asymmetric public and private keys from standard formats, without needing to use an X.509 certificate.

Tutti i tipi di chiavi (RSA, DSA, ECDsa, ECDiffieHellman) supportano il formato X.509 SubjectPublicKeyInfo per le chiavi pubbliche e i formati PKCS#8 PrivateKeyInfo e PKCS#8 EncryptedPrivateKeyInfo per le chiavi private.All key types (RSA, DSA, ECDsa, ECDiffieHellman) support the X.509 SubjectPublicKeyInfo format for public keys, and the PKCS#8 PrivateKeyInfo and PKCS#8 EncryptedPrivateKeyInfo formats for private keys. RSA supporta anche PKCS#1 RSAPublicKey e PKCS#1 RSAPrivateKey.RSA additionally supports PKCS#1 RSAPublicKey and PKCS#1 RSAPrivateKey. Tutti i metodi di esportazione producono dati binari con codifica DER e i metodi di importazione presentano lo stesso comportamento.The export methods all 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.IO;
using System.Security.Cryptography;

namespace rsakeyprint
{
    class Program
    {
        static void Main(string[] args)
        {
            using (RSA rsa = RSA.Create())
            {
                byte[] keyBytes = File.ReadAllBytes(args[0]);
                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));
            }
        }
    }
}
user@comp-ubuntu1810:~/rsakeyprint$ echo Making a small key to save on screen space.
Making a small key to save on screen space.
user@comp-ubuntu1810:~/rsakeyprint$ openssl genrsa 768 | openssl rsa -outform der -out rsa.key
Generating RSA private key, 768 bit long modulus (2 primes)
..+++++++
........+++++++
e is 65537 (0x010001)
writing RSA key
user@comp-ubuntu1810:~/rsakeyprint$ dotnet run rsa.key
Read 461 bytes, 0 extra byte(s) in file.
0F-D0-82-34-F8-13-38-4A-7F-C7-52-4A-F6-93-F8-FB-6D-98-7A-6A-04-3B-BC-35-8C-7D-AC-A5-A3-6E-AD-C1-66-30-81-2C-2A-DE-DA-60-03-6A-2C-D9-76-15-7F-61-97-57-
79-E1-6E-45-62-C3-83-04-97-CB-32-EF-C5-17-5F-99-60-92-AE-B6-34-6F-30-06-03-AC-BF-15-24-43-84-EB-83-60-EF-4D-3B-BD-D9-5D-56-26-F0-51-CE-F1
user@comp-ubuntu1810:~/rsakeyprint$ openssl rsa -in rsa.key -inform der -text -noout | grep -A7 private
privateExponent:
    0f:d0:82:34:f8:13:38:4a:7f:c7:52:4a:f6:93:f8:
    fb:6d:98:7a:6a:04:3b:bc:35:8c:7d:ac:a5:a3:6e:
    ad:c1:66:30:81:2c:2a:de:da:60:03:6a:2c:d9:76:
    15:7f:61:97:57:79:e1:6e:45:62:c3:83:04:97:cb:
    32:ef:c5:17:5f:99:60:92:ae:b6:34:6f:30:06:03:
    ac:bf:15:24:43:84:eb:83:60:ef:4d:3b:bd:d9:5d:
    56:26:f0:51:ce:f1

I file PKCS#8 possono essere esaminati con la classe System.Security.Cryptography.Pkcs.Pkcs8PrivateKeyInfo.PKCS#8 files can be inspected with the System.Security.Cryptography.Pkcs.Pkcs8PrivateKeyInfo class.

I file PFX/PKCS#12 possono essere esaminati e modificati rispettivamente con System.Security.Cryptography.Pkcs.Pkcs12Info e System.Security.Cryptography.Pkcs.Pkcs12Builder.PFX/PKCS#12 files can be inspected and manipulated with System.Security.Cryptography.Pkcs.Pkcs12Info and System.Security.Cryptography.Pkcs.Pkcs12Builder, respectively.

SerialPort per LinuxSerialPort for Linux

.NET Core 3.0 supporta ora System.IO.Ports.SerialPort in Linux..NET Core 3.0 now supports System.IO.Ports.SerialPort on Linux.

In precedenza, .NET Core supportava solo l'uso del tipo SerialPort in Windows.Previously, .NET Core only supported using the SerialPort type on Windows.

Altri miglioramenti BCLMore BCL Improvements

Span<T>, Memory<T> e i tipi correlati introdotti in .NET Core 2.1 sono stati ottimizzati in .NET Core 3.0.The Span<T>, Memory<T>, and related types that were introduced in .NET Core 2.1, have been optimized in .NET Core 3.0. Le operazioni comuni, ad esempio la costruzione di intervalli, il sezionamento, l'analisi e la formattazione offrono ora prestazioni migliori.Common operations such as span construction, slicing, parsing, and formatting now perform better.

Inoltre, i tipi come String sono stati sottoposti a miglioramenti per aumentarne l'efficienza quando sono usati come chiavi con Dictionary<TKey, TValue> e altre raccolte.Additionally, types like String have seen under-the-cover improvements to make them more efficient when used as keys with Dictionary<TKey, TValue> and other collections. Per trarre vantaggio da questi miglioramenti, non sono necessarie modifiche al codice.No code changes are required to benefit from these improvements.

.NET Core 3 Preview 1 presenta anche i nuovi miglioramenti seguenti:The following improvements are also new in .NET Core 3 Preview 1:

  • Supporto di Brotli predefinito in HttpClientBrotli support built in to HttpClient
  • ThreadPool.UnsafeQueueWorkItem(IThreadPoolWorkItem)ThreadPool.UnsafeQueueWorkItem(IThreadPoolWorkItem)
  • Unsafe.UnboxUnsafe.Unbox
  • CancellationToken.UnregisterCancellationToken.Unregister
  • Operatori aritmetici complessiComplex arithmetic operators
  • API socket per il keep-alive TCPSocket APIs for TCP keep alive
  • StringBuilder.GetChunksStringBuilder.GetChunks
  • Analisi IPEndPointIPEndPoint parsing
  • RandomNumberGenerator.GetInt32RandomNumberGenerator.GetInt32

Compilazione a livelliTiered compilation

Per impostazione predefinita, con .NET Core 3.0 la compilazione a livelli è attiva.Tiered compilation is on by default with .NET Core 3.0. È una funzionalità che consente al runtime di usare in modo più adattivo il compilatore JIT per ottenere prestazioni migliori, sia all'avvio che per ottimizzare la velocità effettiva.It is a feature that enables the runtime to more adaptively use the Just-In-Time (JIT) compiler to get better performance, both at startup and to maximize throughput.

Questa funzionalità è stata aggiunta come funzionalità con consenso esplicito in .NET Core 2.1 ed è stata abilitata per impostazione predefinita in .NET Core 2.2 Preview 2.This feature was added as an opt-in feature in .NET Core 2.1 and then was enabled by default in .NET Core 2.2 Preview 2. Successivamente, è stata ripristinata come funzionalità con consenso esplicito nella versione .NET Core 2.2.Subsequently, it has been reverted back to opt in with the .NET Core 2.2 release.

Supporto ARM64 per LinuxARM64 Linux support

È stato aggiunto il supporto per ARM64 per Linux.Support has been added 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.

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

Per altre informazioni., vedere Stato di ARM64 per .NET Core.Please check .NET Core ARM64 Status for more information.

Nota

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

Installare le versioni di anteprima di .NET Core 3.0 in Linux con SnapInstall .NET Core 3.0 Previews on Linux with Snap

Snap è il modo preferenziale per installare e provare le anteprime di .NET Core nelle distribuzioni di Linux che supportano Snap.Snap is the preferred way to install and try .NET Core previews on Linux distributions that support Snap.

Dopo aver configurato Snap nel sistema, eseguire il comando seguente per installare .NET Core SDK 3.0 Preview SDK.After configuring Snap on your system, run the following command to install the .NET Core SDK 3.0 Preview SDK.

sudo snap install dotnet-sdk --beta --classic

Se .NET Core viene installato usando il pacchetto Snap, il comando di .NET Core predefinito è dotnet-sdk.dotnet, anziché semplicemente dotnet.When .NET Core in installed using the Snap package, the default .NET Core command is dotnet-sdk.dotnet, as opposed to just dotnet. Il vantaggio del comando con spazio dei nomi è che non si verificheranno conflitti con una versione di .NET Core installata a livello globale eventualmente disponibile.The benefit of the namespaced command is that it will not conflict with a globally installed .NET Core version you may have. È possibile definire l'alias dotnet per questo comando con:This command can be aliased to dotnet with:

sudo snap alias dotnet-sdk.dotnet dotnet

Alcune distribuzioni richiedono un altro passaggio per abilitare l'accesso al certificato SSL.Some distros require an additional step to enable access to the SSL certificate. Vedere la documentazione sulla configurazione di Linux per altri dettagli.See our Linux Setup for details.

Supporto di GPIO per Raspberry PiGPIO Support for Raspberry Pi

Sono stati rilasciati due nuovi pacchetti NuGet che è possibile usare per la programmazione GPIO.Two new 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 includes APIs for GPIO, SPI, I2C and PWM devices. Il pacchetto di associazioni IoT include associazioni di dispositivi per i vari chip e sensori, gli stessi disponibili indotnet/iot - src/devices.The IoT bindings package includes device bindings for various chips and sensors, the same ones available at dotnet/iot - src/devices.

Le API per le porte seriali aggiornate, annunciate per .NET Core 3.0 Preview 1, non fanno parte di questi pacchetti ma sono disponibili come parte della piattaforma .NET Core.The updated serial port APIs that were announced as part of .NET Core 3.0 Preview 1 are not part of these packages but are available as part of the .NET Core platform.

Supporto per piattaformePlatform Support

.NET Core 3 sarà supportato nei sistemi operativi seguenti:.NET Core 3 will be supported on the following operating systems:

  • Client Windows: 7, 8.1, 10 (1607+)Windows Client: 7, 8.1, 10 (1607+)
  • Windows Server: 2012 R2 SP1+Windows Server: 2012 R2 SP1+
  • macOS: 10.12+macOS: 10.12+
  • RHEL: 6+RHEL: 6+
  • Fedora: 26+Fedora: 26+
  • Ubuntu: 16.04+Ubuntu: 16.04+
  • Debian: 9+Debian: 9+
  • SLES: 12+SLES: 12+
  • openSUSE: 42.3+openSUSE: 42.3+
  • Alpine: 3.8+Alpine: 3.8+

Il supporto dei chip è il seguente:Chip support follows:

  • x64 in Windows, macOS e Linuxx64 on Windows, macOS, and Linux
  • x86 in Windowsx86 on Windows
  • ARM32 in Windows e LinuxARM32 on Windows and Linux
  • ARM64 in LinuxARM64 on Linux

Per Linux, ARM32 è supportato in Debian 9+ e Ubuntu 16.04+.For Linux, ARM32 is supported on Debian 9+ and Ubuntu 16.04+. Per ARM64, è uguale a ARM32 con l'aggiunta di Alpine 3.8.For ARM64, it is the same as ARM32 with the addition of Alpine 3.8. Queste sono le stesse versioni di tali distribuzioni supportate per x64.These are the same versions of those distros as is supported for X64.

Le immagini Docker per .NET Core 3.0 sono disponibili in microsoft/dotnet nell'Hub Docker.Docker images for .NET Core 3.0 are available at microsoft/dotnet on Docker Hub. È in corso il processo di adozione di Microsoft Container Registry (MCR) ed è previsto che le immagini finali di .NET Core 3.0 vengano pubblicate solo in MCR.Microsoft is currently in the process of adopting Microsoft Container Registry (MCR) and it is expected that the final .NET Core 3.0 images will only be published to MCR.