.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 ਕੋਰ 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 ਕੋਰ 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 ਕੋਰ 3.0 ਅਤੇ ਕੋਰ 2.2 ਦੇ ਨਤੀਜੇ ਇੱਕ ਸਮਾਨ ਹਨ (.NET ਕੋਰ 3.0):

ਕੈਚ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੋ ਕੋਡ ਨੂੰ ਸਮਝਣਾ ਔਖਾ ਬਣਾਉਂਦਾ ਹੈ ਅਤੇ ਤੁਹਾਡੇ ਪ੍ਰੋਗਰਾਮ ਦੇ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਟਾਈਮ ਨੂੰ ਵਧਾਉਂਦਾ ਹੈ। ਪਰ ਜੇ ਤੁਹਾਨੂੰ ਇਸ ਨਿਰਮਾਣ ਦੀ ਲੋੜ ਹੈ, ਤਾਂ ਤੁਹਾਨੂੰ ਕੋਡ ਦੀਆਂ ਉਹ ਲਾਈਨਾਂ ਨਹੀਂ ਪਾਉਣੀਆਂ ਚਾਹੀਦੀਆਂ ਜਿਨ੍ਹਾਂ ਤੋਂ ਗਲਤੀਆਂ ਨੂੰ ਸੰਭਾਲਣ ਦੀ ਉਮੀਦ ਨਹੀਂ ਕੀਤੀ ਜਾਂਦੀ - ਇਹ ਕੋਡ ਨੂੰ ਸਮਝਣ ਵਿੱਚ ਆਸਾਨ ਬਣਾ ਦੇਵੇਗਾ। ਵਾਸਤਵ ਵਿੱਚ, ਇਹ ਅਪਵਾਦਾਂ ਦਾ ਪ੍ਰਬੰਧਨ ਇੰਨਾ ਜ਼ਿਆਦਾ ਨਹੀਂ ਹੈ ਜੋ ਸਿਸਟਮ ਨੂੰ ਲੋਡ ਕਰਦਾ ਹੈ, ਸਗੋਂ ਥ੍ਰੋ ਨਿਊ ਐਕਸੈਪਸ਼ਨ ਕੰਸਟਰੱਕਟ ਦੁਆਰਾ ਆਪਣੇ ਆਪ ਵਿੱਚ ਗਲਤੀਆਂ ਨੂੰ ਸੁੱਟਣਾ ਹੈ।

ਅਪਵਾਦ ਸੁੱਟਣਾ ਕੁਝ ਕਲਾਸ ਨਾਲੋਂ ਹੌਲੀ ਹੈ ਜੋ ਲੋੜੀਂਦੇ ਫਾਰਮੈਟ ਵਿੱਚ ਗਲਤੀ ਨੂੰ ਇਕੱਠਾ ਕਰੇਗਾ। ਜੇ ਤੁਸੀਂ ਇੱਕ ਫਾਰਮ ਜਾਂ ਕੁਝ ਡੇਟਾ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰ ਰਹੇ ਹੋ ਅਤੇ ਤੁਸੀਂ ਸਪਸ਼ਟ ਤੌਰ 'ਤੇ ਜਾਣਦੇ ਹੋ ਕਿ ਗਲਤੀ ਕੀ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ, ਤਾਂ ਇਸਦੀ ਪ੍ਰਕਿਰਿਆ ਕਿਉਂ ਨਹੀਂ ਕੀਤੀ ਜਾਂਦੀ?

ਜੇਕਰ ਇਹ ਸਥਿਤੀ ਬੇਮਿਸਾਲ ਨਹੀਂ ਹੈ ਤਾਂ ਤੁਹਾਨੂੰ ਥ੍ਰੋ ਨਿਊ ਅਪਵਾਦ() ਨਿਰਮਾਣ ਨਹੀਂ ਲਿਖਣਾ ਚਾਹੀਦਾ। ਅਪਵਾਦ ਨੂੰ ਸੰਭਾਲਣਾ ਅਤੇ ਸੁੱਟਣਾ ਬਹੁਤ ਮਹਿੰਗਾ ਹੈ !!!

ToLower, ToLowerInvariant, ToUpper, ToUpperInvariant

