leads = leads.OrderBy(lead => lead.Person.FirstName);

var orderBypath = "Person.FirstName";

leads = leads.OrderBy(orderBypath);

public static class EntityQueryExtensions
{
    public static IEntityQuery<TSource> Order<TSource>(this IQueryable<TSource> source, string property, ListSortDirection listSortDirection)
    {
        if (listSortDirection == ListSortDirection.Ascending)
        {
            return ApplyOrder(source, property, "OrderBy");
        }
        
        // Descending            
        return ApplyOrder(source, property, "OrderByDescending");                       
    }

    public static IEntityQuery<TSource> OrderBy<TSource>(this IQueryable<TSource> source, string property)
    {
        return ApplyOrder(source, property, "OrderBy");
    }

    public static IEntityQuery<TSource> OrderByDescending<TSource>(this IQueryable<TSource> source, string property)
    {
        return ApplyOrder(source, property, "OrderByDescending");
    }

    public static IEntityQuery<TSource> ThenBy<TSource>(this IQueryable<TSource> source, string property)
    {
        return ApplyOrder(source, property, "ThenBy");
    }

    public static IEntityQuery<TSource> ThenByDescending<TSource>(this IQueryable<TSource> source, string property)
    {
        return ApplyOrder(source, property, "ThenByDescending");
    }       

    public static IEntityQuery<T> ApplyOrder<T>(IQueryable<T> source, string property, string methodName)
    {
        ParameterExpression arg = Expression.Parameter(typeof(T), property);
        Expression expr = arg;

        foreach (string prop in property.Split('.'))
        {
            // use reflection (not ComponentModel) to mirror LINQ
            expr = Expression.PropertyOrField(expr, prop);
        }

        Type delegateType = typeof(Func<,>).MakeGenericType(typeof(T), expr.Type);
        LambdaExpression lambda = Expression.Lambda(delegateType, expr, arg);

        return (IEntityQuery<T>)

        typeof(Queryable).GetMethods().Single(
            method => method.Name == methodName &&
                      method.IsGenericMethodDefinition &&
                      method.GetGenericArguments().Length == 2 &&
                      method.GetParameters().Length == 2).MakeGenericMethod(typeof(T), expr.Type)
                      .Invoke(null, new object[] { source, lambda });
    }    
}

public static class EntityQueryExtensions
{

// Transform IEntityQuery<TSource> into a count query
public static IEntityQuery<int> AsQueryCount<TSource>(this IEntityQuery<TSource> source)
{
    return (EntityQuery<int>) source.GroupBy(g => 1).Select(c => c.Count());
}

// Transform IEntityQuery into a count query
public static IEntityQuery<int> AsQueryCount(this IEntityQuery source)
{
    // Can't GroupBy/Select an untyped IEntityQuery
    // Can't cast source IEntityQuery to IEntityQuery<Entity> or 
    // even IEntityQuery<object>
    //
    // So we're left with using reflection to get the queryable type
    // and calling the typed version of the AsQueryCount static extension 
    // method.
    //
    // Note: If someone can come up with a solution to do this without
    // reflection let me know!
    MethodInfo methodInfo;
    ParameterInfo[] parameters;

    Type entityType = source.QueryableType;

    ReflectionHelpers.FindStaticMethod(typeof (EntityQueryExtensions), "AsQueryCount", new[] {entityType},
                                       new[] {entityType}, out methodInfo, out parameters);

    object result = methodInfo.Invoke(null, new object[] {source});

    return result as IEntityQuery<int>;
}

}





public static class ReflectionHelpers
{
    public static void FindStaticMethod(Type type, string methodName, Type[] typeArguments, Type[] parameterTypes,
                                        out MethodInfo methodInfo,
                                        out ParameterInfo[] parameters)
    {
        methodInfo = null;
        parameters = null;

        if (null == parameterTypes)
        {
            methodInfo = type.GetMethod(methodName, BindingFlags.Public | BindingFlags.Instance);
            methodInfo = methodInfo.MakeGenericMethod(typeArguments);
            parameters = methodInfo.GetParameters();
        }
        else
        {
            // Method is probably overloaded. As far as i know there's no other way to get the MethodInfo instance, we have to
            // search for it in all the type methods
            MethodInfo[] methods = type.GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static);
            foreach (MethodInfo method in methods)
            {
                if (method.Name == methodName)
                {
                    // create the generic method
                    MethodInfo genericMethod = method.MakeGenericMethod(typeArguments);
                    parameters = genericMethod.GetParameters();

                    // compare the method parameters
                    if (parameters.Length == parameterTypes.Length)
                    {
                        for (int i = 0; i < parameters.Length; i++)
                        {
                            if (parameters.ParameterType != parameterTypes)
                            {
                                continue; // this is not the method we'r looking for
                            }
                        }

                        // if we'r here, we got the rigth method
                        methodInfo = genericMethod;
                        break;
                    }
                }
            }

            if (null == methodInfo)
            {
                throw new InvalidOperationException("Method not found");
            }
        }
    }
}