Bagikan melalui

Yang baru di .NET Core 3.0

  • Artikel

Artikel ini menjelaskan apa yang baru dalam .NET Core 3.0. Salah satu peningkatan terbesar adalah dukungan untuk aplikasi desktop Windows (hanya Windows). Dengan menggunakan komponen .NET Core 3.0 SDK Windows Desktop, Anda dapat mem-port aplikasi Formulir Windows dan Windows Presentation Foundation (WPF). Agar jelas, komponen Windows Desktop hanya didukung dan disertakan pada Windows. Untuk informasi selengkapnya, lihat bagian desktop Windows nanti di artikel ini.

.NET Core 3.0 menambahkan dukungan untuk C# 8.0. Sangat disarankan agar Anda menggunakan Visual Studio 2019 versi 16.3 atau yang lebih baru, Visual Studio untuk Mac 8.3 atau yang lebih baru, atau Visual Studio Code dengan ekstensi C# terbaru.

Unduh dan mulai dengan .NET Core 3.0 sekarang di Windows, macOS, atau Linux.

Untuk informasi selengkapnya tentang rilis, lihat pengumuman .NET Core 3.0.

.NET Core 3.0 RC 1 dianggap siap produksi oleh Microsoft dan didukung penuh. Jika Anda menggunakan rilis pratinjau, Anda harus berpindah ke versi RTM untuk dukungan berkelanjutan.

Peningkatan bahasa C# 8.0

C# 8.0 juga merupakan bagian dari rilis ini, yang mencakup fitur jenis referensi nullable, aliran asinkron, dan lebih banyak pola. Untuk informasi selengkapnya tentang fitur C# 8.0, lihat Apa yang baru di C# 8.0.

Tutorial yang terkait dengan fitur bahasa C# 8.0:

Penyempurnaan bahasa ditambahkan untuk mendukung fitur API berikut yang dirinci di bawah ini:

.NET Standard 2.1+

.NET Core 3.0 mengimplementasikan .NET Standard 2.1. Namun, templat default dotnet new classlib menghasilkan proyek yang masih menargetkan .NET Standard 2.0. Untuk menargetkan .NET Standard 2.1, edit file proyek Anda dan ubah properti menjadi TargetFrameworknetstandard2.1:

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <TargetFramework>netstandard2.1</TargetFramework>
  </PropertyGroup>

</Project>

Jika Anda menggunakan Visual Studio, Anda memerlukan Visual Studio 2019, karena Visual Studio 2017 tidak mendukung .NET Standard 2.1 atau .NET Core 3.0.

Kompilasi/Sebarkan

Executable default

.NET Core sekarang membangun executable yang bergantung pada kerangka kerja secara default. Perilaku ini baru untuk aplikasi yang menggunakan versi .NET Core yang diinstal secara global. Sebelumnya, hanya penyebaran mandiri yang akan menghasilkan executable.

Selama dotnet build atau dotnet publish, executable (dikenal sebagai appHost) dibuat yang cocok dengan lingkungan dan platform SDK yang Anda gunakan. Anda dapat mengharapkan hal yang sama dengan executable ini seperti yang Anda lakukan pada executable asli lainnya, seperti:

  • Anda dapat mengeklik dua kali pada executable.
  • Anda dapat meluncurkan aplikasi dari prompt perintah secara langsung, seperti myapp.exe di Windows, dan ./myapp di Linux dan macOS.

macOS appHost dan notarisasi

hanya macOS

Dimulai dengan .NET Core SDK 3.0 yang diberi notarisasi untuk macOS, pengaturan untuk menghasilkan executable default (dikenal sebagai appHost) dinonaktifkan secara default. Untuk informasi selengkapnya, lihat macOS Catalina Notarization dan dampaknya pada unduhan dan proyek .NET Core.

Saat pengaturan appHost diaktifkan, .NET Core menghasilkan Mach-O asli yang dapat dieksekusi saat Anda membangun atau menerbitkan. Aplikasi Anda berjalan dalam konteks appHost saat dijalankan dari kode sumber dengan dotnet run perintah , atau dengan memulai Mach-O yang dapat dieksekusi secara langsung.

Tanpa appHost, satu-satunya cara pengguna dapat memulai aplikasi yang bergantung pada kerangka kerja adalah dengan dotnet <filename.dll> perintah . AppHost selalu dibuat saat Anda menerbitkan aplikasi mandiri.

