.NET Core හි කාර්ය සාධනය

.NET Core හි කාර්ය සාධනය

ආයුබෝවන් සියල්ලටම! මෙම ලිපිය මගේ සගයන් සහ මම විවිධ ව්‍යාපෘතිවල වැඩ කරන විට දීර්ඝ කාලයක් තිස්සේ භාවිතා කරන හොඳම භාවිතයන් එකතුවකි.

ගණනය කිරීම් සිදු කරන ලද යන්ත්රය පිළිබඳ තොරතුරු:BenchmarkDotNet=v0.11.5, OS=Windows 10.0.18362
Intel Core i5-8250U CPU 1.60GHz (Kaby Lake R), 1 CPU, 8 තාර්කික සහ 4 භෞතික හර
.NET Core SDK=3.0.100
[සත්කාරක]: .NET Core 2.2.7 (CoreCLR 4.6.28008.02, CoreFX 4.6.28008.03), 64bit RyuJIT
හරය: .NET Core 2.2.7 (CoreCLR 4.6.28008.02, CoreFX 4.6.28008.03), 64bit RyuJIT
[සත්කාරක]: .NET Core 3.0.0 (CoreCLR 4.700.19.46205, CoreFX 4.700.19.46214), 64bit RyuJIT
හරය: .NET Core 3.0.0 (CoreCLR 4.700.19.46205, CoreFX 4.700.19.46214), 64bit RyuJIT

Job=Core Runtime=core

ToList එදිරිව ToArray සහ Cycles

.NET Core 3.0 නිකුත් කිරීමත් සමඟ මෙම තොරතුරු සකස් කිරීමට මම සැලසුම් කළෙමි, නමුත් ඔවුන් මට පහර දුන්නා, මට වෙනත් කෙනෙකුගේ මහිමය සොරකම් කිරීමට සහ වෙනත් පුද්ගලයින්ගේ තොරතුරු පිටපත් කිරීමට අවශ්‍ය නැත, එබැවින් මම පෙන්වා දෙන්නම් සංසන්දනය විස්තරාත්මකව විස්තර කර ඇති හොඳ ලිපියකට සබැඳිය.

මා වෙනුවෙන්, මට මගේ මිනුම් සහ ප්‍රතිඵල ඔබට ඉදිරිපත් කිරීමට අවශ්‍යයි; ලිවීමේ ලූප "C++ ශෛලියට" ආදරය කරන්නන් සඳහා මම ඒවාට ප්‍රතිලෝම ලූප එකතු කළෙමි.

කේතය:

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

.NET Core 2.2 සහ 3.0 හි කාර්ය සාධන වේගය බොහෝ දුරට සමාන වේ. මෙන්න මට .NET Core 3.0 තුළ ලබා ගැනීමට හැකි වූ දේ:

Array එකතුවක් එහි අභ්‍යන්තර ප්‍රශස්තකරණයන් සහ පැහැදිලි එකතු කිරීමේ ප්‍රමාණය වෙන් කිරීම හේතුවෙන් එහි පුනරාවර්තන සැකසීම වේගවත් බව අපට නිගමනය කළ හැක. ලැයිස්තු එකතුවකට තමන්ගේම වාසි ඇති බව මතක තබා ගැනීම වටී, අවශ්‍ය ගණනය කිරීම් අනුව ඔබ නිවැරදි එකතුව භාවිතා කළ යුතුය. ඔබ ලූප සමඟ වැඩ කිරීම සඳහා තර්කනය ලිව්වත්, මෙය සාමාන්‍ය ලූපයක් බවත්, හැකි ලූප් ප්‍රශස්තිකරණයට ද යටත් වන බවත් අමතක නොකරන්න. බොහෝ කලකට පෙර habr හි ලිපියක් පළ විය: https://habr.com/ru/post/124910/. එය තවමත් අදාළ වන අතර කියවීම නිර්දේශ කෙරේ.

විසි කරන්න

වසරකට පෙර, මම ලෙගසි ව්‍යාපෘතියක සමාගමක සේවය කළෙමි, එම ව්‍යාපෘතියේ උත්සාහ-අල්ලා-දැමීමේ ඉදිකිරීමක් හරහා ක්ෂේත්‍ර වලංගුකරණය සැකසීම සාමාන්‍ය දෙයක් විය. ව්‍යාපෘතිය සඳහා මෙය සෞඛ්‍යයට අහිතකර ව්‍යාපාරික තර්කයක් බව මම දැනටමත් තේරුම් ගෙන සිටිමි, එබැවින් හැකි සෑම විටම එවැනි නිර්මාණයක් භාවිතා නොකිරීමට මම උත්සාහ කළෙමි. නමුත් එවැනි ඉදිකිරීමක් සමඟ දෝෂ හැසිරවීමේ ප්රවේශය නරක වන්නේ මන්දැයි අපි සොයා බලමු. මම ප්‍රවේශ දෙක සංසන්දනය කිරීමට කුඩා කේතයක් ලියා එක් එක් විකල්පය සඳහා මිණුම් සලකුණු සෑදුවෙමි.

