Keep NULL rows last on Dynamic Linq Order By

I am using this snippet below for Ordering my Linq queries dynamically and works great. I am not great at reflection or complex linq queries but I need a way that when ascending order is used, that NULL values are last and vice versa.

So if my property name was an integer and the column values were 1, 3, 5, all NULL rows would be at the end, not at the beginning by default. What can I add to this expression to make that happen?

private class OrderByInfo
        {
            public string PropertyName { get; set; }
            public SortDirection Direction { get; set; }
            public bool Initial { get; set; }
        }

    private static IOrderedQueryable<T> ApplyOrderBy<T>(IQueryable<T> collection, OrderByInfo orderByInfo)
            {
                string[] props = orderByInfo.PropertyName.Split('.');
                Type type = typeof(T);

                ParameterExpression arg = Expression.Parameter(type, "x");
                Expression expr = arg;
                foreach (string prop in props)
                {
                    // use reflection (not ComponentModel) to mirror LINQ
                    PropertyInfo pi = type.GetProperty(prop, BindingFlags.IgnoreCase | BindingFlags.Public | BindingFlags.Instance);
                    expr = Expression.Property(expr, pi);
                    type = pi.PropertyType;
                }
                Type delegateType = typeof(Func<,>).MakeGenericType(typeof(T), type);
                LambdaExpression lambda = Expression.Lambda(delegateType, expr, arg);
                string methodName = String.Empty;

                if (!orderByInfo.Initial && collection is IOrderedQueryable<T>)
                {
                    if (orderByInfo.Direction == SortDirection.Ascending)
                        methodName = "ThenBy";
                    else
                        methodName = "ThenByDescending";
                }
                else
                {
                    if (orderByInfo.Direction == SortDirection.Ascending)
                        methodName = "OrderBy";
                    else
                        methodName = "OrderByDescending";
                }

                //TODO: apply caching to the generic methodsinfos?
                return (IOrderedQueryable<T>)typeof(Queryable).GetMethods().Single(
                    method => method.Name == methodName
                            && method.IsGenericMethodDefinition
                            && method.GetGenericArguments().Length == 2
                            && method.GetParameters().Length == 2)
                    .MakeGenericMethod(typeof(T), type)
                    .Invoke(null, new object[] { collection, lambda });

            }