Anda dapat mengonfigurasi appHost di tingkat proyek, atau mengalihkan appHost untuk perintah tertentu dotnet dengan -p:UseAppHost parameter :

  • File proyek

    <PropertyGroup>
  <UseAppHost>true</UseAppHost>
</PropertyGroup>

  • Parameter baris-perintah

    dotnet run -p:UseAppHost=true

Untuk informasi selengkapnya tentang pengaturan UseAppHost, lihat Properti MSBuild untuk Microsoft.NET.Sdk.

File tunggal yang dapat dieksekusi

Perintah ini dotnet publish mendukung pengemasan aplikasi Anda ke dalam file tunggal khusus platform yang dapat dieksekusi. Executable mengekstrak sendiri dan berisi semua dependensi (termasuk asli) yang diperlukan untuk menjalankan aplikasi Anda. Saat aplikasi pertama kali dijalankan, aplikasi diekstrak ke direktori berdasarkan nama aplikasi dan pengidentifikasi build. Startup lebih cepat ketika aplikasi dijalankan lagi. Aplikasi tidak perlu mengekstrak dirinya sendiri untuk kedua kalinya kecuali versi baru digunakan.

Untuk menerbitkan file tunggal yang dapat dieksekusi, atur PublishSingleFile di proyek Anda atau pada baris perintah dengan dotnet publish perintah :

<PropertyGroup>
  <RuntimeIdentifier>win10-x64</RuntimeIdentifier>
  <PublishSingleFile>true</PublishSingleFile>
</PropertyGroup>

-atau-

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

Untuk informasi selengkapnya tentang penerbitan file tunggal, lihat dokumen desain bunder file tunggal.

Pemangkasan perakitan

.NET core 3.0 SDK dilengkapi dengan alat yang dapat mengurangi ukuran aplikasi dengan menganalisis IL dan memangkas rakitan yang tidak digunakan.

Aplikasi mandiri mencakup semua yang diperlukan untuk menjalankan kode Anda, tanpa memerlukan .NET untuk diinstal di komputer host. Namun, sering kali aplikasi hanya memerlukan subset kecil kerangka kerja untuk berfungsi, dan pustaka lain yang tidak digunakan dapat dihapus.

.NET Core sekarang menyertakan pengaturan yang akan menggunakan alat IL Trimmer untuk memindai IL aplikasi Anda. Alat ini mendeteksi kode apa yang diperlukan, lalu memangkas pustaka yang tidak digunakan. Alat ini dapat secara signifikan mengurangi ukuran penyebaran beberapa aplikasi.

Untuk mengaktifkan alat ini, tambahkan <PublishTrimmed> pengaturan di proyek Anda dan terbitkan aplikasi mandiri:

<PropertyGroup>
  <PublishTrimmed>true</PublishTrimmed>
</PropertyGroup>

dotnet publish -r <rid> -c Release

Sebagai contoh, templat proyek konsol baru "halo dunia" dasar yang disertakan, ketika diterbitkan, mencapai ukuran sekitar 70 MB. Dengan menggunakan <PublishTrimmed>, ukuran tersebut dikurangi menjadi sekitar 30 MB.

Penting untuk dipertimbangkan bahwa aplikasi atau kerangka kerja (termasuk ASP.NET Core dan WPF) yang menggunakan refleksi atau fitur dinamis terkait, akan sering rusak saat dipangkas. Kerusakan ini terjadi karena pemangkas tidak tahu tentang perilaku dinamis ini dan tidak dapat menentukan jenis kerangka kerja mana yang diperlukan untuk refleksi. Alat IL Trimmer dapat dikonfigurasi untuk mengetahui skenario ini.

Di atas segalanya, pastikan untuk menguji aplikasi Anda setelah pemangkasan.

Untuk informasi selengkapnya tentang alat IL Trimmer, lihat dokumentasi atau kunjungi repositori mono/linker .

Kompilasi berjenjang

Kompilasi berjenjang (TC) aktif secara default dengan .NET Core 3.0. Fitur ini memungkinkan runtime untuk lebih adaptif menggunakan kompilator just-in-time (JIT) untuk mencapai performa yang lebih baik.

Manfaat utama kompilasi berjenjang adalah menyediakan dua cara metode jitting: dalam tingkat berkualitas lebih rendah tetapi lebih cepat atau tingkat yang lebih tinggi tetapi lebih lambat. Kualitasnya mengacu pada seberapa baik metode dioptimalkan. TC membantu meningkatkan performa aplikasi saat melalui berbagai tahap eksekusi, dari startup melalui status stabil. Ketika kompilasi berjenjang dinonaktifkan, setiap metode dikompilasi dengan satu cara yang bias terhadap performa status stabil atas performa startup.

