Ordem LINQ por coluna nula, em que a ordem é crescente e os nulos devem ser os últimos

Estou tentando classificar uma lista de produtos pelo preço.

O conjunto de resultados precisa listar produtos por preço, de baixo a alto, pela coluna LowestPrice. No entanto, esta coluna é anulável.

Posso classificar a lista em ordem decrescente da seguinte forma:

var products = from p in _context.Products
   where p.ProductTypeId == 1
   orderby p.LowestPrice.HasValue descending
   orderby p.LowestPrice descending
   select p;

// returns:    102, 101, 100, null, null

No entanto, não consigo descobrir como classificar isso em ordem crescente.

// i'd like: 100, 101, 102, null, null

Tente colocar as duas colunas na mesma ordem, por.

orderby p.LowestPrice.HasValue descending, p.LowestPrice

Caso contrário, cada pedido será uma operação separada na coleção, reordenando-o a cada vez.

Isso deve ordenar os que têm um valor primeiro, "depois" a ordem do valor.

Realmente ajuda a entender a sintaxe da consulta LINQ e como ela é convertida em chamadas de método LINQ.

Acontece que

var products = from p in _context.Products
               where p.ProductTypeId == 1
               orderby p.LowestPrice.HasValue descending
               orderby p.LowestPrice descending
               select p;

será traduzido pelo compilador para

var products = _context.Products
                       .Where(p => p.ProductTypeId == 1)
                       .OrderByDescending(p => p.LowestPrice.HasValue)
                       .OrderByDescending(p => p.LowestPrice)
                       .Select(p => p);

Isso não é enfaticamente o que você deseja. Isso classifica por Product.LowestPrice.HasValueem descendingordem e, em seguida, re-ordena toda a coleção por Product.LowestPriceemdescending ordem.

O que você quer é

var products = _context.Products
                       .Where(p => p.ProductTypeId == 1)
                       .OrderByDescending(p => p.LowestPrice.HasValue)
                       .ThenBy(p => p.LowestPrice)
                       .Select(p => p);

que você pode obter usando a sintaxe da consulta,

var products = from p in _context.Products
               where p.ProductTypeId == 1
               orderby p.LowestPrice.HasValue descending,
                       p.LowestPrice
               select p;

Para detalhes das traduções da sintaxe da consulta para chamadas de método, consulte a especificação do idioma. Seriamente. Leia-o.

A solução para valores de string é realmente estranha:

.OrderBy(f => f.SomeString == null).ThenBy(f => f.SomeString) 

O único motivo que funciona é porque a primeira expressão OrderBy(), classifica boolvalores: true/ false. falseO resultado segue primeiro o trueresultado (nulos) e ThenBy()classifica os valores não nulos em ordem alfabética.

Então, eu prefiro fazer algo mais legível como este:

.OrderBy(f => f.SomeString ?? "z")

Se SomeStringfor nulo, será substituído por "z"e, em seguida, classificar tudo em ordem alfabética.

NOTA: Esta não é uma solução definitiva, pois "z"vai primeiro do que os valores-z zebra.

ATUALIZAÇÃO 6/6/2016 - Sobre o comentário @jornhd, é realmente uma boa solução, mas ainda é um pouco complexa, portanto, recomendo envolvê-lo em uma classe Extension, como esta:

public static class MyExtensions
{
    public static IOrderedEnumerable<T> NullableOrderBy<T>(this IEnumerable<T> list, Func<T, string> keySelector)
    {
        return list.OrderBy(v => keySelector(v) != null ? 0 : 1).ThenBy(keySelector);
    }
}

E use-o como:

var sortedList = list.NullableOrderBy(f => f.SomeString);

Eu tenho outra opção nesta situação. Minha lista é objList, e eu tenho que pedir, mas os nulos devem estar no final. minha decisão:

var newList = objList.Where(m=>m.Column != null)
                     .OrderBy(m => m.Column)
                     .Concat(objList.where(m=>m.Column == null));

Eu estava tentando encontrar uma solução LINQ para isso, mas não consegui resolver isso com as respostas aqui.

Minha resposta final foi:

.OrderByDescending(p => p.LowestPrice.HasValue).ThenBy(p => p.LowestPrice)

minha decisão:

Array = _context.Products.OrderByDescending(p => p.Val ?? float.MinValue)

Isso é o que eu criei porque estou usando métodos de extensão e também meu item é uma string, portanto não .HasValue:

.OrderBy(f => f.SomeString == null).ThenBy(f => f.SomeString)

Isso funciona com objetos LINQ 2 na memória. Não testei com a EF ou com qualquer DB ORM.

Abaixo está o método de extensão para verificar se é nulo se você deseja classificar na propriedade filho de um keySelector.

public static IOrderedEnumerable<T> NullableOrderBy<T>(this IEnumerable<T> list, Func<T, object> parentKeySelector, Func<T, object> childKeySelector)
{
    return list.OrderBy(v => parentKeySelector(v) != null ? 0 : 1).ThenBy(childKeySelector);
}

E use-o como:

var sortedList = list.NullableOrderBy(x => x.someObject, y => y.someObject?.someProperty);

Aqui está outra maneira:

//Acsending
case "SUP_APPROVED_IND": qry =
                            qry.OrderBy(r => r.SUP_APPROVED_IND.Trim() == null).
                                    ThenBy(r => r.SUP_APPROVED_IND);

                            break;
//….
//Descending
case "SUP_APPROVED_IND": qry =
                            qry.OrderBy(r => r.SUP_APPROVED_IND.Trim() == null).
                                    ThenByDescending(r => r.SUP_APPROVED_IND); 

                            break;

SUP_APPROVED_IND is char(1) in Oracle db.

Observe que r.SUP_APPROVED_IND.Trim() == nullé tratado comotrim(SUP_APPROVED_IND) is null no Oracle db.

Veja isto para detalhes: Como posso consultar valores nulos na estrutura da entidade?

Outra opção (útil para o nosso cenário):

Temos uma tabela de usuários, armazenando ADName, LastName, FirstName

• Os usuários devem ser alfabéticos
• Contas sem nome / sobrenome também, com base em seu nome AD - mas no final da lista de usuários
• Usuário fictício com o ID "0" ("Sem seleção") deve estar sempre no topo.

Alteramos o esquema da tabela e adicionamos uma coluna "SortIndex", que define alguns grupos de classificação. (Deixamos uma diferença de 5, para inserir grupos mais tarde)

ID | ADName |      First Name | LastName | SortIndex
0    No Selection  null         null     | 0
1    AD\jon        Jon          Doe      | 5
3    AD\Support    null         null     | 10     
4    AD\Accounting null         null     | 10
5    AD\ama        Amanda       Whatever | 5

Agora, em termos de consulta, seria:

SELECT * FROM User order by SortIndex, LastName, FirstName, AdName;

em Expressões de método:

db.User.OrderBy(u => u.SortIndex).ThenBy(u => u.LastName).ThenBy(u => u.FirstName).ThenBy(u => u.AdName).ToList();

que produz o resultado esperado:

ID | ADName |      First Name | LastName | SortIndex
0    No Selection  null         null     | 0
5    AD\ama        Amanda       Whatever | 5
1    AD\jon        Jon          Doe      | 5
4    AD\Accounting null         null     | 10
3    AD\Support    null         null     | 10