如何对列表进行排序，然后对该列表的子集进行排序

Question

我有一组线条。每行都是字段的集合。很容易找到第 1 列并按其内容排序：

_lines = lines.OrderBy(l => l.Fields.Find(f => f.ColumnNumber == 1).Content).ToList();

但是我如何对这个列表的一个子集进行排序呢？我想按 f.ColumnNumber == 3 排序，其中 (f.ColumnNumber == 1).Content 为 6。

所以我的线条集合看起来像这样：

Col1, Col2, Col3

1, data, data
5, data, data
6, data, Chuck
6, data, Chuck
6, data, Jeffster
6, data, Jeffster
6, data, Grunke
6, data, Gertrude
8, data, data
9, data, data

我想按 col1 排序，然后只排序 col1 == 6 的 col1，但按 col3 排序。

有没有办法在 c# 中做到这一点？我似乎找不到神奇的公式。

编辑：

我的示例数据有点过于简化了。有些行有 3 列，其他行有更多或更少的列。因此，当我使用 .ThenBy 扩展时，如果我试图对 col 3 上的行进行子排序但说第 9 行只有一列，我会得到一个对象引用，它没有设置为对象异常的实例。

这是一个更好的示例数据示例：

Col1, Col2, Col3, Col4

1, data, data, data
5, data, data
6, data, Chuck
6, data, Chuck
6, data, Jeffster
6, data, Jeffster
6, data, Grunke
6, data, Gertrude
8, data, data
9, data

Code 1 lines have 4 columns.
Code 5 lines have 3.
Code 6 lines have 3 - and I need to sort by col 3 alphabetically.
Code 8 lines have 3 columns.
Code 9 lines have 2.

无法保证列表完全排序。所以我首先需要按第一列 1-9 对行进行排序，然后我只需要按列 3 对代码 6 进行排序。

编辑 2：

我的类结构有点复杂，所以我尽量保持简单，希望它就足够了，但看起来他的情况并非如此，所以让我与你分享一下类定义：

public class Field : IField
{
    public FieldSpecification Specification { get; set; }
    public string Content { get; set; }
}

public class FieldSpecification
{
        public int ColumnNumber { get; set; }
        public int Length { get; set; }
        public int StartPosition { get; set; }
        public int EndPosition { get { return StartPosition + Length - 1; } }
        public Justification Justification { get; set; }
        public char PadCharacter { get; set; }
}

那我有一堆符合ILine接口的行

public interface ILine
{
    List<IField> Fields { get; set; }
    int Credits { get; }
    int Debits { get; }
    BigInteger Hash { get; }
}

所以从技术上讲，我在上面显示了类似 field.ColumnNumber，但它应该是 field.Specification.ColumnNumber。

目标是根据可以更改的规范构建固定宽度的文件。所以每一行都有一个带有规范的字段集合，然后数据可以进入内容，规范可以帮助做验证：格式化验证。

我希望有一种方法可以使用 linq 对列表子集进行排序，但我可能需要解构我的最终行集合，对其进行排序，然后重新构建集合。我希望避免这种情况。

Answer 1

您可以使用ThenBy 扩展名。

看看你想要的输出，看起来很简单，

 var output = lines.Select(l => new
    {
        Col1 =  int.Parse(l.Fields.Find(f => f.ColumnNumber == 1).Content),
        Col2 =  l.Fields.Find(f => f.ColumnNumber == 2).Content,
        Col3 =  l.Fields.Find(f => f.ColumnNumber == 3).Content
    }).OrderBy(l => l.Col1).ThenBy(l => l.Col3);

足够了。

---

如果由于某种原因，您只想在Col1 为6 时订购子列表，

 var output = lines.Select(l => new
    {
        Col1 =  int.Parse(l.Fields.Find(f => f.ColumnNumber == 1).Content),
        Col2 =  l.Fields.Find(f => f.ColumnNumber == 2).Content,
        Col3 =  l.Fields.Find(f => f.ColumnNumber == 3).Content
    }).OrderBy(l => l.Col1).ThenBy(l => l.Col1 == 6 ? l.Col3 : null);

---

最后一个警告，根据 Fields 的类型，可能有更好的方法来解决所有这些问题。

Answer 2

可以通过ThenBy扩展方法完成；一般来说，这个概念被称为lexicographical order。

Answer 3

如果我可以假设你的类定义是这样的：

public class Datum
{
    public int ID { get; set; }
    public string[] Cols { get; set; }
}

然后我可以这样定义数据：

var data = new []
{
    new Datum() { ID = 1, Cols = new [] { "data", "data", "data", }, },
    new Datum() { ID = 5, Cols = new [] { "data", "data", }, },
    new Datum() { ID = 6, Cols = new [] { "data", "Chuck", }, },
    new Datum() { ID = 6, Cols = new [] { "data", "Chuck", }, },
    new Datum() { ID = 6, Cols = new [] { "data", "Jeffster", }, },
    new Datum() { ID = 6, Cols = new [] { "data", "Jeffster", }, },
    new Datum() { ID = 6, Cols = new [] { "data", "Grunke", }, },
    new Datum() { ID = 6, Cols = new [] { "data", "Gertrude", }, },
    new Datum() { ID = 8, Cols = new [] { "data", "data", }, },
    new Datum() { ID = 9, Cols = new [] { "data", }, },
};

然后我可以这样排序：

var sorted =
    from d in data
    let key =
        String.Format("{0:0000}", d.ID)
        + (d.ID != 6 ? "" : "-" + d.Cols[1])
    orderby key
    select d;

我得到了这些结果：