ನೆಟ್ ಕೋರ್‌ನಲ್ಲಿ ಕಾರ್ಯಕ್ಷಮತೆ

ನೆಟ್ ಕೋರ್‌ನಲ್ಲಿ ಕಾರ್ಯಕ್ಷಮತೆ

ಎಲ್ಲರಿಗು ನಮಸ್ಖರ! ಈ ಲೇಖನವು ವಿವಿಧ ಯೋಜನೆಗಳಲ್ಲಿ ಕೆಲಸ ಮಾಡುವಾಗ ನನ್ನ ಸಹೋದ್ಯೋಗಿಗಳು ಮತ್ತು ನಾನು ದೀರ್ಘಕಾಲದವರೆಗೆ ಬಳಸುತ್ತಿರುವ ಅತ್ಯುತ್ತಮ ಅಭ್ಯಾಸಗಳ ಸಂಗ್ರಹವಾಗಿದೆ.

ಲೆಕ್ಕಾಚಾರಗಳನ್ನು ನಿರ್ವಹಿಸಿದ ಯಂತ್ರದ ಬಗ್ಗೆ ಮಾಹಿತಿ:BenchmarkDotNet=v0.11.5, OS=Windows 10.0.18362
ಇಂಟೆಲ್ ಕೋರ್ 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 vs 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):

ಕ್ಯಾಚ್ ಪ್ರಯತ್ನಿಸಿ ಕೋಡ್ ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಕಷ್ಟವಾಗುತ್ತದೆ ಮತ್ತು ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂನ ಕಾರ್ಯಗತಗೊಳಿಸುವ ಸಮಯವನ್ನು ಹೆಚ್ಚಿಸುತ್ತದೆ. ಆದರೆ ನಿಮಗೆ ಈ ನಿರ್ಮಾಣ ಅಗತ್ಯವಿದ್ದರೆ, ದೋಷಗಳನ್ನು ನಿಭಾಯಿಸಲು ನಿರೀಕ್ಷಿಸದ ಕೋಡ್‌ನ ಆ ಸಾಲುಗಳನ್ನು ನೀವು ಸೇರಿಸಬಾರದು - ಇದು ಕೋಡ್ ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಸುಲಭವಾಗುತ್ತದೆ. ವಾಸ್ತವವಾಗಿ, ಸಿಸ್ಟಮ್ ಅನ್ನು ಲೋಡ್ ಮಾಡುವ ವಿನಾಯಿತಿಗಳ ನಿರ್ವಹಣೆಯು ತುಂಬಾ ಅಲ್ಲ, ಬದಲಿಗೆ ಹೊಸ ಎಕ್ಸೆಪ್ಶನ್ ರಚನೆಯ ಮೂಲಕ ದೋಷಗಳನ್ನು ಎಸೆಯುವುದು.

ವಿನಾಯಿತಿಗಳನ್ನು ಎಸೆಯುವುದು ಕೆಲವು ವರ್ಗಕ್ಕಿಂತ ನಿಧಾನವಾಗಿರುತ್ತದೆ ಅದು ಅಗತ್ಯವಿರುವ ಸ್ವರೂಪದಲ್ಲಿ ದೋಷವನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ. ನೀವು ಫಾರ್ಮ್ ಅಥವಾ ಕೆಲವು ಡೇಟಾವನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುತ್ತಿದ್ದರೆ ಮತ್ತು ದೋಷ ಏನಾಗಿರಬೇಕು ಎಂದು ನಿಮಗೆ ಸ್ಪಷ್ಟವಾಗಿ ತಿಳಿದಿದ್ದರೆ, ಅದನ್ನು ಏಕೆ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಬಾರದು?

ಈ ಪರಿಸ್ಥಿತಿಯು ಅಸಾಧಾರಣವಾಗಿಲ್ಲದಿದ್ದರೆ ನೀವು ಥ್ರೋ ಹೊಸ ಎಕ್ಸೆಪ್ಶನ್() ರಚನೆಯನ್ನು ಬರೆಯಬಾರದು. ವಿನಾಯಿತಿಯನ್ನು ನಿಭಾಯಿಸುವುದು ಮತ್ತು ಎಸೆಯುವುದು ತುಂಬಾ ದುಬಾರಿಯಾಗಿದೆ !!!

ಟು-ಲೋವರ್, ಟು-ಲೋವರ್-ಇನ್ವೇರಿಯಂಟ್, ಟೌಪ್ಪರ್, ಟು-ಅಪ್ಪರ್ ಇನ್ವೇರಿಯಂಟ್

.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