Coileanadh ann an .NET Core
Hi uile! Tha an artaigil seo na chruinneachadh de chleachdaidhean as fheàrr a tha mo cho-obraichean agus mi air a bhith a’ cleachdadh airson ùine mhòr nuair a tha iad ag obair air diofar phròiseactan.
Fiosrachadh mun inneal air an deach an àireamhachadh a dhèanamh:BenchmarkDotNet = 0.11.5, OS = Windows 10.0.18362
Intel Core i5-8250U CPU 1.60GHz (Kaby Lake R), 1 CPU, 8 loidsigeach agus coraichean corporra 4
.NET Core SDK=3.0.100
[Host]: .NET Core 2.2.7 (CoreCLR 4.6.28008.02, CoreFX 4.6.28008.03), 64bit RyuJIT
Bun-ìre: .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
Bun-ìre: .NET Core 3.0.0 (CoreCLR 4.700.19.46205, CoreFX 4.700.19.46214), 64bit RyuJIT
Job=Am prìomh ùine-ruith=Cridhe
ToList vs ToArray and Cycles
Bha mi an dùil am fiosrachadh seo ullachadh le sgaoileadh .NET Core 3.0, ach rinn iad a 'chùis orm, chan eil mi airson glòir cuideigin eile a ghoid agus fiosrachadh dhaoine eile a chopaigeadh, agus mar sin cuiridh mi an cèill .
Às mo leth fhìn, tha mi dìreach airson na tomhasan agus na toraidhean agam a thaisbeanadh dhut; chuir mi lùban cùil riutha airson leannanan de lùban sgrìobhaidh “stoidhle C ++”.
còd:
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;
}
}
Tha astaran coileanaidh ann an .NET Core 2.2 agus 3.0 cha mhòr co-ionann. Seo na fhuair mi a-steach .NET Core 3.0:
Faodaidh sinn a cho-dhùnadh gu bheil giullachd ath-aithriseach de chruinneachadh Array nas luaithe air sgàth cho math sa tha e a-staigh agus a bhith a’ riarachadh meud cruinneachaidh soilleir. Is fhiach cuimhneachadh cuideachd gu bheil na buannachdan aige fhèin aig cruinneachadh Liosta agus bu chòir dhut an cruinneachadh ceart a chleachdadh a rèir an àireamhachadh a tha a dhìth. Fiù ma sgrìobhas tu loidsig airson a bhith ag obair le lùban, na dìochuimhnich gur e lùb àbhaisteach a tha seo agus tha e cuideachd fo ùmhlachd optimization lùb a dh’ fhaodadh a bhith ann. Chaidh artaigil fhoillseachadh air habr o chionn fhada: . Tha e fhathast buntainneach agus leughadh air a mholadh.
Tilgeil
O chionn bliadhna, bha mi ag obair aig companaidh air pròiseact dìleab, anns a’ phròiseact sin bha e àbhaisteach dearbhadh achaidh a phròiseasadh tro thogalach feuchainn-glacadh. Bha mi a 'tuigsinn mar-thà gur e loidsig gnìomhachais mì-fhallain a bha seo airson a' phròiseict, agus mar sin nuair a bha e comasach dh'fheuch mi gun a bhith a 'cleachdadh a leithid de dhealbhadh. Ach obraichidh sinn a-mach carson a tha an dòigh-obrach airson làimhseachadh mhearachdan le leithid de thogail dona. Sgrìobh mi còd beag gus coimeas a dhèanamh eadar an dà dhòigh-obrach agus rinn mi slatan-tomhais airson gach roghainn.
còd:
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;
}Tha toradh co-chosmhail aig na toraidhean ann an .NET Core 3.0 agus Core 2.2 (.NET Core 3.0):
Feuch ri glacadh a nì an còd nas duilghe a thuigsinn agus àrdaichidh e ùine cur gu bàs a’ phrògraim agad. Ach ma tha feum agad air an togail seo, cha bu chòir dhut na loidhnichean còd sin a chur a-steach nach eilear an dùil a bhith a 'làimhseachadh mhearachdan - nì seo an còd nas fhasa a thuigsinn. Gu dearbh, chan e dìreach làimhseachadh eisgeachdan a tha a’ luchdachadh an t-siostam, ach an àite a bhith a’ tilgeil mhearachdan iad fhèin tron togalach ùr tilgeil Exception.
Tha tilgeadh eisgeachdan nas slaodaiche na cuid de chlas a chruinnicheas a’ mhearachd anns a’ chruth a tha a dhìth. Ma tha thu a’ giullachd foirm no cuid de dhàta agus gu bheil fios agad gu soilleir dè a’ mhearachd a bu chòir a bhith, carson nach giullachd thu e?
Cha bu chòir dhut togalach ùr Exception() a sgrìobhadh mura h-eil an suidheachadh seo sònraichte. Tha làimhseachadh agus tilgeil eisgeachd gu math daor !!!
Gu h-Ìseal, gu h-ìsle, gu h-ìseal, gu h-ìseal, gu h-ìseal, gu tionndadh
Thairis air na bliadhnaichean 5 de eòlas agam ag obair air an àrd-ùrlar .NET, tha mi air tighinn tarsainn air mòran phròiseactan a chleachd maidseadh sreang. Chunnaic mi an dealbh a leanas cuideachd: bha aon fhuasgladh Iomairt ann le mòran phròiseactan, agus rinn gach fear dhiubh coimeas sreang eadar-dhealaichte. Ach dè a bu chòir a chleachdadh agus ciamar a nì thu aonachadh? Anns an leabhar CLR tro C # le Richter, leugh mi fiosrachadh gu bheil an dòigh ToUpperInvariant() nas luaithe na ToLowerInvariant().
Earrann bhon leabhar:
Gu dearbh, cha robh mi ga chreidsinn agus cho-dhùin mi cuid de dheuchainnean a ruith an uairsin air an .NET Framework agus chuir an toradh iongnadh orm - barrachd air àrdachadh coileanaidh 15%. An uairsin, nuair a ràinig mi obair an ath mhadainn, sheall mi na tomhais sin dha na h-àrd-oifigearan agam agus thug mi cothrom dhaibh faighinn chun chòd stòr. Às deidh seo, chaidh 2 a-mach à 14 pròiseactan atharrachadh gus gabhail ris na tomhasan ùra, agus leis gu robh an dà phròiseact seo ann airson clàran mòra Excel a phròiseasadh, bha an toradh nas cudromaiche na an toradh.
Bidh mi cuideachd a’ taisbeanadh dhut tomhasan airson diofar dhreachan de .NET Core, gus an urrainn do gach fear agaibh taghadh a dhèanamh a dh’ ionnsaigh an fhuasglaidh as fheàrr. Agus tha mi dìreach airson sin a chuir ris anns a ’chompanaidh far a bheil mi ag obair, bidh sinn a’ cleachdadh ToUpper () gus coimeas a dhèanamh eadar sreangan.
còd:
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();
}
Ann an .NET Core 3.0, tha an t-àrdachadh airson gach aon de na dòighean sin ~x2 agus a’ cothromachadh nam buileachadh eatorra fhèin.
Cruinneachadh ìre
Anns an artaigil mu dheireadh agam thug mi cunntas goirid air a’ ghnìomhachd seo, bu mhath leam na faclan agam a cheartachadh agus a leudachadh. Bidh cruinneachadh ioma-ìre a’ luathachadh ùine tòiseachaidh an fhuasglaidh agad, ach bidh thu ag ìobairt gun tèid pàirtean den chòd agad a chuir ri chèile ann an dreach nas fheàrr air a’ chùl, a bheir a-steach beagan os cionn. Le teachd NET Core 3.0, tha an ùine togail airson pròiseactan le cruinneachadh sreath air a chomasachadh air a dhol sìos agus chaidh bugaichean co-cheangailte ris an teicneòlas seo a chàradh. Roimhe sin, dh ’adhbhraich an teicneòlas seo mearachdan anns na ciad iarrtasan ann an ASP.NET Core agus reothadh e rè a’ chiad togail ann am modh cruinneachaidh ioma-ìre. Tha e an-dràsta air a chomasachadh gu bunaiteach ann an .NET Core 3.0, ach faodaidh tu a chuir dheth ma thogras tu. Ma tha thu ann an suidheachadh stiùiriche sgioba, àrd, meadhan, no ma tha thu nad cheannard air roinn, feumaidh tu tuigsinn gu bheil leasachadh pròiseict luath ag àrdachadh luach na sgioba agus leigidh an teicneòlas seo leat ùine a shàbhaladh don dà leasaiche. agus àm a’ phròiseict fhèin.
Ìre NET suas
Dèan ùrachadh air an tionndadh .NET Framework / .NET Core agad. Gu tric, bidh gach dreach ùr a’ toirt buannachdan coileanaidh a bharrachd agus a’ cur feartan ùra ris.
Ach dè dìreach na buannachdan a th 'ann? Bheir sinn sùil air cuid dhiubh:
- Thug .NET Core 3.0 a-steach ìomhaighean R2R a lughdaicheas an ùine tòiseachaidh de thagraidhean .NET Core.
- Le dreach 2.2, nochd Tier Compilation, le taing dha na prògraman a bhios a’ caitheamh nas lugha de ùine a’ cur air bhog pròiseact.
- Taic airson Inbhean .NET ùra.
- Taic airson dreach ùr den chànan prògramaidh.
- Optimization, le gach dreach ùr bidh an optimization de na leabharlannan bunaiteach Cruinneachadh / Structar / Sruth / String / Regex agus mòran a bharrachd a’ leasachadh. Ma tha thu a 'dèanamh imrich bhon .NET Framework gu .NET Core, gheibh thu àrdachadh coileanaidh mòr a-mach às a' bhogsa. Mar eisimpleir, bidh mi a 'ceangal ceangal ri cuid de na optimizations a chaidh a chur ri .NET Core 3.0:
co-dhùnadh
Nuair a bhios tu a’ sgrìobhadh còd, is fhiach aire a thoirt do dhiofar thaobhan den phròiseact agad agus feartan do chànan prògramaidh agus àrd-ùrlar a chleachdadh gus an toradh as fheàrr a choileanadh. Bhithinn toilichte nan co-roinn thu an t-eòlas agad co-cheangailte ri optimization ann an .NET.
Source: www.habr.com