Why does the IQueyable version of a LINQ Extension method take more time than its IEnumerable counterpart?

I have this method that I created a long time ago:

    public static IEnumerable<TSource> In<TSource, TMember>(this IEnumerable<TSource> source,
        Func<TSource, TMember> identifier, params TMember[] values) =>
 source.Where(m => values.Contains(identifier(m)));

And after I read about expression trees, I went to implement the IQueryable version of this method, and this is the result:

public static IQueryable<TSource> In<TSource, TMember>(this IQueryable<TSource> source,
   Expression<Func<TSource, TMember>> identifier, params TMember[] values)
        var memberName = (identifier.Body as MemberExpression).Member.Name;
        var param = Expression.Parameter(typeof(TSource), "m");
        var listOfValues = Expression.Constant(values.ToList());
        var member = Expression.Property(param, memberName);

        MethodInfo method = typeof(List<TMember>).GetMethod("Contains");
        Expression call = Expression.Call(listOfValues, method, member);

        var theExpression = Expression.Lambda<Func<TSource, bool>>(call, param);

        return source.Where(theExpression);

To test it, I created a StopWatch, to compare the ElapsedMilliseconds between the two versions, I was expecting that the IQueryable version will take less time:

    var lst = new List<MyClass>();
    for (int i = 0; i < 9_999_999; i++)
        lst.Add(new MyClass { RowNo = i, Value = i.ToString() });
    Stopwatch timer = new Stopwatch();
    var enRes = lst.In(x => x.RowNo, lst.Where(z => z.RowNo > 5).Select(x => x.RowNo).ToArray());
    Console.WriteLine("Enumerable version: " + timer.ElapsedMilliseconds);
    var res = lst.AsQueryable().In(x => x.RowNo, lst.Where(z => z.RowNo > 5).Select(x => x.RowNo).ToArray());
    Console.WriteLine("Queryable version: " + timer.ElapsedMilliseconds);

the ElapsedMilliseconds for the IQueryable version is always greater than the IEnumerable version!

to see how LINQ methods behave, I tested this on Where and FirstOrDefault:

var enRes = lst.Where(x => x.RowNo < 9_999_999);
var qRes = qrb.Where(x => x.RowNo < 9_999_999);

2 tests from 4 gave 0 for both versions while two tests gave 1 ms for the IQueyable, and 0 ms for the IEnumerable version
the difference was clearer with FirstOrDefault which the IQueryable version was always greater.

I know that these difference are almost negligible that doesn't affect performance, but the point is that these differences shed a light on the behavior of IEnumerable over IQueryable , that for me not 100% clear.

To sum up: Isn't the IQueryable take less time than its counterpart IEnumerable version?

Also I'd like to know if my implementation of IQueryable.In method is right