Saat TC diaktifkan, perilaku berikut berlaku untuk kompilasi metode saat aplikasi dimulai:

  • Jika metode memiliki kode yang dikompilasi sebelumnya, atau ReadyToRun, kode yang dibuat sebelumnya digunakan.
  • Jika tidak, metode disingkirkan. Biasanya, metode ini bersifat generik atas jenis nilai.
    • JIT cepat menghasilkan kode berkualitas lebih rendah (atau kurang dioptimalkan) lebih cepat. Di .NET Core 3.0, Quick JIT diaktifkan secara default untuk metode yang tidak berisi perulangan dan lebih disukai selama startup.
    • JIT yang sepenuhnya mengoptimalkan menghasilkan kode berkualitas lebih tinggi (atau lebih dioptimalkan) lebih lambat. Untuk metode di mana Quick JIT tidak akan digunakan (misalnya, jika metode dikaitkan dengan MethodImplOptions.AggressiveOptimization), JIT yang sepenuhnya mengoptimalkan digunakan.

Untuk metode yang sering disebut, kompilator just-in-time akhirnya membuat kode yang dioptimalkan sepenuhnya di latar belakang. Kode yang dioptimalkan kemudian menggantikan kode yang telah dikompilasi sebelumnya untuk metode tersebut.

Kode yang dihasilkan oleh Quick JIT dapat berjalan lebih lambat, mengalokasikan lebih banyak memori, atau menggunakan lebih banyak ruang tumpukan. Jika ada masalah, Anda dapat menonaktifkan Quick JIT menggunakan properti MSBuild ini dalam file proyek:

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

Untuk menonaktifkan TC sepenuhnya, gunakan properti MSBuild ini di file proyek Anda:

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

Tip

Jika Anda mengubah pengaturan ini dalam file proyek, Anda mungkin perlu melakukan build bersih agar pengaturan baru tercermin (hapus obj direktori dan bin dan bangun ulang).

Untuk informasi selengkapnya tentang mengonfigurasi kompilasi pada waktu proses, lihat Opsi konfigurasi runtime untuk kompilasi.

Gambar ReadyToRun

Anda dapat meningkatkan waktu mulai aplikasi .NET Core Anda dengan mengkompilasi rakitan aplikasi Anda sebagai format ReadyToRun (R2R). R2R adalah bentuk kompilasi ahead-of-time (AOT).

Biner R2R meningkatkan performa startup dengan mengurangi jumlah pekerjaan yang perlu dilakukan kompilator just-in-time (JIT) sesuai beban aplikasi Anda. Biner berisi kode asli yang serupa dibandingkan dengan apa yang akan dihasilkan JIT. Namun, biner R2R lebih besar karena berisi kode bahasa perantara (IL), yang masih diperlukan untuk beberapa skenario, dan versi asli dari kode yang sama. R2R hanya tersedia saat Anda menerbitkan aplikasi mandiri yang menargetkan lingkungan runtime tertentu (RID) seperti Linux x64 atau Windows x64.

Untuk mengkompilasi proyek Anda sebagai ReadyToRun, lakukan hal berikut:

  1. <PublishReadyToRun> Tambahkan pengaturan ke proyek Anda:

    <PropertyGroup>
  <PublishReadyToRun>true</PublishReadyToRun>
</PropertyGroup>

  2. Menerbitkan aplikasi mandiri. Misalnya, perintah ini membuat aplikasi mandiri untuk Windows versi 64-bit:

    dotnet publish -c Release -r win-x64 --self-contained

Pembatasan lintas platform/arsitektur

Kompilator ReadyToRun saat ini tidak mendukung penargetan silang. Anda harus mengkompilasi pada target tertentu. Misalnya, jika Anda menginginkan gambar R2R untuk Windows x64, Anda perlu menjalankan perintah terbitkan di lingkungan tersebut.

Pengecualian untuk penargetan silang:

  • Windows x64 dapat digunakan untuk mengkompilasi gambar Windows Arm32, Arm64, dan x86.
  • Windows x86 dapat digunakan untuk mengkompilasi gambar Windows Arm32.
  • Linux x64 dapat digunakan untuk mengkompilasi gambar Linux Arm32 dan Arm64.

Untuk informasi selengkapnya, lihat Siap Dijalankan.

Runtime/SDK

Penerusan roll runtime versi utama

