አፈጻጸም በ 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 ኮር ኤስዲኬ = 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

ስራ=የኮር አሂድ ጊዜ=ኮር

ToList vs ToArray እና ዑደቶች

ይህንን መረጃ በ .NET Core 3.0 መለቀቅ ለማዘጋጀት አቅጄ ነበር, ነገር ግን ደበደቡኝ, የሌላ ሰውን ክብር መስረቅ እና የሌሎችን መረጃ መቅዳት አልፈልግም, ስለዚህ እኔ ብቻ እጠቁማለሁ. ንጽጽሩ በዝርዝር ከተገለጸበት ጥሩ ጽሑፍ ጋር ማገናኘት.

በራሴ ስም፣ የእኔን መለኪያዎች እና ውጤቶቼን ላቀርብላችሁ እፈልጋለሁ፤ “C++ style” የአጻጻፍ loops ወዳጆች ለእነሱ የተገላቢጦሽ ቀለበቶችን ጨመርኩላቸው።

ኮድ:

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 ስብስብ ተደጋጋሚ ሂደት ፈጣን ነው ብለን መደምደም እንችላለን በውስጣዊ ማመቻቸት እና ግልጽ በሆነ የስብስብ መጠን ምደባ። በተጨማሪም የዝርዝር ስብስብ የራሱ ጥቅሞች እንዳሉት እና በሚፈለገው ስሌት መሰረት ትክክለኛውን ስብስብ መጠቀም እንዳለቦት ማስታወስ ጠቃሚ ነው. ምንም እንኳን ከ loops ጋር ለመስራት አመክንዮ ቢጽፉ እንኳን ፣ ይህ ተራ ምልልስ መሆኑን አይርሱ እና እንዲሁም በተቻለ loop ማመቻቸት ላይ የተመሠረተ ነው። ከረጅም ጊዜ በፊት ሀብር ላይ አንድ መጣጥፍ ታትሟል፡- https://habr.com/ru/post/124910/. አሁንም ጠቃሚ እና የሚመከር ነው.

መወርወር

ከዓመት በፊት በአንድ ድርጅት ውስጥ በትሩፋት ፕሮጀክት ሠርቻለሁ፣ በዚያ ፕሮጀክት ውስጥ የመስክ ማረጋገጫን በሙከራ-ካtch-ውርወራ ግንባታ ማካሄድ የተለመደ ነበር። ከዚያ በኋላ ይህ ለፕሮጀክቱ ጤናማ ያልሆነ የንግድ ሥራ አመክንዮ እንደሆነ ተረድቻለሁ, ስለዚህ በተቻለ መጠን እንዲህ ዓይነት ንድፍ ላለመጠቀም ሞከርኩ. ግን ከእንደዚህ ዓይነት ግንባታ ጋር ስህተቶችን የማስተናገድ አቀራረብ ለምን መጥፎ እንደሆነ እንወቅ. ሁለቱን አቀራረቦች ለማነፃፀር ትንሽ ኮድ ጻፍኩ እና ለእያንዳንዱ አማራጭ መለኪያዎችን አደረግሁ።

ኮድ:

        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):

ለመያዝ ይሞክሩ ኮዱን ለመረዳት አስቸጋሪ ያደርገዋል እና የፕሮግራምዎን የአፈፃፀም ጊዜ ይጨምራል። ነገር ግን ይህንን ግንባታ ካስፈለገዎት ስህተቶችን ለማስተናገድ የማይጠበቁትን የኮድ መስመሮች ማስገባት የለብዎትም - ይህ ኮዱን ለመረዳት ቀላል ያደርገዋል። እንደ እውነቱ ከሆነ ስርዓቱን የሚጭነው የልዩነቶች አያያዝ ሳይሆን ስህተቶችን በራሳቸው መወርወር አዲስ ልዩ ግንባታ ነው።

ልዩ ሁኔታዎችን መወርወር ስህተቱን በሚፈለገው ቅርጸት ከሚሰበስቡ አንዳንድ ክፍሎች ቀርፋፋ ነው። ቅጹን ወይም አንዳንድ መረጃዎችን እያስኬዱ ከሆነ እና ስህተቱ ምን መሆን እንዳለበት በግልፅ ካወቁ ለምን አታስኬዱትም?