.NET ਪਲੇਟਫਾਰਮ 'ਤੇ ਕੰਮ ਕਰਨ ਦੇ ਮੇਰੇ 5 ਸਾਲਾਂ ਦੇ ਤਜ਼ਰਬੇ ਵਿੱਚ, ਮੈਂ ਬਹੁਤ ਸਾਰੇ ਪ੍ਰੋਜੈਕਟਾਂ ਵਿੱਚ ਆਇਆ ਹਾਂ ਜੋ ਸਟ੍ਰਿੰਗ ਮੈਚਿੰਗ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਸਨ। ਮੈਂ ਹੇਠਾਂ ਦਿੱਤੀ ਤਸਵੀਰ ਵੀ ਵੇਖੀ: ਬਹੁਤ ਸਾਰੇ ਪ੍ਰੋਜੈਕਟਾਂ ਦੇ ਨਾਲ ਇੱਕ ਐਂਟਰਪ੍ਰਾਈਜ਼ ਹੱਲ ਸੀ, ਜਿਨ੍ਹਾਂ ਵਿੱਚੋਂ ਹਰ ਇੱਕ ਨੇ ਸਟ੍ਰਿੰਗ ਤੁਲਨਾ ਵੱਖਰੇ ਢੰਗ ਨਾਲ ਕੀਤੀ। ਪਰ ਕੀ ਵਰਤਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ ਅਤੇ ਇਸ ਨੂੰ ਕਿਵੇਂ ਇਕਜੁੱਟ ਕਰਨਾ ਹੈ? ਰਿਕਟਰ ਦੁਆਰਾ C# ਦੁਆਰਾ CLR ਕਿਤਾਬ ਵਿੱਚ, ਮੈਂ ਜਾਣਕਾਰੀ ਪੜ੍ਹੀ ਹੈ ਕਿ 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 ਕੋਰ 3.0 ਵਿੱਚ, ਇਹਨਾਂ ਵਿੱਚੋਂ ਹਰੇਕ ਵਿਧੀ ਲਈ ਵਾਧਾ ~x2 ਹੈ ਅਤੇ ਆਪਸ ਵਿੱਚ ਲਾਗੂਕਰਨ ਨੂੰ ਸੰਤੁਲਿਤ ਕਰਦਾ ਹੈ।

ਟੀਅਰ ਕੰਪਾਈਲੇਸ਼ਨ