.NET Core 3.0 memperkenalkan fitur keikutsertaan yang memungkinkan aplikasi Anda untuk meneruskan ke versi utama terbaru .NET Core. Selain itu, pengaturan baru telah ditambahkan untuk mengontrol bagaimana roll forward diterapkan ke aplikasi Anda. Ini dapat dikonfigurasi dengan cara berikut:

  • Properti file proyek: RollForward
  • Properti file konfigurasi runtime: rollForward
  • Variabel Lingkungan: DOTNET_ROLL_FORWARD
  • Argumen baris perintah: --roll-forward

Salah satu nilai berikut harus ditentukan. Jika pengaturan dihilangkan, Minor adalah default.

  • LatestPatch
    Teruskan ke versi patch tertinggi. Tindakan ini menonaktifkan versi kecil gulung maju.
  • Kecil
    Teruskan ke versi minor terendah yang lebih tinggi, jika versi minor yang diminta hilang. Jika versi minor yang diminta ada, maka kebijakan LatestPatch digunakan.
  • Utama
    Teruskan ke versi utama terendah yang lebih tinggi, dan versi minor terendah, jika versi utama yang diminta hilang. Jika versi utama yang diminta ada, maka kebijakan Minor digunakan.
  • LatestMinor
    Teruskan ke versi minor tertinggi, bahkan jika versi minor yang diminta ada. Ditujukan untuk skenario hosting komponen.
  • LatestMajor
    Gulung maju ke versi minor tertinggi dan tertinggi, bahkan jika mayor yang diminta ada. Ditujukan untuk skenario hosting komponen.
  • Nonaktifkan
    Jangan bergulir ke depan. Hanya ikat ke versi yang ditentukan. Kebijakan ini tidak disarankan untuk penggunaan umum karena menonaktifkan kemampuan untuk gulung maju ke patch terbaru. Nilai ini hanya disarankan untuk pengujian.

Selain pengaturan Nonaktifkan, semua pengaturan akan menggunakan versi patch tertinggi yang tersedia.

Secara default, jika versi yang diminta (seperti yang ditentukan untuk .runtimeconfig.json aplikasi) adalah versi rilis, hanya versi rilis yang dipertimbangkan untuk roll forward. Setiap versi pra-rilis diabaikan. Jika tidak ada versi rilis yang cocok, versi pra-rilis akan diperhitungkan. Perilaku ini dapat diubah dengan mengatur DOTNET_ROLL_FORWARD_TO_PRERELEASE=1, dalam hal ini semua versi selalu dipertimbangkan.

Membangun dependensi salinan

Perintah dotnet build sekarang menyalin dependensi NuGet untuk aplikasi Anda dari cache NuGet ke folder output build. Sebelumnya, dependensi hanya disalin sebagai bagian dotnet publishdari .

Ada beberapa operasi, seperti pemangkasan dan penerbitan halaman pisau cukur, yang masih akan memerlukan penerbitan.

Alat lokal

.NET Core 3.0 memperkenalkan alat lokal. Alat lokal mirip dengan alat global tetapi dikaitkan dengan lokasi tertentu pada disk. Alat lokal tidak tersedia secara global dan didistribusikan sebagai paket NuGet.

Alat lokal mengandalkan nama dotnet-tools.json file manifes di direktori Anda saat ini. File manifes ini menentukan alat yang akan tersedia di folder tersebut dan di bawah ini. Anda dapat mendistribusikan file manifes dengan kode Anda untuk memastikan bahwa siapa pun yang bekerja dengan kode Anda dapat memulihkan dan menggunakan alat yang sama.

Untuk alat global dan lokal, diperlukan versi runtime yang kompatibel. Banyak alat saat ini pada target .NET Core Runtime 2.1 NuGet.org. Untuk menginstal alat ini secara global atau lokal, Anda masih perlu menginstal Runtime NET Core 2.1.

Opsi global.json baru

File global.json memiliki opsi baru yang memberikan lebih banyak fleksibilitas saat Anda mencoba menentukan versi .NET Core SDK mana yang digunakan. Opsi barunya adalah:

  • allowPrerelease: Menunjukkan apakah pemecah masalah SDK harus mempertimbangkan versi prarilis saat memilih versi SDK yang akan digunakan.
  • rollForward: Menunjukkan kebijakan roll-forward yang akan digunakan saat memilih versi SDK, baik sebagai fallback saat versi SDK tertentu hilang atau sebagai arahan untuk menggunakan versi yang lebih tinggi.

