Algorithms

struct Record
{
    public int T { get; set; }
    public int H { get; set; }
    public int L { get; set; }
}

Record[] UnsortedRecords =
{
    new Record { T = 0, H = 0, L = 2 },
    new Record { T = 1, H = 2, L = 1 },
    new Record { T = 0, H = 1, L = 4 },
    new Record { T = 0, H = 0, L = 0 },
    new Record { T = 2, H = 4, L = 2 },
    new Record { T = 2, H = 3, L = 6 },
};

public static IEnumerable<Record> SortRecords(IEnumerable<Record> source)
{
    return source
        .GroupBy(r => r.T, (key, items) => items
            .GroupBy(r => r.H)
            .SelectMany(g => g)
        )
        .SelectMany(g => g);
}

IEnumerable<Record> SortedRecords = SortRecords(UnsortedRecords);

/*
Sorted records:

T0 H0 L2 
T0 H0 L0 
T0 H1 L4 
T1 H2 L1 
T2 H4 L2 
T2 H3 L6 
*/

Enumerable.GroupBy[^]:

The IGrouping<TKey,TElement> objects are yielded in an order based on the order of the elements in source that produced the first key of each IGrouping<TKey,TElement>. Elements in a grouping are yielded in the order they appear in source.

source.GroupBy(r => new { r.T, r.H }).SelectMany(g => g);

/*
Result:

T0 H0 L2 
T0 H0 L0 
T1 H2 L1 
T0 H1 L4 
T2 H4 L2 
T2 H3 L6 
*/

public static IEnumerable<Record> SortRecords(IEnumerable<Record> source)
{
    IEnumerable<IEnumerable<Record>> groupT = Enumerable.GroupBy(source, 
        delegate(Record r) { return r.T; },
        delegate(int key, IEnumerable<Record> items)
        {
            IEnumerable<IGrouping<int, Record>> groupH = Enumerable.GroupBy(items, delegate(Record r) { return r.H; });
            return Enumerable.SelectMany(groupH, delegate(IGrouping<int, Record> g) { return g; });
        });
    
    return Enumerable.SelectMany(groupT, delegate(IEnumerable<Record> g) { return g; });
}

public static IEnumerable<Record> SortRecords(IEnumerable<Record> source)
{
    IEnumerable<IEnumerable<Record>> groupT = Enumerable.GroupBy<Record, int, IEnumerable<Record>>(source, 
        delegate(Record r) { return r.T; },
        delegate(int key, IEnumerable<Record> items)
        {
            IEnumerable<IGrouping<int, Record>> groupH = Enumerable.GroupBy<Record, int>(items, delegate(Record r) { return r.H; });
            return Enumerable.SelectMany<IEnumerable<Record>, Record>(groupH, delegate(IEnumerable<Record> g) { return g; });
        });
    
    return Enumerable.SelectMany<IEnumerable<Record>, Record>(groupT, delegate(IEnumerable<Record> g) { return g; });
}

private static Int32 SortByLengthThenAlpha(String x, String y) {
  // 1st sort
  Int32 result = x.Length.CompareTo(y.Length);
  // result will be < 0, 0, > 0

  if (result == 0) {
    // 2nd Sort, standard string sort
    result = x.CompareTo(y);

    // and so on if more is needed
    // if (result==0) {
    // }
    //
  }
  return result;
}

Array.Sort(strings, SortByLengthThenAlpha);

Original Order
==============
Reddish
Yellowish
Redder
Greenish
Red
Orange
Yellow
Orangy
Green

Sorted
======
Red
Green
Orange
Orangy
Redder
Yellow
Reddish
Greenish
Yellowish