Сортировка массива

using System.Collections.Generic;
 
namespace DBClient.Services.Sorters
{
    public class NaturalStringComparer : IComparer<string>
    {
        public static NaturalStringComparer Instance { get; } = new NaturalStringComparer();
 
        public int Compare(string x, string y)
        {
            string s1 = x;
            if (s1 == null)
            {
                return 0;
            }
            string s2 = y;
            if (s2 == null)
            {
                return 0;
            }
 
            int len1 = s1.Length;
            int len2 = s2.Length;
            int marker1 = 0;
            int marker2 = 0;
 
            // Walk through two the strings with two markers.
            while (marker1 < len1 && marker2 < len2)
            {
                char ch1 = s1[marker1];
                char ch2 = s2[marker2];
 
                // Some buffers we can build up characters in for each chunk.
                char[] space1 = new char[len1];
                int loc1 = 0;
                char[] space2 = new char[len2];
                int loc2 = 0;
 
                // Walk through all following characters that are digits or
                // characters in BOTH strings starting at the appropriate marker.
                // Collect char arrays.
                do
                {
                    space1[loc1++] = ch1;
                    marker1++;
 
                    if (marker1 < len1)
                    {
                        ch1 = s1[marker1];
                    }
                    else
                    {
                        break;
                    }
                } while (char.IsDigit(ch1) == char.IsDigit(space1[0]));
 
                do
                {
                    space2[loc2++] = ch2;
                    marker2++;
 
                    if (marker2 < len2)
                    {
                        ch2 = s2[marker2];
                    }
                    else
                    {
                        break;
                    }
                } while (char.IsDigit(ch2) == char.IsDigit(space2[0]));
 
                // If we have collected numbers, compare them numerically.
                // Otherwise, if we have strings, compare them alphabetically.
                string str1 = new string(space1);
                string str2 = new string(space2);
 
                int result;
 
                if (char.IsDigit(space1[0]) && char.IsDigit(space2[0]))
                {
                    long thisNumericChunk = long.Parse(str1);
                    long thatNumericChunk = long.Parse(str2);
                    result = thisNumericChunk.CompareTo(thatNumericChunk);
                }
                else
                {
                    result = str1.CompareTo(str2);
                }
 
                if (result != 0)
                {
                    return result;
                }
            }
            return len1 - len2;
        }
    }
}

using System;
using System.Collections;
 
using DTOClassLibrary.DTO;
 
namespace DBClient.Services.Sorters
{
    public class GPReportSorter : IComparer
    {
        // Наш сортировщик
        private readonly NaturalStringComparer _stringComparer = NaturalStringComparer.Instance;
 
        public int Compare(object x, object y)
        {
            if (x is not GPReport && y is not GPReport)
                throw new ArgumentException("Этот тип объектов не поддерживается!");
 
            GPReport _x = x as GPReport;
            GPReport _y = y as GPReport;
 
            int result = _stringComparer.Compare(_x.KKS, _y.KKS);
 
            if (result == 0)
                result = _stringComparer.Compare(_x.Abbreviation, _y.Abbreviation);
 
            return result;
        }
    }
}

draws = draws
    .OrderBy(d => d.DNumber, NaturalStringComparer.Instance)
    .ToList();

_sourceDrawReport = (CollectionViewSource)Resources["DrawReportsSort"];
_sourceGPlans = (CollectionViewSource)Resources["GPlansSort"];
 
_viewDrawReport = (ListCollectionView)_sourceDrawReport.View;
_viewGPlans = (ListCollectionView)_sourceGPlans.View;
 
_viewDrawReport.CustomSort = DrawReportSorter.Instance;
_viewGPlans.CustomSort = GPlanSorter.Instance;

using System.Collections.Generic;
 
using DTOClassLibrary.DTO;
 
namespace VModels.Services.Sorters
{
    public class MRNZPositionSorter : IComparer<MRNZPosition>
    {
        private readonly NaturalStringComparer _stringComparer = NaturalStringComparer.Instance;
 
        public static MRNZPositionSorter Instance { get; } = new MRNZPositionSorter();
 
        public int Compare(MRNZPosition x, MRNZPosition y)
        {
            int result = _stringComparer.Compare(x.DNumber, y.DNumber);
 
            if (result == 0)
                result = _stringComparer.Compare(x.DSheet, y.DSheet);
 
            if (result == 0)
                result = _stringComparer.Compare(x.WorkName, y.WorkName);
 
            return result;
        }
    }
}

using System;
using System.Collections.Generic;
 
namespace DBClient.Services.Sorters
{
    public class NaturalStringComparer : IComparer<string>
    {
        public static NaturalStringComparer Instance { get; } = new NaturalStringComparer();
 
        public int Compare(string x, string y)
        {
            if (x == null || y == null)
                return 0;
 
            int len1 = x.Length;
            int len2 = y.Length;
            int marker1 = 0;
            int marker2 = 0;
 
            while (marker1 < len1 && marker2 < len2)
            {
                bool isDigit1 = char.IsDigit(x[marker1]);
                bool isDigit2 = char.IsDigit(y[marker2]);
 
                int loc1 = 0;
                int loc2 = 0;
 
                do
                {
                    loc1 += 1;
                    marker1 += 1;
                } while (marker1 < len1 && char.IsDigit(x[marker1]) == isDigit1);
 
                do
                {
                    loc2 += 1;
                    marker2 += 1;
                } while (marker2 < len2 && char.IsDigit(y[marker2]) == isDigit2);
 
                int result;
 
                if (isDigit1 && isDigit2)
                {
                    long thisNumericChunk = long.Parse(x.AsSpan(marker1 - loc1, loc1));
                    long thatNumericChunk = long.Parse(y.AsSpan(marker2 - loc2, loc2));
 
                    result = thisNumericChunk.CompareTo(thatNumericChunk);
                }
                else
                {
                    result = string.Compare(x, marker1 - loc1, y, marker2 - loc2, Math.Min(loc1, loc2));
                }
 
                if (result != 0)
                    return result;
            }
 
            return len1 - len2;
        }
    }
}

else
{
    result = string.Compare(x, marker1 - loc1, y, marker2 - loc2, Math.Max(loc1, loc2));
}