Untuk informasi selengkapnya tentang perubahan termasuk nilai default, nilai yang didukung, dan aturan pencocokan baru, lihat gambaran umum global.json.

Ukuran tumpukan Pengumpulan Sampah yang Lebih Kecil

Ukuran tumpukan default Pengumpul Sampah telah berkurang sehingga menghasilkan .NET Core menggunakan lebih sedikit memori. Perubahan ini lebih selaras dengan anggaran alokasi generasi 0 dengan ukuran cache prosesor modern.

Dukungan Halaman Besar Pengumpulan Sampah

Halaman Besar (juga dikenal sebagai Halaman Besar di Linux) adalah fitur di mana sistem operasi dapat menetapkan wilayah memori yang lebih besar dari ukuran halaman asli (seringkali 4K) untuk meningkatkan performa aplikasi yang meminta halaman besar ini.

Pengumpul Sampah sekarang dapat dikonfigurasi dengan pengaturan GCLargePages sebagai fitur keikutsertaan untuk memilih untuk mengalokasikan halaman besar di Windows.

Windows Desktop &COM

Penginstal Windows .NET Core SDK

Penginstal MSI untuk Windows telah berubah dimulai dengan .NET Core 3.0. Alat penginstal SDK sekarang akan meningkatkan rilis pita fitur SDK di tempat. Pita fitur didefinisikan dalam ratusan grup di bagian patch dari nomor versi. Misalnya, 3.0.101 dan 3.0.201 adalah versi dalam dua band fitur yang berbeda sementara 3.0.101 dan 3.0.199 berada di band fitur yang sama. Dan, ketika .NET Core SDK 3.0.101 diinstal, .NET Core SDK 3.0.100 akan dihapus dari mesin jika ada. Saat .NET Core SDK 3.0.200 diinstal pada komputer yang sama, .NET Core SDK 3.0.101 tidak akan dihapus.

Untuk informasi selengkapnya tentang penerapan versi, lihat Gambaran umum tentang bagaimana .NET Core diversikan.

Desktop Windows

.NET Core 3.0 mendukung aplikasi desktop Windows menggunakan Windows Presentation Foundation (WPF) dan Formulir Windows. Kerangka kerja ini juga mendukung penggunaan kontrol modern dan Gaya lancar dari Windows UI XAML Library (WinUI) melalui kepulauan XAML.

Komponen Windows Desktop adalah bagian dari Windows .NET Core 3.0 SDK.

Anda dapat membuat aplikasi WPF atau Formulir Windows baru dengan perintah berikutdotnet:

dotnet new wpf
dotnet new winforms

Visual Studio 2019 menambahkan templat Proyek Baru untuk .NET Core 3.0 Formulir Windows dan WPF.

Untuk informasi selengkapnya tentang cara mem-port aplikasi .NET Framework yang ada, lihat Proyek Port WPF dan proyek Port Formulir Windows.

WinForms DPI tinggi

Aplikasi .NET Core Formulir Windows dapat mengatur mode DPI tinggi dengan Application.SetHighDpiMode(HighDpiMode). Metode SetHighDpiMode ini mengatur mode DPI tinggi yang sesuai kecuali pengaturan telah diatur oleh cara lain seperti App.Manifest atau P/Panggil sebelum Application.Run.

Nilai yang mungkin highDpiMode , seperti yang dinyatakan System.Windows.Forms.HighDpiMode oleh enum adalah:

  • DpiUnaware
  • SystemAware
  • PerMonitor
  • PerMonitorV2
  • DpiUnawareGdiScaled

Untuk informasi selengkapnya tentang mode DPI tinggi, lihat Pengembangan Aplikasi Desktop DPI Tinggi di Windows.

Membuat komponen COM

Di Windows, Anda sekarang dapat membuat komponen terkelola yang dapat dipanggil COM. Kemampuan ini sangat penting untuk menggunakan .NET Core dengan model add-in COM dan juga untuk memberikan paritas dengan .NET Framework.

Tidak seperti .NET Framework tempat mscoree.dll digunakan sebagai server COM, .NET Core akan menambahkan dll peluncur asli ke direktori bin saat Anda membangun komponen COM Anda.

Untuk contoh cara membuat komponen COM dan menggunakannya, lihat Demo COM.

Interop Asli Windows

Windows menawarkan API asli yang kaya dalam bentuk API C datar, COM, dan WinRT. Sementara .NET Core mendukung P/Invoke, .NET Core 3.0 menambahkan kemampuan untuk Membuat CoCreate COM API dan Mengaktifkan API WinRT. Untuk contoh kode, lihat Demo Excel.

