Performansa di .NET Core
Silav hemû! Ev gotar berhevokek Pratîkên çêtirîn e ku ez û hevkarên xwe ji demek dirêj ve dema ku li ser projeyên cûda dixebitin bikar tînin.
Agahdariya li ser makîneya ku hesabên li ser hatine kirin:BenchmarkDotNet=v0.11.5, OS=Windows 10.0.18362
Intel Core i5-8250U CPU 1.60GHz (Kaby Lake R), 1 CPU, 8 mentiqî û 4 core laşî
.NET Core SDK=3.0.100
[Host]: .NET Core 2.2.7 (CoreCLR 4.6.28008.02, CoreFX 4.6.28008.03), 64bit RyuJIT
Core: .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
Core: .NET Core 3.0.0 (CoreCLR 4.700.19.46205, CoreFX 4.700.19.46214), 64bit RyuJIT
Kar=Dema xebitandinê ya bingehîn=Navkî
ToList vs ToArray û Cycles
Min plan kir ku bi berdana .NET Core 3.0 re vê agahiyê amade bikim, lê wan li min xistin, ez naxwazim rûmeta yekî din bidizim û agahdariya kesên din kopî bikim, ji ber vê yekê ez ê tenê destnîşan bikim. .
Li ser navê xwe, ez tenê dixwazim pîvandin û encamên xwe pêşkêşî we bikim, ji bo hezkiriyên "şêwaza C++" ya xelekên nivîsandinê.
Navê dizî:
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;
}
}
Leza performansê di .NET Core 2.2 û 3.0 de hema hema yek in. Li vir tiştê ku min karîbû di .NET Core 3.0 de bi dest bixim:
Em dikarin encam bidin ku pêvajoyek dubare ya berhevokek Array ji ber xweşbîniyên hundurîn û veqetandina mezinahiya berhevokê ya eşkere bileztir e. Her weha hêja ye ku ji bîr mekin ku berhevokek Lîsteyê avantajên xwe hene û divê hûn li gorî hesabên pêwîst berhevoka rast bikar bînin. Tewra ku hûn mantiqê ji bo xebata bi lûkan re binivîsin, ji bîr nekin ku ev xelekek asayî ye û di heman demê de bi optimîzasyona mimkun a loopê ve girêdayî ye. Beriya demeke dirêj li ser habrê gotarek hat weşandin: . Ew hîn jî têkildar e û xwendinê tê pêşniyar kirin.
Avêtin
Salek berê, ez li pargîdaniyek li ser projeyek mîras xebitîm, di wê projeyê de normal bû ku meriv erêkirina zeviyê bi avahiyek ceribandin-kişandin-avêtinê re pêvajoyê bike. Wê hingê min berê fêm kir ku ev ji bo projeyê mantiqa karsaziya netendurist bû, ji ber vê yekê gava ku gengaz bû min hewl da ku sêwiranek wusa bikar nekim. Lê em fêhm bikin ka çima nêzîkatiya birêvebirina xeletiyan bi avahiyek wusa xirab e. Min kodek piçûk nivîsand ku du nêzîkatiyan berhev bikim û ji bo her vebijarkê pîvan çêkir.
Navê dizî:
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;
}Encamên di .NET Core 3.0 û Core 2.2 de encamek wekhev heye (.NET Core 3.0):
Biceribînin girtina kodê famkirina kodê dijwartir dike û dema pêkanîna bernameya we zêde dike. Lê heke hûn hewceyê vê avakirinê bin, divê hûn wan rêzikên kodê yên ku ne li bendê ne ku xeletiyan bi rê ve bibin têxin - ev ê fêhmkirina kodê hêsantir bike. Di rastiyê de, ne ew qas hilgirtina îstîsnayan e ku pergalê bar dike, lê ji bilî avêtina xeletiyan bixwe bi navgîniya avêtina avahiyek nû ya Îstîsnayê.
Avêtina îstîsnayan ji hin pola ku dê xeletiyê di forma hewce de berhev bike hêdîtir e. Ger hûn formek an hin daneyan hildiberînin û hûn bi eşkere dizanin ku xeletî çi be, çima wê pêvajo nekin?
Ger ev rewş ne awarte be, divê hûn avahiyek nû ya avêtina Îstîsna() nenivîsin. Destekirin û avêtina îstisnayekê pir biha ye!!!
ToLower, ToLowerInvariant, ToUpper, ToUpperInvariant
Di serpêhatiya min a 5 salan de ku li ser platforma .NET-ê dixebitim, ez rastî gelek projeyên ku hevberdana rêzan bikar anîne de hatim. Min wêneya jêrîn jî dît: çareseriyek Enterprise bi gelek projeyan re hebû, ku her yek ji wan berhevokên rêzan cûda pêk anî. Lê divê çi were bikar anîn û meriv wê çawa bike yek? Di pirtûka CLR bi rêya C# ya Richter de, min agahdarî xwend ku rêbaza ToUpperInvariant() ji ToLowerInvariant() zûtir e.
Beşek ji pirtûkê:
Bê guman, min jê bawer nekir û biryar da ku hin ceribandinan li ser .NET Framework bimeşînim û encam ez şok kirim - ji% 15 zêdekirina performansê. Dûv re, sibeha din dema ku ez hatim ser kar, min van pîvanan nîşanî serekên xwe da û gihandina koda çavkaniyê da wan. Piştî vê yekê, 2 ji 14 projeyan hatin guheztin da ku pîvandinên nû bicîh bînin, û ji ber ku ev her du proje hebûn ku tabloyên mezin ên Excel-ê bişopînin, encam ji bo hilberê bêtir girîng bû.
Ez pîvanên ji bo guhertoyên cihêreng ên .NET Core jî pêşkêşî we dikim, da ku her yek ji we bikaribe berbi çareseriya herî çêtirîn vebijarkek bike. Û ez tenê dixwazim lê zêde bikim ku di pargîdaniya ku ez lê dixebitim, em ToUpper() bikar tînin da ku rêzan bidin hev.
Navê dizî:
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();
}
Di .NET Core 3.0 de, zêdebûna her yek ji van rêbazan ~x2 ye û pêkanînan di nav xwe de hevseng dike.
Berhevkirina Tier
Di gotara xweya paşîn de min bi kurtasî vê fonksiyonê diyar kir, ez dixwazim gotinên xwe rast û temam bikim. Berhevkirina pir-astî dema destpêkirina çareseriya we bileztir dike, lê hûn qurban dikin ku beşên koda we dê di paşerojê de di guhertoyek xweştirkirî de werin berhev kirin, ku dikare serkêşiyek piçûk destnîşan bike. Bi hatina NET Core 3.0 re, dema çêkirinê ji bo projeyên bi berhevkirina rêzê ve hatî çalak kirin kêm bûye û xeletiyên bi vê teknolojiyê re têkildar hatine rast kirin. Berê, vê teknolojiyê di daxwazên yekem ên ASP.NET Core de rê li ber xeletiyan girt û di dema avakirina yekem de di moda berhevkirina pir-ast de dicemidîne. Ew niha di .NET Core 3.0 de ji hêla xwerû ve hatî çalak kirin, lê heke hûn bixwazin hûn dikarin wê neçalak bikin. Ger hûn di pozîsyona serokê tîmê de ne, pîr, navîn, an hûn serokê beşê ne, wê hingê divê hûn fêm bikin ku pêşkeftina bilez a projeyê nirxa tîmê zêde dike û ev teknolojî dê bihêle ku hûn ji bo her du pêşdebiran dem bihêlin. û dema projeyê bixwe ye.
.NET asta bilind
Guhertoya .NET Framework / .NET Core-ya xwe nûve bikin. Bi gelemperî, her guhertoya nû destkeftiyên performansa zêde peyda dike û taybetmendiyên nû lê zêde dike.
Lê tam feydeyên wê çi ne? Ka em li hin ji wan binêrin:
- .NET Core 3.0 wêneyên R2R destnîşan kir ku dê dema destpêkirina sepanên .NET Core kêm bike.
- Bi guhertoya 2.2-ê, Berhevkirina Tier xuya bû, bi saya kîjan bernameçêker dê kêmtir wext bidin destpêkirina projeyekê.
- Piştgiriya ji bo standardên nû .NET.
- Piştgiriya guhertoyek nû ya zimanê bernamekirinê.
- Optimîzasyon, bi her guhertoya nû re xweşbîniya pirtûkxaneyên bingehîn Kolek / Avahî / Stream / String / Regex û hêj bêtir çêtir dibe. Ger hûn ji .NET Framework berbi .NET Core ve diçin, hûn ê performansek mezin ji qutiyê bistînin. Wek mînak, ez girêdanek bi hin xweşbîniyên ku li .NET Core 3.0 hatine zêdekirin ve girêdidim:
encamê
Dema ku kodê dinivîsin, hêja ye ku bala xwe bidin aliyên cihêreng ên projeya xwe û taybetmendiyên ziman û platforma bernamesaziya xwe bikar bînin da ku encamek çêtirîn bi dest bixin. Ez ê kêfxweş bibim ku hûn zanyariyên xwe yên têkildarî xweşbîniyê di .NET de parve bikin.
Source: www.habr.com