කේතය:

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

.NET Core 3.0 සහ Core 2.2 හි ප්‍රතිඵල වලට සමාන ප්‍රතිඵලයක් ඇත (.NET Core 3.0):

අල්ලා ගැනීමට උත්සාහ කරන්න, කේතය තේරුම් ගැනීමට අපහසු වන අතර ඔබේ වැඩසටහන ක්‍රියාත්මක කිරීමේ කාලය වැඩි කරයි. නමුත් ඔබට මෙම ඉදිකිරීම අවශ්‍ය නම්, දෝෂ හැසිරවීමට බලාපොරොත්තු නොවන එම කේත රේඛා ඇතුළත් නොකළ යුතුය - මෙය කේතය තේරුම් ගැනීමට පහසු වනු ඇත. ඇත්ත වශයෙන්ම, පද්ධතිය පූරණය කරන ව්‍යතිරේක හැසිරවීම එතරම් නොවේ, නමුත් විසි කිරීමේ නව ව්‍යතිරේක ඉදිකිරීම හරහා දෝෂ විසි කිරීම.

ව්‍යතිරේක විසි කිරීම අවශ්‍ය ආකෘතියේ දෝෂය එකතු කරන සමහර පන්තියට වඩා මන්දගාමී වේ. ඔබ පෝරමයක් හෝ දත්ත කිහිපයක් සකසමින් සිටින්නේ නම් සහ දෝෂය කුමක් විය යුතු දැයි ඔබ පැහැදිලිව දන්නේ නම්, එය ක්‍රියා නොකරන්නේ මන්ද?

මෙම තත්වය සුවිශේෂී නොවේ නම්, ඔබ විසින් නව ව්‍යතිරේක() නිර්මාණයක් නොලිය යුතුය. ව්යතිරේකයක් හැසිරවීම සහ විසි කිරීම ඉතා මිල අධිකයි !!!

ToLower, ToLowerInvariant, ToUpper, ToUpperInvariant

.NET වේදිකාවේ වැඩ කිරීමේ මගේ වසර 5ක පළපුරුද්ද තුළ, නූල් ගැලපීම භාවිතා කළ බොහෝ ව්‍යාපෘති මට හමු වී ඇත. මම පහත පින්තූරය ද දුටුවෙමි: බොහෝ ව්‍යාපෘති සමඟ එක් ව්‍යවසාය විසඳුමක් ඇති අතර, ඒ සෑම එකක්ම විවිධ තන්තු සංසන්දනය කරන ලදී. නමුත් භාවිතා කළ යුත්තේ කුමක්ද සහ එය ඒකාබද්ධ කරන්නේ කෙසේද? රිච්ටර් විසින් CLR හරහා C# පොතේ, ToUpperInvariant() ක්‍රමය ToLowerInvariant() ට වඩා වේගවත් බව මම තොරතුරු කියෙව්වා.

පොතෙන් උපුටා ගැනීම:

ඇත්ත වශයෙන්ම, මම එය විශ්වාස නොකළ අතර .NET රාමුව මත සමහර පරීක්ෂණ ධාවනය කිරීමට තීරණය කළ අතර ප්රතිඵලය මා කම්පනයට පත් කළේය - 15% කට වඩා කාර්ය සාධනය වැඩි කිරීම. පසුව, පසුදා උදෑසන රැකියාවට පැමිණි පසු, මම මෙම මිනුම් මගේ ඉහළ නිලධාරීන්ට පෙන්වා මූල කේතය වෙත ප්‍රවේශය ලබා දුනිමි. මෙයින් පසු, නව මිනුම් සඳහා ඉඩ සැලසෙන පරිදි ව්‍යාපෘති 2 න් 14 ක් වෙනස් කරන ලද අතර, විශාල Excel වගු සැකසීම සඳහා මෙම ව්‍යාපෘති දෙක පැවති බව සලකන විට, ප්‍රතිඵලය නිෂ්පාදනයට වඩා වැදගත් විය.

.NET Core හි විවිධ අනුවාද සඳහා මිනුම් ද මම ඔබට ඉදිරිපත් කරමි, එවිට ඔබ සෑම කෙනෙකුටම වඩාත්ම ප්‍රශස්ත විසඳුම සඳහා තේරීමක් කළ හැකිය. ඒවගේම මම වැඩ කරන ආයතනයේ ඒක එකතු කරන්න ඕනේ, අපි ToUpper() තන්තු සංසන්දනය කරන්න පාවිච්චි කරනවා.

කේතය:

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

.NET Core 3.0 හි, මෙම එක් එක් ක්‍රමය සඳහා වැඩි වීම ~x2 වන අතර ඒවා අතර ක්‍රියාත්මක කිරීම් තුලනය කරයි.

ස්ථර සම්පාදනය

