How can I get a sorted `List` based on an associated numeric index

Question

I want to sort a string using indexes, but it's not working after 10th index, 10th/later indexes added after 1st index in the list after using Sort() method.

I have tried below code, but it's not working.

List<string> stringList = new List<string>();

foreach (ManagementObject disk in objectSearcher.Get() )
{
    stringList.Add(string.Format("{0, -15} {1,-35} {2, -20}",
                                disk.GetPropertyValue("Index"),
                                disk.GetPropertyValue("Model"),
                                diskSize));
}
stringList.Sort();

In the above scenario, the code is working fine for 0-9 indexes but for later indexes, this is not working as expected.

Answer 1

Put your object into a class structure and work with that strong type as long as possible:

public class DiskInfo
{
    private int index = 0;
    private string model = String.Empty;
    private unsigned long size = 0;

    public int getIndex() { return index; }
    public string getModel() { return model; }
    public unsigned long getSize() { return size; }

    public DiskInfo(int index, string model, unsigned long size)
    {
        this.index = index;
        this.model = model;
        this.size = size;
    }

    public string ToString()
    {
        return string.Format("{0, -15} {1,-35} {2, -20}", index, model, size);
    }
}
// ...
List<DiskInfo> lst = new List<DiskInfo>();
foreach (ManagementObject disk in objectSearcher.Get() )
{
    lst.Add(new DiskInfo(
        disk.GetPropertyValue("Index"),
        disk.GetPropertyValue("Model"),
        diskSize
    ));
}

Adjust types as needed.
Then you can use simple linq to sort.

lst = lst.OrderBy(x => x.getIndex());

On top of that you get IDE support and compiler errors instead of trying to figure out why you get format exceptions, etc when mucking around with strings. If your input data is not of the correct data type, then cast it then and there.
For example, index gets passed as a string:

string strIdx = "15";
lst.Add(new DiskInfo(int.Parse(strIdx)), ...)

Answer 2

It's not working after 10th index.

That is because List().Sort invoke string's comparison function.In string comparison "0" is less than "1", "1" is less than "11" and "12" is less than "2" etc.So it is not working after 10.

You can definition a sample comparison function as below:

 public static int Compare(string a, string b)
        {
            return int.Parse(a.Substring(0, 15)).CompareTo(int.Parse(b.Substring(0, 15)));
        }

and then invoke it in sort method:

stringList.Sort(Compare);

The prerequisite is that your format is satisfied that its first 15 characters can convert to an integer.

Answer 3

You seem to be deliberately left aligning index your numbers, which will mean that the ascending string sorted sequence of 1 through 12 would would be 1, 11, 12, 2, 3, 4, ...

Since you have the index value during the creation of the string, it would be wasteful to again parse the number out of the string in order to sort it. It would be better to retain the index and the string separately in a suitable data structure, sort by the index, and then project out just the string.

Updated for OP's new Question

Creating a custom POCO class (with or without an IComparable implementation) seems overkill everytime you need to sort an enumerable of related data by one of its properties.

Instead, you can easily build up a sortable anon class, struct or tuple containing the sortable integer and the concatenated string, then sort, then project out just the string. Either way, OP's GetPropertyValue method appears to return (reflect) a weak type such as object or string - accepted answer wouldn't compile as it needs to cast index to an int.

Here's value tuple solution:

var tuples = new List<(int index, string str)>();

foreach (ManagementObject disk in objectSearcher.Get() )
{
    var indexValue = int.Parse(disk.GetPropertyValue("Index"));
    tuples.Add((indexValue, string.Format("{0, -15} {1,-35} {2, -20}",
                                indexValue,
                                disk.GetPropertyValue("Model"),
                                diskSize)));
}

// Sort by index, and project out the assembled string.
var myList = tuples
          .OrderBy(t => t.index)
          .Select(t => t.str)
          .ToList();

Original Answer, OP had a simple loop

What I've done below is to keep a Value tuple of the original string, and the parsed integer value of the first 15 digits.

Note that this will break if there are non-numeric characters in the first 15 characters of your string.

// Test Data
var strings = Enumerable.Range(0, 12)
  .Select(i => (string.Format("{0, -15} {1,-35} {2, -20}", i, "Model", "35GB")));

// Project out a tuple of (index, string)    
var indexedTuples = strings.Select(s => (idx: int.Parse(s.Substring(0, 15)), str: s));
var sorted = indexedTuples.OrderBy(t => t.idx)
                          .Select(t => t.str);

Answer 4

You are probably looking for the "logical sort order" seen in Windows Explorer. Below I have replaced the default string comparer with a comparer using that API: StrCmpLogicalW

class Program
{
    public sealed class NaturalStringComparer : IComparer<string>
    {
        [DllImport("shlwapi.dll", CharSet = CharSet.Unicode)]
        public static extern int StrCmpLogicalW(string psz1, string psz2);

        public int Compare(string a, string b) => StrCmpLogicalW(a, b);
    }

    static void Main()
    {
        var stringList = new List<string>();

        var index = 0;
        while (index < 12)
        {
            stringList.Add($"{index,-15} {"Model",-35} {"35GB",-20}");
            index++;
        }

        stringList.Sort(new NaturalStringComparer());

        foreach (var s in stringList)
        {
            Console.WriteLine(s);
        }
    }
}