Tshebetso ho .NET Core
Lumelang bohle! Sehlooho sena ke pokello ea Mekhoa e Molemo ka ho Fetisisa eo 'na le basebetsi-'moho le 'na re e sebelisang ka nako e telele ha re sebetsa mererong e fapaneng.
Lintlha tse mabapi le mochini oo lipalo li neng li etsoa ho ona:BenchmarkDotNet=v0.11.5, OS=Windows 10.0.18362
Intel Core i5-8250U CPU 1.60GHz (Kaby Lake R), 1 CPU, 8 e utloahalang le li-cores tse 4 tsa 'mele
.NET Core SDK=3.0.100
[Moamoheli]: .NET Core 2.2.7 (CoreCLR 4.6.28008.02, CoreFX 4.6.28008.03), 64bit RyuJIT
Koko: .NET Core 2.2.7 (CoreCLR 4.6.28008.02, CoreFX 4.6.28008.03), 64bit RyuJIT
[Moamoheli]: .NET Core 3.0.0 (CoreCLR 4.700.19.46205, CoreFX 4.700.19.46214), 64bit RyuJIT
Koko: .NET Core 3.0.0 (CoreCLR 4.700.19.46205, CoreFX 4.700.19.46214), 64bit RyuJIT
Mosebetsi=Morero oa Konokono=Mokonoko
ToList vs ToArray le Cycles
Ke rerile ho lokisetsa tlhahisoleseding ena ka ho lokolloa ha .NET Core 3.0, empa ba ile ba nkotla ho eona, ha ke batle ho utsoa khanya ea motho e mong le ho kopitsa tlhahisoleseding ea batho ba bang, kahoo ke tla supa feela. .
Lebitsong la ka, ke mpa ke batla ho hlahisa litekanyo tsa ka le liphetho tsa ka; Ke kentse li-loops ho bona bakeng sa barati ba "C ++ mokhoa" oa ho ngola loops.
Code:
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;
}
}
Lebelo la ts'ebetso ho .NET Core 2.2 le 3.0 li batla li tšoana. Mona ke seo ke khonneng ho se fumana ho NET Core 3.0:
Re ka fihlela qeto ea hore ts'ebetso e pheta-phetoang ea pokello ea Array e potlakile ka lebaka la ntlafatso ea kahare le kabo ea boholo bo hlakileng ba pokello. Hape ke habohlokoa ho hopola hore pokello ea Lenane e na le melemo ea eona 'me u lokela ho sebelisa pokello e nepahetseng ho latela lipalo tse hlokahalang. Le ha o ngola logic bakeng sa ho sebetsa ka loops, u se ke oa lebala hore ena ke loop e tloaelehileng mme e boetse e ipapisitse le ts'ebetso e ka khonehang ea loop. Sengoloa se phatlalalitsoe ka habr khale haholo: . E ntse e le ea bohlokoa ebile e khothaletsoa ho bala.
Lahlela
Selemong se fetileng, ke ile ka sebetsa k'hamphaning morerong oa lefa, morerong oo e ne e le ntho e tloaelehileng ho sebetsana le netefatso ea tšimo ka mokhoa oa ho leka ho lahla. Ke ne ke se ke ntse ke utloisisa ka nako eo hore ena e ne e le mokhoa o sa nepahaleng oa khoebo bakeng sa morero, kahoo neng kapa neng ha ho khoneha ke ne ke leka ho se sebelise moralo o joalo. Empa a re boneng hore na ke hobane'ng ha mokhoa oa ho sebetsana le liphoso ka mohaho o joalo o le mpe. Ke ngotse khoutu e nyane ho bapisa mekhoa e 'meli mme ka etsa li-benchmark bakeng sa khetho ka' ngoe.
Code:
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;
}Liphetho ho .NET Core 3.0 le Core 2.2 li na le sephetho se tšoanang (.NET Core 3.0):
Leka ho tšoasa ho etsa hore khoutu e be thata ho utloisisa le ho eketsa nako ea ts'ebetso ea lenaneo la hau. Empa haeba u hloka kaho ena, ha ua lokela ho kenya mela eo ea khoutu e sa lebelloang ho sebetsana le liphoso - sena se tla etsa hore khoutu e utloisisehe habonolo. Ha e le hantle, ha se ho sebetsana le mekhelo haholo ho laolang tsamaiso, empa ho e-na le hoo ke ho lahlela liphoso ka bobona ka ho lahlela kaho e ncha ea Exception.
Mekhelo ea ho lahlela e lieha ho feta sehlopha se seng se tla bokella phoso ka mokhoa o hlokahalang. Haeba u ntse u sebetsana le foromo kapa data e itseng 'me u tseba hantle hore na phoso e lokela ho ba efe, ke hobane'ng ha u sa e sebetse?
Ha oa lokela ho ngola moaho o mocha oa Exception() haeba boemo bona bo sa tloaeleha. Ho sebetsana le ho lahlela mokhelo ho theko e boima haholo !!!
Ho ea Tlase, ho ea TlaseHa e sa fetohe, ho ea holimo ho ea holimo, ho ea holimo, ho ea holimo, ho ea holimo, ho ea holimo, ho ea holimo, ho ea holimo, ho ea holimo, ho ea holimo, ho ea holimo, ho ea holimo, ka ho sa fetoheng
Lilemong tsa ka tse 5 tsa phihlelo ea ho sebetsa sethaleng sa .NET, ke kopane le merero e mengata e neng e sebelisa khoele ea ho bapisa. Hape ke bone setšoantšo se latelang: ho ne ho e-na le tharollo e le 'ngoe ea Khoebo e nang le merero e mengata, e' ngoe le e 'ngoe ea tsona e neng e etsa papiso ea likhoele ka tsela e fapaneng. Empa ke eng e lokelang ho sebelisoa le ho e kopanya joang? Bukeng ea CLR ka C # ka Richter, ke balile tlhahisoleseling hore mokhoa oa ToUpperInvariant () o potlakile ho feta ToLowerInvariant ().
Nopolo e tsoang bukeng:
Ha e le hantle, ha kea ka ka e lumela 'me ka etsa qeto ea ho etsa liteko tse ling ka nako eo ho .NET Framework mme sephetho se ile sa ntšosa - ho feta 15% ho eketseha ha tshebetso. Joale, ha ke fihla mosebetsing hoseng ho latelang, ke ile ka bontša baokameli ba ka litekanyo tsena ’me ka ba fa monyetla oa ho fumana khoutu ea mohloli. Ka mor'a sena, merero e 2 ho e 14 e ile ea fetoloa ho lumellana le litekanyo tse ncha, 'me ha ho nahanoa hore merero ena e' meli e ne e le teng bakeng sa ho sebetsana le litafole tse kholo tsa Excel, phello e bile ea bohlokoa ho feta sehlahisoa.
Ke boetse ke hlahisa ho lona litekanyo bakeng sa liphetolelo tse fapaneng tsa .NET Core, e le hore e mong le e mong oa lōna a ka etsa khetho e lebisang ho tharollo e nepahetseng ka ho fetisisa. 'Me ke batla feela ho kenyelletsa hore k'hamphaning eo ke sebetsang ho eona, re sebelisa ToUpper() ho bapisa likhoele.
Code:
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();
}
Ho .NET Core 3.0, keketseho ea e 'ngoe le e' ngoe ea mekhoa ena ke ~ x2 mme e leka-lekanya ts'ebetsong har'a bona.
Kopano ea Tier
Sehloohong sa ka sa ho qetela ke hlalositse ts'ebetso ena ka bokhutšoanyane, ke rata ho lokisa le ho tlatsetsa mantsoe a ka. Ho bokella maemo a mangata ho potlakisa nako ea ho qala ea tharollo ea hau, empa u tela hore likarolo tsa khoutu ea hau li tla bokelloa ka mokhoa o ntlafalitsoeng haholoanyane ka morao, o ka hlahisang sehlooho se senyenyane. Ka ho fihla ha NET Core 3.0, nako ea kaho ea merero e nang le li-tier compilation e fokotsehile mme likokoana-hloko tse amanang le theknoloji ena li lokisitsoe. Nakong e fetileng, theknoloji ena e ile ea lebisa liphoso likopong tsa pele tsa ASP.NET Core 'me ea hoama nakong ea kaho ea pele ka mokhoa oa ho bokella mekhahlelo e mengata. Hajoale e nolofalitsoe ka ho sa feleng ho .NET Core 3.0, empa u ka e thibela ha u lakatsa. Haeba u le maemong a moetapele oa sehlopha, ea phahameng, ea bohareng, kapa u hlooho ea lefapha, joale u tlameha ho utloisisa hore nts'etsopele ea projeke e potlakileng e eketsa boleng ba sehlopha mme theknoloji ena e tla u lumella ho boloka nako bakeng sa bahlahisi ka bobeli. le nako ea morero ka boona.
NET boemo bo holimo
Ntlafatsa mofuta oa hau oa .NET Framework / .NET Core. Hangata, mofuta o mong le o mong o mocha o fana ka phaello e eketsehileng ea ts'ebetso mme o eketsa likarolo tse ncha.
Empa hantle-ntle melemo ke efe? A re shebeng tse ling tsa tsona:
- .NET Core 3.0 e hlahisitse litšoantšo tsa R2R tse tla fokotsa nako ea ho qala ea lisebelisoa tsa .NET Core.
- Ka mofuta oa 2.2, Tier Compilation e hlahile, ka lebaka leo baetsi ba mananeo ba tla qeta nako e nyane ba qala morero.
- Tšehetso bakeng sa Mekhoa e mecha ea .NET.
- Tšehetso bakeng sa mofuta o mocha oa puo ea lenaneo.
- Ntlafatso, ka mofuta o mong le o mong o mocha, ntlafatso ea lilaebrari tsa mantlha Pokello / Struct / Stream / String / Regex le tse ling tse ngata li ntlafala. Haeba u falla ho tloha .NET Framework ho ea .NET Core, u tla fumana ts'ebetso e kholo ea ts'ebetso ho tsoa lebokoseng. E le mohlala, ke hokela sehokelo ho tse ling tsa lintlafatso tse kentsoeng ho .NET Core 3.0:
fihlela qeto e
Ha u ngola khoutu, ho bohlokoa ho ela hloko likarolo tse fapaneng tsa projeke ea hau le ho sebelisa likarolo tsa puo ea hau ea lenaneo le sethala ho fihlela sephetho se setle. Ke tla thaba ha o arolelana tsebo ea hau e amanang le ho ntlafatsa ho .NET.
Source: www.habr.com