මගේ අවසාන ලිපියේ මම මෙම ක්‍රියාකාරිත්වය කෙටියෙන් විස්තර කළෙමි, මගේ වචන නිවැරදි කිරීමට සහ අතිරේක කිරීමට මම කැමතියි. බහු-මට්ටමේ සම්පාදනය ඔබේ විසඳුමේ ආරම්භක කාලය වේගවත් කරයි, නමුත් ඔබේ කේතයේ කොටස් කුඩා පොදු කාර්යක් හඳුන්වා දිය හැකි පසුබිමේ වඩාත් ප්‍රශස්ත අනුවාදයකට සම්පාදනය කරනු ඇතැයි ඔබ කැප කරයි. NET Core 3.0 පැමිණීමත් සමඟ, ස්ථර සම්පාදනය සක්‍රීය කර ඇති ව්‍යාපෘති සඳහා ගොඩනැගීමේ කාලය අඩු වී ඇති අතර මෙම තාක්‍ෂණය හා සම්බන්ධ දෝෂ නිවැරදි කර ඇත. මීට පෙර, මෙම තාක්‍ෂණය ASP.NET Core හි පළමු ඉල්ලීම්වල දෝෂ වලට තුඩු දුන් අතර බහු මට්ටමේ සම්පාදන මාදිලියේ පළමු ගොඩනැගීමේදී කැටි වේ. එය දැනට .NET Core 3.0 හි පෙරනිමියෙන් සක්‍රීය කර ඇත, නමුත් ඔබට අවශ්‍ය නම් එය අක්‍රිය කළ හැක. ඔබ කණ්ඩායම් නායක, ජ්‍යෙෂ්ඨ, මැද, හෝ ඔබ දෙපාර්තමේන්තුවක ප්‍රධානියා නම්, වේගවත් ව්‍යාපෘති සංවර්ධනය කණ්ඩායමේ වටිනාකම වැඩි කරන බව ඔබ තේරුම් ගත යුතු අතර මෙම තාක්ෂණය මඟින් සංවර්ධකයින් දෙදෙනාටම කාලය ඉතිරි කර ගැනීමට ඉඩ සලසයි. සහ ව්යාපෘතියේ කාලයම.

.NET මට්ටම ඉහළට

ඔබගේ .NET Framework / .NET Core අනුවාදය උත්ශ්‍රේණි කරන්න. බොහෝ විට, සෑම නව අනුවාදයක්ම අතිරේක කාර්ය සාධන වාසි ලබා දෙන අතර නව විශේෂාංග එකතු කරයි.

නමුත් ඇත්ත වශයෙන්ම ප්රතිලාභ මොනවාද? ඒවායින් කිහිපයක් අපි බලමු:

• .NET Core 3.0 විසින් R2R රූප හඳුන්වා දුන් අතර එය .NET Core යෙදුම්වල ආරම්භක කාලය අඩු කරයි.
• 2.2 අනුවාදය සමඟ, ස්ථර සම්පාදනය දර්ශනය විය, එයට ස්තූතිවන්ත වන පරිදි ක්‍රමලේඛකයින් ව්‍යාපෘතියක් දියත් කිරීමට අඩු කාලයක් ගත කරයි.
• නව .NET ප්‍රමිති සඳහා සහාය.
• ක්‍රමලේඛන භාෂාවේ නව අනුවාදයක් සඳහා සහාය.
• ප්‍රශස්තකරණය, සෑම නව අනුවාදයක් සමඟම මූලික පුස්තකාල එකතුව/ව්‍යුහය/ස්ට්‍රීම්/ස්ට්‍රින්ග්/රෙජෙක්ස් ප්‍රශස්තකරණය සහ තවත් බොහෝ දේ වැඩිදියුණු වේ. ඔබ .NET Framework වෙතින් .NET Core වෙත සංක්‍රමණය වන්නේ නම්, ඔබට විශාල කාර්ය සාධනයක් ලබා ගත හැක. උදාහරණයක් ලෙස, මම .NET Core 3.0 වෙත එක් කරන ලද සමහර ප්‍රශස්තකරණයන් වෙත සබැඳියක් අමුණමි: https://devblogs.microsoft.com/dotnet/performance-improvements-in-net-core-3-0/

නිගමනය

කේතය ලිවීමේදී, ඔබේ ව්‍යාපෘතියේ විවිධ අංශ කෙරෙහි අවධානය යොමු කිරීම සහ හොඳම ප්‍රතිඵලය ලබා ගැනීම සඳහා ඔබේ ක්‍රමලේඛන භාෂාවේ සහ වේදිකාවේ විශේෂාංග භාවිතා කිරීම වටී. ඔබ .NET හි ප්‍රශස්තකරණයට අදාළ ඔබේ දැනුම බෙදා ගන්නේ නම් මම සතුටු වෙමි.

github වෙත සබැඳිය

මූලාශ්රය: www.habr.com