.NET ڪور ۾ ڪارڪردگي

.NET ڪور ۾ ڪارڪردگي

هيلو سڀ! هي آرٽيڪل بهترين طريقن جو هڪ مجموعو آهي جنهن کي منهنجو ساٿي ۽ مان هڪ ڊگهي وقت کان استعمال ڪري رهيا آهيون جڏهن مختلف منصوبن تي ڪم ڪري رهيا آهيون.

مشين جي باري ۾ معلومات جنهن تي حساب ڪيو ويو:BenchmarkDotNet=v0.11.5، OS=Windows 10.0.18362
Intel Core i5-8250U CPU 1.60GHz (Kaby Lake R)، 1 CPU، 8 منطقي ۽ 4 جسماني ڪور
.NET ڪور SDK = 3.0.100
[ميزبان]: .NET ڪور 2.2.7 (CoreCLR 4.6.28008.02، CoreFX 4.6.28008.03)، 64bit RyuJIT
ڪور: .NET ڪور 2.2.7 (CoreCLR 4.6.28008.02، CoreFX 4.6.28008.03)، 64bit RyuJIT
[ميزبان]: .NET ڪور 3.0.0 (CoreCLR 4.700.19.46205، CoreFX 4.700.19.46214)، 64bit RyuJIT
ڪور: .NET ڪور 3.0.0 (CoreCLR 4.700.19.46205، CoreFX 4.700.19.46214)، 64bit RyuJIT

نوڪري = ڪور رن ٽائم = ڪور

ToList بمقابله ToArray ۽ سائيڪل

مون هن معلومات کي .NET Core 3.0 جي رليز سان تيار ڪرڻ جو ارادو ڪيو، پر انهن مون کي ان تي مات ڏني، مان ڪنهن ٻئي جي شان کي چوري ڪرڻ ۽ ٻين ماڻهن جي معلومات کي نقل ڪرڻ نٿو چاهيان، تنهنڪري مان صرف اشارو ڪندس. هڪ سٺي مضمون سان ڳنڍيو جتي مقابلو تفصيل سان بيان ڪيو ويو آهي.

منهنجي پنهنجي طرفان، مان صرف توهان کي پنهنجا ماپ ۽ نتيجا پيش ڪرڻ چاهيان ٿو؛ مون انهن ۾ ريورس لوپس شامل ڪيا آهن انهن لاءِ ”سي++ انداز“ لکڻ جي لوپ جي شوقينن لاءِ.

ڪوڊ

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 ڪور 2.2 ۽ 3.0 ۾ ڪارڪردگي جي رفتار لڳ ڀڳ هڪجهڙا آهن. هتي اهو آهي جيڪو مان حاصل ڪري سگهيو آهيان .NET ڪور 3.0:

اسان اهو نتيجو ڪري سگهون ٿا ته هڪ آري گڏ ڪرڻ جي ٻيهر پروسيسنگ تيز آهي ان جي اندروني اصلاحن ۽ واضح مجموعي سائيز مختص ڪرڻ جي ڪري. اهو پڻ ياد رکڻ جي قابل آهي ته هڪ لسٽ گڏ ڪرڻ جا پنهنجا فائدا آهن ۽ توهان کي گهربل ڳڻپ جي بنياد تي صحيح مجموعو استعمال ڪرڻ گهرجي. جيتوڻيڪ جيڪڏهن توهان لوپ سان ڪم ڪرڻ لاء منطق لکندا آهيو، اهو نه وساريو ته هي هڪ عام لوپ آهي ۽ اهو پڻ ممڪن آهي لوپ جي اصلاح جي تابع آهي. ڪافي عرصو اڳ حبر تي هڪ مضمون شايع ٿيو هو: 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):

ڪوشش ڪريو ڪيچ ڪوڊ کي سمجھڻ ۾ مشڪل بڻائي ٿو ۽ توھان جي پروگرام جي عمل جو وقت وڌائي ٿو. پر جيڪڏهن توهان کي هن تعمير جي ضرورت آهي، توهان کي ڪوڊ جون اهي لائينون داخل نه ڪرڻ گهرجن جن جي غلطي کي سنڀالڻ جي اميد نه آهي - اهو ڪوڊ کي سمجهڻ آسان بڻائي ڇڏيندو. حقيقت ۾، اهو ايترو گهڻو نه آهي ته استثناء کي هٿي وٺن جيڪو سسٽم کي لوڊ ڪري ٿو، بلڪه نئين استثني تعمير جي ذريعي پاڻ کي غلطين کي اڇلائڻ.

اُڇلائڻ واري استثنا ڪجهه طبقي جي ڀيٽ ۾ سستي آهي جيڪا گهربل شڪل ۾ غلطي کي گڏ ڪندي. جيڪڏهن توهان هڪ فارم يا ڪجهه ڊيٽا پروسيس ڪري رهيا آهيو ۽ توهان واضح طور تي ڄاڻو ٿا ته غلطي ڇا هجڻ گهرجي، ڇو نه ان تي عمل ڪيو وڃي؟

توهان کي نه لکڻ گهرجي هڪ اڇلائي نئين Exception() تعمير جيڪڏهن اها صورتحال غير معمولي ناهي. هڪ استثنا هٿ ڪرڻ ۽ اڇلائڻ تمام مهانگو آهي !!!

اونڌو ڪرڻ وارو ، مٿانهون اونڌو ڪندڙ ، مٿانهون ، مٿانهون