ਮੇਰੇ ਪਿਛਲੇ ਲੇਖ ਵਿੱਚ ਮੈਂ ਇਸ ਕਾਰਜਕੁਸ਼ਲਤਾ ਦਾ ਸੰਖੇਪ ਵਰਣਨ ਕੀਤਾ ਹੈ, ਮੈਂ ਆਪਣੇ ਸ਼ਬਦਾਂ ਨੂੰ ਠੀਕ ਅਤੇ ਪੂਰਕ ਕਰਨਾ ਚਾਹਾਂਗਾ। ਬਹੁ-ਪੱਧਰੀ ਸੰਕਲਨ ਤੁਹਾਡੇ ਹੱਲ ਦੇ ਸ਼ੁਰੂਆਤੀ ਸਮੇਂ ਨੂੰ ਤੇਜ਼ ਕਰਦਾ ਹੈ, ਪਰ ਤੁਸੀਂ ਕੁਰਬਾਨੀ ਦਿੰਦੇ ਹੋ ਕਿ ਤੁਹਾਡੇ ਕੋਡ ਦੇ ਹਿੱਸੇ ਬੈਕਗ੍ਰਾਉਂਡ ਵਿੱਚ ਇੱਕ ਵਧੇਰੇ ਅਨੁਕੂਲਿਤ ਸੰਸਕਰਣ ਵਿੱਚ ਕੰਪਾਇਲ ਕੀਤੇ ਜਾਣਗੇ, ਜੋ ਇੱਕ ਛੋਟਾ ਓਵਰਹੈੱਡ ਪੇਸ਼ ਕਰ ਸਕਦਾ ਹੈ। NET ਕੋਰ 3.0 ਦੇ ਆਗਮਨ ਦੇ ਨਾਲ, ਟੀਅਰ ਕੰਪਾਈਲੇਸ਼ਨ ਸਮਰਥਿਤ ਪ੍ਰੋਜੈਕਟਾਂ ਲਈ ਬਿਲਡ ਟਾਈਮ ਘੱਟ ਗਿਆ ਹੈ ਅਤੇ ਇਸ ਤਕਨਾਲੋਜੀ ਨਾਲ ਜੁੜੇ ਬੱਗ ਫਿਕਸ ਕੀਤੇ ਗਏ ਹਨ। ਪਹਿਲਾਂ, ਇਸ ਤਕਨਾਲੋਜੀ ਨੇ ASP.NET ਕੋਰ ਵਿੱਚ ਪਹਿਲੀਆਂ ਬੇਨਤੀਆਂ ਵਿੱਚ ਤਰੁੱਟੀਆਂ ਪੈਦਾ ਕੀਤੀਆਂ ਸਨ ਅਤੇ ਮਲਟੀ-ਲੈਵਲ ਕੰਪਾਈਲੇਸ਼ਨ ਮੋਡ ਵਿੱਚ ਪਹਿਲੀ ਬਿਲਡ ਦੌਰਾਨ ਫ੍ਰੀਜ਼ ਹੋ ਜਾਂਦੀ ਹੈ। ਇਹ ਵਰਤਮਾਨ ਵਿੱਚ .NET ਕੋਰ 3.0 ਵਿੱਚ ਮੂਲ ਰੂਪ ਵਿੱਚ ਸਮਰੱਥ ਹੈ, ਪਰ ਜੇਕਰ ਤੁਸੀਂ ਚਾਹੋ ਤਾਂ ਇਸਨੂੰ ਅਸਮਰੱਥ ਕਰ ਸਕਦੇ ਹੋ। ਜੇਕਰ ਤੁਸੀਂ ਟੀਮ-ਲੀਡ, ਸੀਨੀਅਰ, ਮਿਡਲ ਦੇ ਅਹੁਦੇ 'ਤੇ ਹੋ, ਜਾਂ ਤੁਸੀਂ ਕਿਸੇ ਵਿਭਾਗ ਦੇ ਮੁਖੀ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ ਇਹ ਸਮਝਣਾ ਚਾਹੀਦਾ ਹੈ ਕਿ ਤੇਜ਼ੀ ਨਾਲ ਪ੍ਰੋਜੈਕਟ ਵਿਕਾਸ ਟੀਮ ਦੇ ਮੁੱਲ ਨੂੰ ਵਧਾਉਂਦਾ ਹੈ ਅਤੇ ਇਹ ਤਕਨਾਲੋਜੀ ਤੁਹਾਨੂੰ ਦੋਵਾਂ ਡਿਵੈਲਪਰਾਂ ਲਈ ਸਮਾਂ ਬਚਾਉਣ ਦੀ ਇਜਾਜ਼ਤ ਦੇਵੇਗੀ। ਅਤੇ ਪ੍ਰੋਜੈਕਟ ਦਾ ਸਮਾਂ ਖੁਦ।

.NET ਪੱਧਰ ਉੱਪਰ

ਆਪਣੇ .NET ਫਰੇਮਵਰਕ / .NET ਕੋਰ ਸੰਸਕਰਣ ਨੂੰ ਅਪਗ੍ਰੇਡ ਕਰੋ। ਅਕਸਰ, ਹਰੇਕ ਨਵਾਂ ਸੰਸਕਰਣ ਵਾਧੂ ਪ੍ਰਦਰਸ਼ਨ ਲਾਭ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ ਅਤੇ ਨਵੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਜੋੜਦਾ ਹੈ।

ਪਰ ਅਸਲ ਵਿੱਚ ਲਾਭ ਕੀ ਹਨ? ਆਓ ਉਨ੍ਹਾਂ ਵਿੱਚੋਂ ਕੁਝ ਨੂੰ ਵੇਖੀਏ:

