Performance dina .NET Core
Halo sadayana! Tulisan ieu mangrupikeun kumpulan Praktek Pangalusna anu kuring sareng kolega kuring parantos lami dianggo nalika damel dina sababaraha proyék.
Inpormasi ngeunaan mesin dimana itungan dilaksanakeun:BenchmarkDotNet=v0.11.5, OS=Windows 10.0.18362
Intel Core i5-8250U CPU 1.60GHz (Kaby Lake Sunda), 1 CPU, 8 logis sareng 4 inti fisik
.NET Core SDK = 3.0.100
[Host]: .NET Core 2.2.7 (CoreCLR 4.6.28008.02, CoreFX 4.6.28008.03), 64bit RyuJIT
Inti: .NET Core 2.2.7 (CoreCLR 4.6.28008.02, CoreFX 4.6.28008.03), 64bit RyuJIT
[Host]: .NET Core 3.0.0 (CoreCLR 4.700.19.46205, CoreFX 4.700.19.46214), 64bit RyuJIT
Inti: .NET Core 3.0.0 (CoreCLR 4.700.19.46205, CoreFX 4.700.19.46214), 64bit RyuJIT
Pakasaban = Inti Runtime = Inti
ToList vs ToArray sareng Siklus
Abdi ngarencanakeun nyiapkeun inpormasi ieu kalayan sékrési .NET Core 3.0, tapi aranjeunna ngéléhkeun kuring, kuring henteu hoyong maok kamulyaan batur sareng nyalin inpormasi jalma sanés, janten kuring ngan ukur nunjukkeun. .
Atas nama kuring sorangan, kuring ngan ukur hoyong nampilkeun ka anjeun pangukuran sareng hasil kuring; Kuring nambihan puteran ngabalikkeun ka aranjeunna pikeun anu resep "gaya C ++" puteran tulisan.
kode:
public class Bench
{
private List<int> _list;
private int[] _array;
[Params(100000, 10000000)] public int N;
[GlobalSetup]
public void Setup()
{
const int MIN = 1;
const int MAX = 10;
Random random = new Random();
_list = Enumerable.Repeat(0, N).Select(i => random.Next(MIN, MAX)).ToList();
_array = _list.ToArray();
}
[Benchmark]
public int ForList()
{
int total = 0;
for (int i = 0; i < _list.Count; i++)
{
total += _list[i];
}
return total;
}
[Benchmark]
public int ForListFromEnd()
{
int total = 0;t
for (int i = _list.Count-1; i > 0; i--)
{
total += _list[i];
}
return total;
}
[Benchmark]
public int ForeachList()
{
int total = 0;
foreach (int i in _list)
{
total += i;
}
return total;
}
[Benchmark]
public int ForeachArray()
{
int total = 0;
foreach (int i in _array)
{
total += i;
}
return total;
}
[Benchmark]
public int ForArray()
{
int total = 0;
for (int i = 0; i < _array.Length; i++)
{
total += _array[i];
}
return total;
}
[Benchmark]
public int ForArrayFromEnd()
{
int total = 0;
for (int i = _array.Length-1; i > 0; i--)
{
total += _array[i];
}
return total;
}
}
speeds kinerja di .NET Core 2.2 jeung 3.0 ampir identik. Ieu naon anu kuring tiasa kéngingkeun dina .NET Core 3.0:
Urang tiasa nyimpulkeun yén ngolah iteratif tina kumpulan Array langkung gancang kusabab optimasi internal sareng alokasi ukuran koleksi anu eksplisit. Éta ogé patut émut yén koleksi Daptar gaduh kaunggulan sorangan sareng anjeun kedah nganggo koleksi anu leres gumantung kana itungan anu diperyogikeun. Sanaos anjeun nyerat logika pikeun damel sareng puteran, tong hilap yén ieu mangrupikeun loop biasa sareng éta ogé tunduk kana optimasi loop anu mungkin. Hiji artikel diterbitkeun dina habr geus lila pisan: . Éta masih relevan sareng disarankeun maca.
Alungan
Sataun ka tukang, kuring digawé di hiji pausahaan dina proyék warisan, dina proyék éta normal pikeun ngolah validasi widang ngaliwatan coba-nyekel-ngalungkeun nyusunna. Kuring parantos ngartos yén ieu mangrupikeun logika bisnis anu teu séhat pikeun proyék éta, janten upami mungkin kuring nyobian henteu nganggo desain sapertos kitu. Tapi hayu urang terang naha pendekatan pikeun nanganan kasalahan sareng konstruksi sapertos kitu goréng. Kuring nulis kode leutik pikeun ngabandingkeun dua pendekatan jeung dijieun tolok ukur pikeun tiap pilihan.
kode:
public bool ContainsHash()
{
bool result = false;
foreach (var file in _files)
{
var extension = Path.GetExtension(file);
if (_hash.Contains(extension))
result = true;
}
return result;
}
public bool ContainsHashTryCatch()
{
bool result = false;
try
{
foreach (var file in _files)
{
var extension = Path.GetExtension(file);
if (_hash.Contains(extension))
result = true;
}
if(!result)
throw new Exception("false");
}
catch (Exception e)
{
result = false;
}
return result;
}Hasilna dina .NET Core 3.0 sareng Core 2.2 gaduh hasil anu sami (.NET Core 3.0):
Coba nyekel ngajadikeun kode harder ngartos tur ngaronjatkeun waktu palaksanaan program Anjeun. Tapi upami anjeun peryogi konstruksi ieu, anjeun henteu kedah nyelapkeun garis-garis kode anu henteu dipiharep tiasa ngadamel kasalahan - ieu bakal ngajantenkeun kodeu langkung gampang kahartos. Kanyataanna, teu jadi loba penanganan iwal nu ngamuat sistem, tapi rada ngalungkeun kasalahan sorangan ngaliwatan lémparan konstruksi Exception anyar.
Ngalungkeun iwal leuwih laun ti sababaraha kelas anu bakal ngumpulkeun kasalahan dina format diperlukeun. Upami anjeun ngolah formulir atanapi sababaraha data sareng anjeun terang terang naon kasalahanana, naha henteu ngolah éta?
Anjeun teu kudu nulis lémparan Iwal anyar () ngawangun lamun kaayaan ieu teu luar biasa. Nanganan sareng ngalungkeun pengecualian mahal pisan !!!
ToLower, ToLowerInvariant, ToUpper, ToUpperInvariant
Leuwih 5 taun pangalaman kuring dipake dina platform .NET, Kuring geus datang di sakuliah loba proyék nu dipaké string cocog. Kuring ogé ningali gambar di handap ieu: aya hiji solusi perusahaan sareng seueur proyék, masing-masing ngalaksanakeun perbandingan string anu béda. Tapi naon anu kedah dianggo sareng kumaha ngahijikeunana? Dina buku CLR via C # ku Richter, Kuring maca informasi yén ToUpperInvariant () métode téh gancang ti ToLowerInvariant ().
Petikan tina buku:
Tangtosna, kuring henteu percanten sareng mutuskeun pikeun ngajalankeun sababaraha tés teras dina .NET Framework sareng hasilna ngajempolan kuring - langkung ti 15% paningkatan kinerja. Teras, nalika dugi ka damel isuk-isuk, kuring nunjukkeun pangukuran ieu ka atasan kuring sareng masihan aranjeunna aksés kana kode sumber. Saatos ieu, 2 ti 14 proyék dirobih pikeun nampung pangukuran énggal, sareng nimbangkeun yén dua proyék ieu aya pikeun ngolah tabel Excel anu ageung, hasilna langkung penting pikeun produk.
Kuring ogé nampilkeun ka anjeun ukuran pikeun vérsi anu béda tina .NET Core, ku kituna unggal anjeun tiasa ngadamel pilihan pikeun solusi anu paling optimal. Sarta kuring ngan hoyong tambahkeun yen di parusahaan tempat kuring gawe, kami nganggo ToUpper () pikeun ngabandingkeun string.
kode:
public const string defaultString = "VXTDuob5YhummuDq1PPXOHE4PbrRjYfBjcHdFs8UcKSAHOCGievbUItWhU3ovCmRALgdZUG1CB0sQ4iMj8Z1ZfkML2owvfkOKxBCoFUAN4VLd4I8ietmlsS5PtdQEn6zEgy1uCVZXiXuubd0xM5ONVZBqDu6nOVq1GQloEjeRN8jXrj0MVUexB9aIECs7caKGddpuut3";
[Benchmark]
public bool ToLower()
{
return defaultString.ToLower() == defaultString.ToLower();
}
[Benchmark]
public bool ToLowerInvariant()
{
return defaultString.ToLowerInvariant() == defaultString.ToLowerInvariant();
}
[Benchmark]
public bool ToUpper()
{
return defaultString.ToUpper() == defaultString.ToUpper();
}
[Benchmark]
public bool ToUpperInvariant()
{
return defaultString.ToUpperInvariant() == defaultString.ToUpperInvariant();
}
Dina .NET Core 3.0, kanaékan unggal sahiji metodeu ieu ~x2 sarta saimbang palaksanaan diantara sorangan.
Kompilasi Tier
Dina artikel panungtungan kuring ngajelaskeun fungsionalitas ieu sakeudeung, Abdi hoyong ngabenerkeun sarta suplement kecap abdi. Kompilasi multi-tingkat nyepetkeun waktos ngamimitian solusi anjeun, tapi anjeun ngorbankeun bagian-bagian kode anjeun bakal disusun kana versi anu langkung dioptimalkeun di latar tukang, anu tiasa ngenalkeun overhead leutik. Kalayan munculna NET Core 3.0, waktos ngawangun pikeun proyék-proyék kalayan kompilasi tingkatan diaktipkeun parantos ngirangan sareng bug anu aya hubunganana sareng téknologi ieu parantos dibenerkeun. Saméméhna, téhnologi ieu ngakibatkeun kasalahan dina requests munggaran di ASP.NET Core na freezes salila ngawangun munggaran dina modeu kompilasi multi-tingkat. Ayeuna diaktipkeun sacara standar di .NET Core 3.0, tapi anjeun tiasa nganonaktipkeun upami anjeun hoyong. Upami anjeun aya dina posisi kalungguhan tim, senior, tengah, atanapi anjeun kapala jabatan, maka anjeun kedah ngartos yén pamekaran proyék gancang ningkatkeun nilai tim sareng téknologi ieu bakal ngamungkinkeun anjeun ngahémat waktos pikeun duanana pamekar. jeung waktu proyék sorangan.
.NET tingkat nepi
Ningkatkeun versi .NET Framework / .NET Core anjeun. Mindeng, unggal versi anyar nyadiakeun gains kinerja tambahan sarta nambahkeun fitur anyar.
Tapi naon sabenerna mangpaat? Hayu urang tingali sababaraha di antarana:
- .NET Core 3.0 ngenalkeun gambar R2R anu bakal ngirangan waktos ngamimitian aplikasi .NET Core.
- Kalayan vérsi 2.2, Tier Compilation némbongan, hatur nuhun anu programer bakal nyéépkeun waktos sakedik pikeun ngaluncurkeun proyék.
- Rojongan pikeun Standar .NET anyar.
- Rojongan pikeun versi anyar tina basa program.
- Optimasi, kalayan unggal versi anyar optimasi perpustakaan dasar Koléksi / Struktur / Stream / String / Regex sareng seueur deui ningkatkeun. Upami anjeun hijrah tina .NET Framework ka .NET Core, anjeun bakal nampi dorongan kinerja anu ageung. Salaku conto, kuring ngagantelkeun tumbu ka sababaraha optimizations nu ditambahkeun kana .NET Core 3.0:
kacindekan
Nalika nulis kode, éta patut nengetan sababaraha aspék proyék anjeun sareng nganggo fitur basa program sareng platform anjeun pikeun ngahontal hasil anu pangsaéna. Abdi janten bungah lamun babagi pangaweruh Anjeun patali optimasi di .NET.
sumber: www.habr.com