.NET پليٽ فارم تي ڪم ڪرڻ جي منهنجي 5 سالن جي تجربي دوران، مون ڪيترن ئي پروجيڪٽس کي ڏٺو آهي جن ۾ اسٽرنگ ميچنگ استعمال ڪئي وئي هئي. مون ھيٺ ڏنل تصوير پڻ ڏٺي: اتي ھڪڙو انٽرپرائز حل آھي ڪيترن ئي منصوبن سان، جن مان ھر ھڪ مختلف انداز سان مقابلو ڪيو. پر ڇا استعمال ڪيو وڃي ۽ ان کي ڪيئن متحد ڪجي؟ ڪتاب ۾ CLR via C# by Richter، مون معلومات پڙهي ته ToUpperInvariant() طريقو ToLowerInvariant() کان تيز آهي.

ڪتاب مان اقتباس:

يقينن، مون ان تي يقين نه ڪيو ۽ .NET فريم ورڪ تي ڪجهه ٽيسٽ هلائڻ جو فيصلو ڪيو ۽ نتيجو مون کي حيران ڪري ڇڏيو - 15 سيڪڙو کان وڌيڪ ڪارڪردگي وڌائي. پوءِ، ٻئي صبح ڪم تي پهچڻ تي، مون پنهنجي اعليٰ عملدارن کي اهي ماپون ڏيکاريون ۽ کين سورس ڪوڊ تائين پهچ ڏني. ان کان پوء، 2 مان 14 منصوبن کي تبديل ڪيو ويو نئين ماپ کي ترتيب ڏيڻ لاء، ۽ غور ڪيو ويو ته اهي ٻه منصوبا موجود هئا وڏي ايڪسل ٽيبل کي پروسيس ڪرڻ لاء، نتيجو پيداوار لاء اهم کان وڌيڪ هو.

مان توهان کي .NET ڪور جي مختلف ورزن لاءِ ماپون پڻ پيش ڪريان ٿو، ته جيئن توهان مان هر هڪ بهترين حل لاءِ چونڊ ڪري سگهي. ۽ مان صرف اهو شامل ڪرڻ چاهيان ٿو ته ڪمپني ۾ جتي آئون ڪم ڪريان ٿو، اسان استعمال ڪندا آهيون 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 ڪور ۾ پهرين درخواستن ۾ غلطين جو سبب بڻيو ۽ ملٽي ليول ڪمپليشن موڊ ۾ پهرين تعمير دوران منجمد ٿي ويو. اهو في الحال .NET Core 3.0 ۾ ڊفالٽ طور فعال آهي، پر جيڪڏهن توهان چاهيو ته ان کي بند ڪري سگهو ٿا. جيڪڏهن توهان ٽيم جي اڳواڻي ۾ آهيو، سينيئر، وچولي، يا توهان ڪنهن ڊپارٽمينٽ جا سربراهه آهيو، ته پوءِ توهان کي اهو سمجهڻ گهرجي ته تيزيءَ سان پروجيڪٽ ڊولپمينٽ ٽيم جي قدر وڌائي ٿي ۽ اها ٽيڪنالاجي توهان کي اجازت ڏيندي ته توهان ٻنهي ڊولپرز لاءِ وقت بچائي سگهو ٿا. ۽ منصوبي جو وقت پاڻ.

.NET سطح مٿي

پنھنجي .NET فريم ورڪ / .NET ڪور ورزن کي اپڊيٽ ڪريو. گهڻو ڪري، هر نئون نسخو اضافي ڪارڪردگي حاصلات مهيا ڪري ٿو ۽ نئين خاصيتون شامل ڪري ٿو.

پر ڇا واقعي فائدا آهن؟ اچو ته انهن مان ڪجهه کي ڏسو:

• .NET ڪور 3.0 متعارف ڪرايو R2R تصويرون جيڪي .NET ڪور ايپليڪيشنن جي شروعاتي وقت کي گھٽائي ڇڏيندا.
• نسخو 2.2 سان، ٽائر تاليف ظاهر ٿيو، جنهن جي مهرباني پروگرامر هڪ منصوبي کي شروع ڪرڻ ۾ گهٽ وقت گذاريندا.
• نئين .NET معيارن لاءِ سپورٽ.
• پروگرامنگ ٻولي جي نئين ورزن لاءِ سپورٽ.
• اصلاح، هر نئين ورزن سان گڏ بيس لائبريرين جي بهتري ڪليڪشن/ اسٽريم/ اسٽريم/ اسٽرنگ/ ريجڪس ۽ گهڻو ڪجهه بهتر. جيڪڏهن توهان .NET فريم ورڪ کان .NET ڪور ڏانهن لڏپلاڻ ڪري رهيا آهيو، توهان کي دٻي مان هڪ وڏو ڪارڪردگي واڌارو حاصل ٿيندو. مثال طور، مان ڪجھ اصلاحن سان ڳنڍيل آھيان جيڪي .NET Core 3.0 ۾ شامل ڪيون ويون آھن: https://devblogs.microsoft.com/dotnet/performance-improvements-in-net-core-3-0/

ٿڪل

جڏهن ڪوڊ لکڻ، اهو توهان جي پروجيڪٽ جي مختلف پهلوئن تي ڌيان ڏيڻ جي قابل آهي ۽ بهترين نتيجو حاصل ڪرڻ لاء توهان جي پروگرامنگ ٻولي ۽ پليٽ فارم جي خاصيتن کي استعمال ڪندي. مون کي خوشي ٿيندي جيڪڏهن توهان .NET ۾ اصلاح سان لاڳاپيل پنهنجي ڄاڻ شيئر ڪندا.

github سان ڳنڍيو

جو ذريعو: www.habr.com