Natural Sort in C#

Natural or Human Sort is the very useful sort where the string "10" comes after the string "9" instead of before "9" and after "1".

If you have a list of files what are numbered you'll probably notice that Windows XP sorts these using a natural sort algorithm.

Useful languages like PHP have a natural sort as part of their base libraries. Unfortunately .Net did not get a natural sort comparer.

So, using http://sourcefrog.net/projects/natsort/ and http://www.mircscripts.org/showdoc.php?type=code&id=2771 as references I have created a Natural Sort compare algorithm in C#

#region Natural Sort
/// <summary>
/// Performs a natural sort order comparison of the strings. This can be used by CompareTo methods of
/// objects that want to be sorted. See: http://sourcefrog.net/projects/natsort/
/// </summary>
/// <param name="a"></param>
/// <param name="b"></param>
/// <returns></returns>
public static int NaturalCompareTo(string a, string b)
{
    // String is not an object and so this doesn't change the passed in value
    a = a.ToUpper();
    b = b.ToUpper();
    
    int indexA = 0;
    int indexB = 0;
    int result = 0;
    string aPart = " ", bPart = " ";
    while (true)
    {
        aPart = indexA < a.Length ? a.Substring(indexA, 1) : "";
        bPart = indexB < b.Length ? b.Substring(indexB, 1) : "";
    
        while (IsSpace(aPart))
        {
            aPart = ++indexA < a.Length ? a.Substring(indexA, 1) : "";
        }
        while (IsSpace(bPart))
        {
            bPart = ++indexB < b.Length ? b.Substring(indexB, 1) : "";
        }
    
        if (IsDigit(aPart) && IsDigit(bPart))
        {
            if (aPart.Equals("0") || bPart.Equals("0"))
            {
                result = NatCompareLeft(a.Substring(indexA), b.Substring(indexB));
                if (result != 0)
                {
                    return result;
                }
            }
            else
            {
                result = NatCompareRight(a.Substring(indexA), b.Substring(indexB));
                if (result != 0)
                {
                    return result;
                }
            }
        }
    
        if (IsEmpty(aPart) && IsEmpty(bPart))
        {
            return 0;
        }
    
        result = aPart.CompareTo(bPart);
        if (result != 0)
        {
            return result;
        }
    
    
        indexA++;
        indexB++;
    }

}


private static bool IsDigit(string theValue)
{
    if (theValue.CompareTo("0") >= 0 && theValue.CompareTo("9") <= 0 && theValue.Length == 1)
    {
        return true;
    }
    else
    {
        return false;
    }
}

private static bool IsSpace(string theValue)
{
    switch (theValue)
    {
        case " ":
        case "\t":
        case "\n":
        case "\r":
        case "\v":
        case "\f":
            return true;
        default:
            return false;
    }
}
private static int NatCompareRight(string a, string b)
{
    int bias = 0;
    int index = 0;
    string aPart, bPart;
    
    while (true)
    {
        aPart = index < a.Length ? a.Substring(index, 1) : "";
        bPart = index < b.Length ? b.Substring(index, 1) : "";
    
        if (!IsDigit(aPart) && !IsDigit(bPart))
        {
            return bias;
        }
        else if (!IsDigit(aPart))
        {
            return -1;
        }
        else if (!IsDigit(bPart))
        {
            return 1;
        }
        else if (aPart.CompareTo(bPart) < 0)
        {
            if (bias == 0) bias = -1;
        }
        else if (aPart.CompareTo(bPart) > 0)
        {
            if (bias == 0) bias = 1;
        }
    
        index++;
    }
    

}


private static int NatCompareLeft(string a, string b)
{
    int index = 0;
    string aPart, bPart;
    
    while (true)
    {
        aPart = index < a.Length ? a.Substring(index, 1) : "";
        bPart = index < b.Length ? b.Substring(index, 1) : "";
    
        if (!IsDigit(aPart) && !IsDigit(bPart))
        {
            return 0;
        }
        else if (!IsDigit(aPart))
        {
            return -1;
        }
        else if (!IsDigit(bPart))
        {
            return 1;
        }
        else if (aPart.CompareTo(bPart) < 0)
        {
            return -1;
        }
        else if (aPart.CompareTo(bPart) > 0)
        {
            return 1;
        }
    
        index++;
    }

}


#endregion