ይህ ሁኔታ ልዩ ካልሆነ አዲስ ልዩ () ግንባታን መጻፍ የለብዎትም። ለየት ያለ አያያዝ እና መጣል በጣም ውድ ነው !!!

ወደ ታች፣ ወደ ታች የማይለዋወጥ፣ ቶላይ፣ ቶላይኢንቫሪንት

በ NET መድረክ ላይ በመስራት ባሳለፍኩት የ5 ዓመታት ልምድ፣ string ማዛመድን የተጠቀሙ ብዙ ፕሮጀክቶችን አጋጥሞኛል። እንዲሁም የሚከተለውን ምስል አየሁ፡ ብዙ ፕሮጀክቶች ያሉት አንድ የኢንተርፕራይዝ መፍትሄ ነበር፣ እያንዳንዱም የሕብረቁምፊ ንጽጽሮችን በተለየ መንገድ አከናውኗል። ግን ምን ጥቅም ላይ መዋል አለበት እና እንዴት አንድ ማድረግ እንደሚቻል? በሪችተር በ C # በኩል CLR በተሰኘው መጽሃፍ ውስጥ የToUpperInvariant () ዘዴ ከToLowerInvariant () የበለጠ ፈጣን መሆኑን መረጃ አንብቤያለሁ።

ከመጽሐፉ የተወሰደ፡-

እርግጥ ነው፣ አላመንኩም ነበር እና አንዳንድ ፈተናዎችን በ.NET Framework ላይ ለማድረግ ወሰንኩ እና ውጤቱ አስደነገጠኝ - ከ 15% በላይ የአፈፃፀም ጭማሪ። ከዚያም በማግስቱ ጠዋት ወደ ሥራ ቦታ እንደደረስኩ እነዚህን መለኪያዎች ለአለቆቼ አሳየሁና የምንጭ ኮዱን እንዲያውቁ ሰጠኋቸው። ከዚህ በኋላ ከ 2 ፕሮጀክቶች ውስጥ 14 አዳዲስ መለኪያዎችን ለማስተናገድ ተለውጠዋል, እና እነዚህ ሁለት ፕሮጀክቶች ግዙፍ የኤክሴል ሰንጠረዦችን ለማስኬድ እንደነበሩ ግምት ውስጥ በማስገባት ውጤቱ ለምርቱ በጣም ጠቃሚ ነበር.

እንዲሁም እያንዳንዳችሁ በጣም ጥሩውን መፍትሄ ለመምረጥ እንድትችሉ ለተለያዩ የ 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 የ NET Core አፕሊኬሽኖችን የሚጀምርበትን ጊዜ የሚቀንሱ R2R ምስሎችን አስተዋውቋል።
• በስሪት 2.2፣ Tier Compilation ታየ፣ ለዚህም ምስጋና ይግባቸውና ፕሮግራመሮች አንድን ፕሮጀክት ለማስጀመር የሚያጠፉት።
• ለአዲስ .NET ደረጃዎች ድጋፍ።
• ለአዲሱ የፕሮግራም ቋንቋ ስሪት ድጋፍ።
• ማመቻቸት በእያንዳንዱ አዲስ ስሪት የመሠረት ቤተ-መጻሕፍት ስብስብ / መዋቅር / ዥረት / ሕብረቁምፊ / ሬጌክስ ማመቻቸት እና ብዙ ይሻሻላል. ከ NET Framework ወደ .NET Core እየተሰደዱ ከሆነ ከሳጥኑ ውስጥ ትልቅ የአፈፃፀም ጭማሪ ታገኛላችሁ። እንደ ምሳሌ፣ ወደ NET Core 3.0 ከተጨመሩት አንዳንድ ማሻሻያዎች ጋር አገናኝ አያይዤዋለሁ፡ https://devblogs.microsoft.com/dotnet/performance-improvements-in-net-core-3-0/

መደምደሚያ

ኮድ በሚጽፉበት ጊዜ ለፕሮጀክትዎ የተለያዩ ገጽታዎች ትኩረት መስጠት እና የፕሮግራም አወጣጥ ቋንቋዎን እና መድረክን በመጠቀም የተሻለውን ውጤት ማምጣት ጠቃሚ ነው። በ NET ውስጥ ከማመቻቸት ጋር የተያያዘ እውቀትዎን ቢያካፍሉ ደስ ይለኛል.

ወደ github አገናኝ

ምንጭ: hab.com