Penyebaran MSIX

MSIX adalah format paket aplikasi Windows baru. Ini dapat digunakan untuk menyebarkan aplikasi desktop .NET Core 3.0 ke Windows 10.

Proyek Pengemasan Aplikasi Windows, yang tersedia di Visual Studio 2019, memungkinkan Anda membuat paket MSIX dengan aplikasi .NET Core mandiri.

File proyek .NET Core harus menentukan runtime yang didukung dalam <RuntimeIdentifiers> properti :

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

Peningkatan Linux

SerialPort untuk Linux

.NET Core 3.0 menyediakan dukungan dasar untuk System.IO.Ports.SerialPort di Linux.

Sebelumnya, .NET Core hanya didukung menggunakan SerialPort pada Windows.

Untuk informasi selengkapnya tentang dukungan terbatas untuk port serial di Linux, lihat masalah GitHub #33146.

Batas memori Docker dan cgroup

Menjalankan .NET Core 3.0 di Linux dengan Docker berfungsi lebih baik dengan batas memori cgroup. Menjalankan kontainer Docker dengan batas memori, seperti dengan docker run -m, mengubah perilaku .NET Core.

  • Ukuran tumpukan Pengumpul Sampah Default (GC): maksimum 20 mb atau 75% dari batas memori pada kontainer.
  • Ukuran eksplisit dapat ditetapkan sebagai angka absolut atau persentase batas grup grup.
  • Ukuran segmen minimum yang dipesan per tumpukan GC adalah 16 mb. Ukuran ini mengurangi jumlah timbunan yang dibuat pada komputer.

Dukungan GPIO untuk Raspberry Pi

Dua paket telah dirilis ke NuGet yang dapat Anda gunakan untuk pemrograman GPIO:

Paket GPIO mencakup API untuk perangkat GPIO, SPI, I2C, dan PWM . Paket pengikatan IoT mencakup pengikatan perangkat. Untuk informasi selengkapnya, lihat repositori GitHub perangkat.

Dukungan Arm64 Linux

.NET Core 3.0 menambahkan dukungan untuk Arm64 untuk Linux. Kasus penggunaan utama untuk Arm64 saat ini dengan skenario IoT. Untuk informasi selengkapnya, lihat Status .NET Core Arm64.

Gambar Docker untuk .NET Core di Arm64 tersedia untuk Alpine, Debian, dan Ubuntu.

Catatan

Dukungan untuk sistem operasi macOS Arm64 (atau "Apple Silicon") dan Windows Arm64 kemudian ditambahkan di .NET 6.

Keamanan

TLS 1.3 & OpenSSL 1.1.1 di Linux

.NET Core sekarang memanfaatkan dukungan TLS 1.3 di OpenSSL 1.1.1, ketika tersedia di lingkungan tertentu. Dengan TLS 1.3:

  • Koneksi waktu ditingkatkan dengan pengurangan perjalanan pulang pergi yang diperlukan antara klien dan server.
  • Peningkatan keamanan karena penghapusan berbagai algoritma kriptografi yang usang dan tidak aman.

Jika tersedia, .NET Core 3.0 menggunakan OpenSSL 1.1.1, OpenSSL 1.1.0, atau OpenSSL 1.0.2 pada sistem Linux. Ketika OpenSSL 1.1.1 tersedia, kedua System.Net.Security.SslStream jenis dan System.Net.Http.HttpClient akan menggunakan TLS 1.3 (dengan asumsi klien dan server mendukung TLS 1.3).

Contoh C# 8.0 berikut menunjukkan .NET Core 3.0 pada Ubuntu 18.10 yang menyambungkan ke 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}");
        }
    }
}

Sandi kriptografi

.NET Core 3.0 menambahkan dukungan untuk cipher AES-GCM dan AES-CCM , yang diimplementasikan dengan System.Security.Cryptography.AesGcm dan System.Security.Cryptography.AesCcm masing-masing. Algoritma ini adalah algoritma Enkripsi Terautentikasi dengan Data Asosiasi (AEAD).

Kode berikut menunjukkan penggunaan AesGcm cipher untuk mengenkripsi dan mendekripsi data acak.

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.");
        }
    }
}

Impor/Ekspor Kunci Kriptografi

.NET Core 3.0 mendukung impor dan ekspor kunci publik dan privat asimetris dari format standar. Anda tidak perlu menggunakan sertifikat X.509.

