C# Linq Complicated Order by

Question

I have a list of strings something like:-

"008","a", "007","b", "c","009"

Need OutPut:-

"a", "b", "c", "007", "008", "009" What i tried so far

string[] things= new string[] {  "aaul", "bob", "lauren", "007", "008", "009"};



foreach (var thing in things.AsQueryable().OrderByDescending(x => x, new SemiNumericComparer()))
{    
    Console.WriteLine(thing);
}

public class SemiNumericComparer: IComparer<string>
{
    public int Compare(string s1, string s2)
    {
        if (IsNumeric(s1) && IsNumeric(s2))
        {
             if (Convert.ToInt32(s1) > Convert.ToInt32(s2)) return 0;
            if (Convert.ToInt32(s1) < Convert.ToInt32(s2)) return 1;
            if (Convert.ToInt32(s1) == Convert.ToInt32(s2)) return -1;
        }

        if (IsNumeric(s1) && !IsNumeric(s2)){
            return -1;
        }

        if (!IsNumeric(s1) && IsNumeric(s2)){
            return 1;

        };
        return string.Compare(s1, s2, true);
    }

    public static bool IsNumeric(object value)
    {
        try {
            int i = Convert.ToInt32(value.ToString());
            return true; 
        }
        catch (FormatException) {
            return false;
        }
    }
}

I Already tried

Here is problem fiddle using above solution

I am able to get output like

a,b,c,009,008,007 Or 007,008,009,c,b,a but need a,b,c,007,008,009 Any Idea?

Answer 1

You want to order into two group, first those which aren't integers followed by the integeres. The first group is ordered lexicographically while the numbers are ordered by their value?

I'd use an extension method like following that try-parses the string to int:

public static int? TryGetInt(this string item)
{
    int i;
    bool success = int.TryParse(item, out i);
    return success ? (int?)i : (int?)null;
}

Then you could use this LINQ query to get the desired order:

string[] things = new string[] { "008", "bob", "009", "007", "aaul", "lauren" };

var ordered = things
    .Select(s => new { s, numberOrNull = s.TryGetInt() }) // store in anonymous type
    .OrderBy(x => x.numberOrNull.HasValue ? 1 : 0)        // first non-integer group
    .ThenBy(x => x.numberOrNull.HasValue ? x.numberOrNull.Value : int.MinValue) // then by number value
    .ThenBy(x => x.s)  // if they weren't numbers order lexicographically
    .Select(x => x.s); // select the string

Answer 2

First separate different groups of starting letter (digit or non-digit), then sort each group

things.OrderBy(x => char.IsDigit(x.FirstOrDefault())).ThenBy(x => x)

Answer 3

public class SemiNumericComparer: IComparer<string>
{
    public int Compare(string s1, string s2)
    {
        if (IsNumeric(s1) && IsNumeric(s2))
        {
            if (Convert.ToInt32(s1) > Convert.ToInt32(s2)) return 1;
            if (Convert.ToInt32(s1) < Convert.ToInt32(s2)) return -1;
            if (Convert.ToInt32(s1) == Convert.ToInt32(s2)) return 0;
        }

        if (IsNumeric(s1) && !IsNumeric(s2))
            return 1;

        if (!IsNumeric(s1) && IsNumeric(s2))
            return -1;

        return string.Compare(s1, s2, true);
    }

    public static bool IsNumeric(object value)
    {
        try {
            int i = Convert.ToInt32(value.ToString());
            return true; 
        }
        catch (FormatException) {
            return false;
        }
    }
}

Taken from here and modified it to sort letters first

Use OrderBy instead of OrderByDescending

Answer 4

Sort by int / not int first, then by content

string[] things = new string[] { "a", "b", "c", "009", "008", "007" };
int temp=0;
string[] result = things.OrderBy(x => int.TryParse(x, out temp))
                        .ThenBy(x => x)
                        .ToArray();

---

Update to Tim's comment (natural order for the int values and lexicographical for the strings)

string[] things = new string[] { "c", "b", "a", "009", "008", "007" , "1234", "299" };
int temp = 0;
string[] result = things.OrderBy(x => int.TryParse(x, out temp) ? temp : int.MinValue)
                        .ThenBy(x => x)
                        .ToArray();

Answer 5

Try the following with Regex:

string[] str = { "008", "abhi", "007", "bcd", "cde", "009" };
str = str.OrderBy(x => Regex.IsMatch(x, @"^\d+$")).ThenBy(x => x).ToArray<string>();

Answer 6

What you have done wrong is the implementation of the Compare method.

Look carefully at the docs:

Return value

A signed integer that indicates the relative values of x and y, as shown in the following table.

Value                 Meaning
Less than zero        x is less than y.
Zero                  x equals y.
Greater than zero     x is greater than y.

You are returning the reverse of what it should in the "both strings are numeric" case. Just switch that around and it will work:

 if (Convert.ToInt32(s1) > Convert.ToInt32(s2)) return 1;
if (Convert.ToInt32(s1) < Convert.ToInt32(s2)) return -1;
if (Convert.ToInt32(s1) == Convert.ToInt32(s2)) return 0;

Answer 7

Try this:

public class SemiNumericComparer : IComparer<string>
{
    public int Compare(string s1, string s2)
    {
        int i1, i2;
        bool b1 = int.TryParse(s1, out i1);
        bool b2 = int.TryParse(s2, out i2);
        if (b1 && b2)
        {
            return i1.CompareTo(i2);
        }
        if (b1) return 1;
        if (b2) return -1;
        return string.Compare(s1, s2, true);
    }
}