LINQ order by null kolumna, gdzie kolejność jest rosnąca, a wartości null powinny być ostatnie

Próbuję posortować listę produktów według ich ceny.

Zestaw wyników musi zawierać listę produktów według ceny od najniższej do najwyższej według kolumny LowestPrice . Jednak ta kolumna ma wartość null.

Mogę posortować listę malejąco w następujący sposób:

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

Jednak nie mogę dowiedzieć się, jak posortować to w kolejności rosnącej.

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

Spróbuj umieścić obie kolumny w tej samej kolejności

orderby p.LowestPrice.HasValue descending, p.LowestPrice

W przeciwnym razie każde zlecenie jest osobną operacją na kolekcji, za każdym razem zmieniając jego kolejność.

Powinno to uporządkować najpierw te, które mają wartość, a następnie kolejność wartości.

Naprawdę pomaga zrozumieć składnię zapytania LINQ i sposób jej tłumaczenia na wywołania metod LINQ.

Okazało się, że

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

zostaną przetłumaczone przez kompilator na

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

To zdecydowanie nie jest to, czego chcesz. Te rodzaje by Product.LowestPrice.HasValuew descendingkolejności, a następnie ponownie sortuje przez całą kolekcję Product.LowestPricew descendingporządku.

To czego chcesz

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

które można uzyskać za pomocą składni zapytania

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

Aby uzyskać szczegółowe informacje na temat tłumaczenia składni zapytania na wywołania metod, zobacz specyfikację języka. Poważnie. Przeczytaj to.

Rozwiązanie dla wartości łańcuchowych jest naprawdę dziwne:

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

Jedynym powodem, dla którego to działa, jest to, że pierwsze wyrażenie OrderBy(),, sortuje boolwartości: true/ false. falsewynik najpierw przejdź do truewyniku ( ThenBy()wartości null ) i sortuj wartości niezerowe w kolejności alfabetycznej.

Dlatego wolę zrobić coś bardziej czytelnego, takiego jak to:

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

Jeśli SomeStringjest null, zostanie zastąpiony przez"z" a następnie posortowany alfabetycznie.

UWAGA: To nie jest ostateczne rozwiązanie, ponieważ "z"jest pierwsze niż wartości z, takie jak zebra.

UPDATE 9/6/2016 - O komentarzu @jornhd, jest to naprawdę dobre rozwiązanie, ale wciąż jest trochę skomplikowane, więc zalecę zawinięcie go w klasę rozszerzenia, taką jak ta:

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);
    }
}

I po prostu użyj go jak:

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

Mam inną opcję w tej sytuacji. Moja lista to objList i muszę zamówić, ale wartości null muszą być na końcu. moja decyzja:

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

Próbowałem znaleźć rozwiązanie LINQ, ale nie mogłem tego rozwiązać na podstawie odpowiedzi tutaj.

Moja ostateczna odpowiedź brzmiała:

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

moja decyzja:

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

Oto, co wymyśliłem, ponieważ używam metod rozszerzających, a mój element jest ciągiem, więc nie .HasValue:

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

Działa to z obiektami LINQ 2 w pamięci. Nie testowałem tego z EF ani żadnym DB ORM.

Poniżej znajduje się metoda rozszerzenia do sprawdzania wartości null, jeśli chcesz posortować według właściwości podrzędnej 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);
}

I po prostu użyj go jak:

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

Oto inny sposób:

//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.

Zauważ, że r.SUP_APPROVED_IND.Trim() == nulljest traktowany jakotrim(SUP_APPROVED_IND) is null w bazie danych Oracle.

Zobacz to, aby uzyskać szczegółowe informacje: Jak mogę wysyłać zapytania o wartości null w ramach jednostki?

Inna opcja (była przydatna w naszym scenariuszu):

Mamy tabelę użytkowników, przechowującą ADName, LastName, FirstName

• Użytkownicy powinni być alfabetyczni
• Konta bez imienia i nazwiska również na podstawie ich ADName - ale na końcu listy użytkowników
• Fałszywy użytkownik o identyfikatorze „0” („Brak wyboru”) Powinien zawsze znajdować się na górze.

Zmieniliśmy schemat tabeli i dodaliśmy kolumnę „SortIndex”, która definiuje niektóre grupy sortowania. (Pozostawiliśmy odstęp 5, więc możemy wstawić grupy później)

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

Teraz, pod względem zapytania, byłoby to:

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

w wyrażeniach metod:

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

co daje oczekiwany wynik:

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