Semua jenis kunci, seperti RSA, DSA, ECDsa, dan ECDiffieHellman, mendukung format berikut:

  • Kunci Umum

    • X.509 SubjectPublicKeyInfo

  • Kunci privat

    • PKCS#8 PrivateKeyInfo
    • PKCS#8 EncryptedPrivateKeyInfo

Kunci RSA juga mendukung:

  • Kunci Umum

    • PKCS#1 RSAPublicKey

  • Kunci privat

    • PKCS#1 RSAPrivateKey

Metode ekspor menghasilkan data biner yang dikodekan DER, dan metode impor mengharapkan hal yang sama. Jika kunci disimpan dalam format PEM yang ramah teks, pemanggil harus mendekode konten base64 sebelum memanggil metode impor.

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

File PKCS#8 dapat diperiksa dengan System.Security.Cryptography.Pkcs.Pkcs8PrivateKeyInfo file PFX/PKCS#12 dapat diperiksa dengan System.Security.Cryptography.Pkcs.Pkcs12Info. File PFX/PKCS#12 dapat dimanipulasi dengan System.Security.Cryptography.Pkcs.Pkcs12Builder.

Perubahan API .NET Core 3.0

Rentang dan indeks

Jenis baru System.Index dapat digunakan untuk pengindeksan. Anda dapat membuatnya dari int yang dihitung dari awal, atau dengan operator awalan ^ (C#) yang dihitung dari akhir:

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"

Ada juga System.Range jenisnya, yang terdiri dari dua Index nilai, satu untuk awal dan satu untuk akhir, dan dapat ditulis dengan x..y ekspresi rentang (C#). Anda kemudian dapat mengindeks Rangedengan , yang menghasilkan iringan:

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

Untuk informasi selengkapnya, lihat tutorial rentang dan indeks.

Aliran asinkron

Jenisnya IAsyncEnumerable<T> adalah versi asinkron baru dari IEnumerable<T>. Bahasa ini memungkinkan Anda await foreach untuk IAsyncEnumerable<T> mengonsumsi elemennya, dan menggunakannya yield return untuk menghasilkan elemen.

Contoh berikut menunjukkan produksi dan konsumsi aliran asinkron. Pernyataan foreach ini asinkron dan sendiri digunakan yield return untuk menghasilkan aliran asinkron untuk penelepon. Pola ini (menggunakan yield return) adalah model yang direkomendasikan untuk menghasilkan aliran asinkron.

async IAsyncEnumerable<int> GetBigResultsAsync()
{
    await foreach (var result in GetResultsAsync())
    {
        if (result > 20) yield return result;
    }
}

Selain dapat await foreach, Anda juga dapat membuat iterator asinkron, misalnya, iterator yang mengembalikan IAsyncEnumerable/IAsyncEnumerator yang dapat Anda dan awaityield masuk. Untuk objek yang perlu dibuang, Anda dapat menggunakan IAsyncDisposable, yang diterapkan berbagai jenis BCL, seperti Stream dan Timer.

Untuk informasi selengkapnya, lihat tutorial aliran asinkron.

Titik Mengambang IEEE

API floating point sedang diperbarui untuk mematuhi revisi IEEE 754-2008. Tujuan dari perubahan ini adalah untuk mengekspos semua operasi yang diperlukan dan memastikan bahwa mereka mematuhi spesifikasi IEEE secara perilaku. Untuk informasi selengkapnya tentang peningkatan floating-point, lihat peningkatan Penguraian dan Pemformatan Floating-Point dalam posting blog .NET Core 3.0 .

Perbaikan penguraian dan pemformatan meliputi:

  • Mengurai dengan benar dan membulatkan input dengan panjang apa pun.
  • Uraikan dan format nol negatif dengan benar.
  • Uraikan dengan benar Infinity dan NaN dengan melakukan pemeriksaan tidak peka huruf besar/kecil dan memungkinkan pendahuluan + opsional jika berlaku.

API baru System.Math meliputi:

  • BitIncrement(Double) dan BitDecrement(Double)
    Sesuai dengan nextUp operasi dan nextDown IEEE. Mereka mengembalikan angka floating-point terkecil yang membandingkan lebih besar atau kurang dari input (masing-masing). Misalnya, Math.BitIncrement(0.0) akan mengembalikan double.Epsilon.

  • MaxMagnitude(Double, Double) dan MinMagnitude(Double, Double)
    Sesuai dengan maxNumMag operasi dan minNumMag IEEE, mereka mengembalikan nilai yang lebih besar atau lebih kecil dari dua input (masing-masing). Misalnya, Math.MaxMagnitude(2.0, -3.0) akan mengembalikan -3.0.

  • ILogB(Double)
    logB Sesuai dengan operasi IEEE yang mengembalikan nilai integral, ia mengembalikan log basis-2 integral dari parameter input. Metode ini secara efektif sama floor(log2(x))dengan , tetapi dilakukan dengan kesalahan pembulatan minimal.

  • ScaleB(Double, Int32)
    scaleB Sesuai dengan operasi IEEE yang mengambil nilai integral, itu mengembalikan secara x * pow(2, n)efektif , tetapi dilakukan dengan kesalahan pembulatan minimal.

  • Log2(Double)
    log2 Sesuai dengan operasi IEEE, ia mengembalikan logaritma base-2. Ini meminimalkan kesalahan pembulatan.

  • FusedMultiplyAdd(Double, Double, Double)
    fma Sesuai dengan operasi IEEE, ia melakukan penambahan perkalian yang menyatu. Artinya, ini dilakukan (x * y) + z sebagai operasi tunggal, sehingga meminimalkan kesalahan pembulatan. Contohnya adalah FusedMultiplyAdd(1e308, 2.0, -1e308), yang mengembalikan 1e308. Reguler (1e308 * 2.0) - 1e308 mengembalikan double.PositiveInfinity.

  • CopySign(Double, Double)
    copySign Sesuai dengan operasi IEEE, ia mengembalikan nilai x, tetapi dengan tanda y.

.NET Platform-Dependen Intrinsics

API telah ditambahkan yang memungkinkan akses ke instruksi CPU berorientasi perf tertentu, seperti set instruksi SIMD atau Bit Manipulation. Instruksi ini dapat membantu mencapai peningkatan performa yang signifikan dalam skenario tertentu, seperti memproses data secara efisien secara paralel.

Jika sesuai, pustaka .NET telah mulai menggunakan instruksi ini untuk meningkatkan performa.

Untuk informasi selengkapnya, lihat .NET Platform-Dependent Intrinsics.

API Versi .NET Core yang Ditingkatkan

Dimulai dengan .NET Core 3.0, API versi yang disediakan dengan .NET Core sekarang mengembalikan informasi yang Anda harapkan. Contohnya:

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

Peringatan

Melanggar perubahan. Ini secara teknis merupakan perubahan yang melanggar karena skema penerapan versi telah berubah.

Dukungan JSON bawaan yang cepat

Pengguna .NET sebagian besar mengandalkan Newtonsoft.Json dan pustaka JSON populer lainnya, yang terus menjadi pilihan yang baik. Newtonsoft.Json menggunakan string .NET sebagai jenis data dasarnya, yaitu UTF-16 di bawah kap.

Dukungan JSON bawaan baru berkinerja tinggi, alokasi rendah, dan berfungsi dengan teks JSON yang dikodekan UTF-8. Untuk informasi selengkapnya tentang System.Text.Json namespace dan jenis, lihat artikel berikut ini:

Dukungan HTTP/2

Jenis ini System.Net.Http.HttpClient mendukung protokol HTTP/2. Jika HTTP/2 diaktifkan, versi protokol HTTP dinegosiasikan melalui TLS/ALPN, dan HTTP/2 digunakan jika server memilih untuk menggunakannya.

Protokol default tetap HTTP/1.1, tetapi HTTP/2 dapat diaktifkan dengan dua cara berbeda. Pertama, Anda dapat mengatur pesan permintaan HTTP untuk menggunakan 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);

Kedua, Anda dapat mengubah HttpClient untuk menggunakan HTTP/2 secara 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);

Sering kali ketika Anda mengembangkan aplikasi, Anda ingin menggunakan koneksi yang tidak terenkripsi. Jika Anda tahu titik akhir target akan menggunakan HTTP/2, Anda dapat mengaktifkan koneksi yang tidak terenkripsi untuk HTTP/2. Anda dapat mengaktifkannya dengan mengatur DOTNET_SYSTEM_NET_HTTP_SOCKETSHTTPHANDLER_HTTP2UNENCRYPTEDSUPPORT variabel lingkungan ke 1 atau dengan mengaktifkannya dalam konteks aplikasi:

AppContext.SetSwitch("System.Net.Http.SocketsHttpHandler.Http2UnencryptedSupport", true);

Langkah berikutnya