LINQ OrderBy versus ThenBy

Alguém pode explicar qual é a diferença entre:

tmp = invoices.InvoiceCollection
              .OrderBy(sort1 => sort1.InvoiceOwner.LastName)
              .OrderBy(sort2 => sort2.InvoiceOwner.FirstName)
              .OrderBy(sort3 => sort3.InvoiceID);

e

tmp = invoices.InvoiceCollection
              .OrderBy(sort1 => sort1.InvoiceOwner.LastName)
              .ThenBy(sort2 => sort2.InvoiceOwner.FirstName)
              .ThenBy(sort3 => sort3.InvoiceID);

Qual é a abordagem correta se eu desejar solicitar por 3 itens de dados?

Você definitivamente deve usar ThenBye não várias OrderBychamadas.

Eu sugeriria isso:

tmp = invoices.InvoiceCollection
              .OrderBy(o => o.InvoiceOwner.LastName)
              .ThenBy(o => o.InvoiceOwner.FirstName)
              .ThenBy(o => o.InvoiceID);

Observe como você pode usar o mesmo nome toda vez. Isso também é equivalente a:

tmp = from o in invoices.InvoiceCollection
      orderby o.InvoiceOwner.LastName,
              o.InvoiceOwner.FirstName,
              o.InvoiceID
      select o;

Se você ligar OrderByvárias vezes, ele efetivamente reordenará a sequência completamente três vezes ... para que a chamada final seja efetivamente a dominante. Você pode (no LINQ to Objects) escrever

foo.OrderBy(x).OrderBy(y).OrderBy(z)

o que seria equivalente a

foo.OrderBy(z).ThenBy(y).ThenBy(x)

como a ordem de classificação é estável, mas você absolutamente não deve:

• É difícil de ler
• Não funciona bem (porque reordena toda a sequência)
• Pode não funcionar em outros provedores (por exemplo, LINQ to SQL)
• Basicamente, não é como OrderByfoi projetado para ser usado.

O objetivo de OrderByé fornecer a projeção de pedidos "mais importante"; use ThenBy(repetidamente) para especificar projeções secundárias, terciárias, etc.

Efetivamente, pense dessa maneira: OrderBy(...).ThenBy(...).ThenBy(...)permite criar uma única comparação composta para dois objetos e, em seguida, classifique a sequência uma vez usando essa comparação composta. Isso é quase certamente o que você deseja.

Achei essa distinção irritante ao tentar criar consultas de maneira genérica, então ajudei um pouco a produzir OrderBy / ThenBy na ordem correta, para quantos tipos você quiser.

public class EFSortHelper
{
  public static EFSortHelper<TModel> Create<TModel>(IQueryable<T> query)
  {
    return new EFSortHelper<TModel>(query);
  }
}  

public class EFSortHelper<TModel> : EFSortHelper
{
  protected IQueryable<TModel> unsorted;
  protected IOrderedQueryable<TModel> sorted;

  public EFSortHelper(IQueryable<TModel> unsorted)
  {
    this.unsorted = unsorted;
  }

  public void SortBy<TCol>(Expression<Func<TModel, TCol>> sort, bool isDesc = false)
  {
    if (sorted == null)
    {
      sorted = isDesc ? unsorted.OrderByDescending(sort) : unsorted.OrderBy(sort);
      unsorted = null;
    }
    else
    {
      sorted = isDesc ? sorted.ThenByDescending(sort) : sorted.ThenBy(sort)
    }
  }

  public IOrderedQueryable<TModel> Sorted
  {
    get
    {
      return sorted;
    }
  }
}

Há várias maneiras de você usar isso dependendo do seu caso de uso, mas se, por exemplo, você passar uma lista de colunas e direções de classificação como strings e bools, poderá fazer um loop sobre elas e usá-las em uma opção como:

var query = db.People.AsNoTracking();
var sortHelper = EFSortHelper.Create(query);
foreach(var sort in sorts)
{
  switch(sort.ColumnName)
  {
    case "Id":
      sortHelper.SortBy(p => p.Id, sort.IsDesc);
      break;
    case "Name":
      sortHelper.SortBy(p => p.Name, sort.IsDesc);
      break;
      // etc
  }
}

var sortedQuery = sortHelper.Sorted;

O resultado em sortedQueryé classificado na ordem desejada, em vez de recorrer repetidamente, como a outra resposta aqui alerta.

se você quiser classificar mais de um campo, vá para ThenBy:

como isso

list.OrderBy(personLast => person.LastName)
            .ThenBy(personFirst => person.FirstName)

Sim, você nunca deve usar múltiplos OrderBy se estiver tocando com várias teclas. ThenBy é uma aposta mais segura, pois será executada após OrderBy.