Bdtjtk

It really helps to understand the LINQ query syntax and how it is translated to LINQ method calls.

It turns out that

var products = from p in _context.Products

               where p.ProductTypeId == 1

               orderby p.LowestPrice.HasValue descending

               orderby p.LowestPrice descending

               select p;

will be translated by the compiler to

var products = _context.Products

                       .Where(p => p.ProductTypeId == 1)

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

                       .OrderByDescending(p => p.LowestPrice)

                       .Select(p => p);

This is emphatically not what you want. This sorts by Product.LowestPrice.HasValue in descending order and then re-sorts the entire collection by Product.LowestPrice in descending order.

What you want is

var products = _context.Products

                       .Where(p => p.ProductTypeId == 1)

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

                       .ThenBy(p => p.LowestPrice)

                       .Select(p => p);

which you can obtain using the query syntax by

var products = from p in _context.Products

               where p.ProductTypeId == 1

               orderby p.LowestPrice.HasValue descending,

                       p.LowestPrice

               select p;

For details of the translations from query syntax to method calls, see the language specification. Seriously. Read it.

I have another option in this situation.
My list is objList, and I have to order but nulls must be in the end.
my decision:

var newList = objList.Where(m=>m.Column != null)

                     .OrderBy(m => m.Column)

                     .Concat(objList.where(m=>m.Column == null));

The solution for string values is really weird:

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

The only reason that works is because the first expression, OrderBy(), sort bool values: true/false. false result go first follow by the true result (nullables) and ThenBy() sort the non-null values alphabetically.

So, I prefer doing something more readable such as this:

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

If SomeString is null, it will be replaced by "z" and then sort everything alphabetically.

NOTE: This is not an ultimate solution since "z" goes first than z-values like zebra.

UPDATE 9/6/2016 - About @jornhd comment, it is really a good solution, but it still a little complex, so I will recommend to wrap it in a Extension class, such as this:

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

    }

}

And simple use it like:

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

my decision:

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

This is what I came up with because I am using extension methods and also my item is a string, thus no .HasValue:

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

This works with LINQ 2 objects in memory. I did not test it with EF or any DB ORM.

I was trying to find a LINQ solution to this but couldn't work it out from the answers here.

My final answer was:

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

Below is extension method to check for null if you want to sort on child property of a 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);

}

And simple use it like:

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