• .NET ਕੋਰ 3.0 ਨੇ R2R ਚਿੱਤਰ ਪੇਸ਼ ਕੀਤੇ ਹਨ ਜੋ .NET ਕੋਰ ਐਪਲੀਕੇਸ਼ਨਾਂ ਦੇ ਸ਼ੁਰੂਆਤੀ ਸਮੇਂ ਨੂੰ ਘਟਾ ਦੇਣਗੇ।
• ਸੰਸਕਰਣ 2.2 ਦੇ ਨਾਲ, ਟੀਅਰ ਕੰਪਾਈਲੇਸ਼ਨ ਪ੍ਰਗਟ ਹੋਇਆ, ਜਿਸਦਾ ਧੰਨਵਾਦ ਪ੍ਰੋਗਰਾਮਰ ਇੱਕ ਪ੍ਰੋਜੈਕਟ ਲਾਂਚ ਕਰਨ ਵਿੱਚ ਘੱਟ ਸਮਾਂ ਬਿਤਾਉਣਗੇ।
• ਨਵੇਂ .NET ਮਿਆਰਾਂ ਲਈ ਸਮਰਥਨ।
• ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ ਦੇ ਇੱਕ ਨਵੇਂ ਸੰਸਕਰਣ ਲਈ ਸਮਰਥਨ।
• ਓਪਟੀਮਾਈਜੇਸ਼ਨ, ਹਰੇਕ ਨਵੇਂ ਸੰਸਕਰਣ ਦੇ ਨਾਲ ਬੇਸ ਲਾਇਬ੍ਰੇਰੀਆਂ ਕਲੈਕਸ਼ਨ/ਸਟ੍ਰਕਟ/ਸਟ੍ਰੀਮ/ਸਟ੍ਰਿੰਗ/ਰੇਜੈਕਸ ਦਾ ਅਨੁਕੂਲਨ ਅਤੇ ਹੋਰ ਬਹੁਤ ਕੁਝ ਸੁਧਾਰਦਾ ਹੈ। ਜੇਕਰ ਤੁਸੀਂ .NET ਫਰੇਮਵਰਕ ਤੋਂ .NET ਕੋਰ 'ਤੇ ਮਾਈਗਰੇਟ ਕਰ ਰਹੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ ਬਾਕਸ ਤੋਂ ਬਾਹਰ ਇੱਕ ਵੱਡਾ ਪ੍ਰਦਰਸ਼ਨ ਬੂਸਟ ਮਿਲੇਗਾ। ਇੱਕ ਉਦਾਹਰਨ ਦੇ ਤੌਰ 'ਤੇ, ਮੈਂ ਕੁਝ ਓਪਟੀਮਾਈਜੇਸ਼ਨਾਂ ਲਈ ਇੱਕ ਲਿੰਕ ਜੋੜਦਾ ਹਾਂ ਜੋ .NET ਕੋਰ 3.0 ਵਿੱਚ ਸ਼ਾਮਲ ਕੀਤੇ ਗਏ ਸਨ: https://devblogs.microsoft.com/dotnet/performance-improvements-in-net-core-3-0/

ਸਿੱਟਾ

ਕੋਡ ਲਿਖਣ ਵੇਲੇ, ਤੁਹਾਡੇ ਪ੍ਰੋਜੈਕਟ ਦੇ ਵੱਖ-ਵੱਖ ਪਹਿਲੂਆਂ ਵੱਲ ਧਿਆਨ ਦੇਣਾ ਅਤੇ ਵਧੀਆ ਨਤੀਜਾ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਤੁਹਾਡੀ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ ਅਤੇ ਪਲੇਟਫਾਰਮ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਮਹੱਤਵਪੂਰਣ ਹੈ। ਮੈਨੂੰ ਖੁਸ਼ੀ ਹੋਵੇਗੀ ਜੇਕਰ ਤੁਸੀਂ .NET ਵਿੱਚ ਓਪਟੀਮਾਈਜੇਸ਼ਨ ਨਾਲ ਸਬੰਧਤ ਆਪਣਾ ਗਿਆਨ ਸਾਂਝਾ ਕਰਦੇ ਹੋ।

ਗੀਥਬ ਨਾਲ ਲਿੰਕ ਕਰੋ

ਸਰੋਤ: www.habr.com