Question

I have an unordered list that can look something like this:

1

2.2

1.1.1

3

When i sort the list, 1.1.1 becomes greater than 3 and 2.2, and 2.2 becomes greater than 3.

This is because Double.Parse removes the dots and makes it a whole number.

This is the method i use to sort with:

public class CompareCategory: IComparer<Category>
{
    public int Compare(Category c1, Category c2)
    {
        Double cat1 = Double.Parse(c1.prefix);
        Double cat2 = Double.Parse(c2.prefix);

        if (cat1 > cat2)
            return 1;
        else if (cat1 < cat2)
            return -1;
        else
            return 0;
    }
}

How can i fix this?
Thanks

Answer 1

Are these version #s by chance? Can you use the Version class? It sorts each part as you seem to want, although it only works up to 4 parts. I would not recommend parsing into a numeric value like you are doing.

It has an IComparable interface. Assuming your inputs are strings, here’s a sample:

public class CompareCategory: IComparer<Category>
{
    public int Compare(Category c1, Category c2)
    {
        var cat1 = new Version(c1.prefix);
        var cat2 = new Version(c2.prefix);

        if (cat1 > cat2)
            return 1;
        else if (cat1 < cat2)
            return -1;
        else
            return 0;
    }
}

If you need something with more than 4 “parts”, I think I would create a comparer which split the strings at the dots, and then parse each element as an integer and compare them numerically. Make sure to consider cases like 1.002.3 and 1.3.3 (what do you want the sort order to be?).

Update, here is a sample of what I mean. Lightly tested:

    public class CategoryComparer : Comparer<Category>
    {
        public override int Compare(Category x, Category y)
        {
            var xParts = x.prefix.Split(new[] { '.' });
            var yParts = y.prefix.Split(new[] { '.' });

            int index = 0;
            while (true)
            {
                bool xHasValue = xParts.Length > index;
                bool yHasValue = yParts.Length > index;
                if (xHasValue && !yHasValue)
                    return 1;   // x bigger
                if (!xHasValue && yHasValue)
                    return -1;  // y bigger
                if (!xHasValue && !yHasValue)
                    return 0;   // no more values -- same
                var xValue = decimal.Parse("." + xParts[index]);
                var yValue = decimal.Parse("." + yParts[index]);
                if (xValue > yValue)
                    return 1;   // x bigger
                if (xValue < yValue)
                    return -1;  // y bigger
                index++;
            }
        }
    }
    public static void Main()
    {
        var categories = new List<Category>()
        {
            new Category { prefix = "1" },
            new Category { prefix = "2.2" },
            new Category { prefix = "1.1.1" },
            new Category { prefix = "1.1.1" },
            new Category { prefix = "1.001.1" },
            new Category { prefix = "3" },
        };

        categories.Sort(new CategoryComparer());
        foreach (var category in categories)
            Console.WriteLine(category.prefix);
    }

Output:

1
1.001.1
1.1.1
1.1.1
2.2
3