Call Select with own type and expression

I want to done follow:

var xpQuery = new XPQuery<Contact>(session);
var select = xpQuery.Select(s => s.FullName);
var distinct = select.Distinct();
var list = distinct.ToList();

XPQuery is IQueryable<T> so I want to request the distinct list of specified property values, but Contact and FullName should be variables here.
So I'm doing follow:

var propertyName = "FullName";
var type = typeof(Contact);
var xpQueryType = typeof(XPQuery<>).MakeGenericType(type);
var xpQueryInstance = Activator.CreateInstance(xpQueryType, new object[] { session });

var param = Expression.Parameter(type);
var genericType = Expression.GetFuncType(type, typeof(string));
var condition = Expression.Lambda(genericType, Expression.Property(param, propertyName), param);

var selectMethod = typeof(Queryable).GetMethod(
								nameof(Queryable.Select),
								new Type[]
								{
									typeof(IQueryable<>).MakeGenericType(type),
									typeof(Expression<>).MakeGenericType(genericType)
								});
var query = selectMethod.Invoke(null, new[] { xpQueryInstance, condition }) as IQueryable<string>;
var r = query.Distinct().ToList();

But I cannot correctly get select method to Invoke it. It returns null or throw different exceptions (ambigiuos match and so on).
How can I achieve this?

Actully you need only dynamic Select, other methods can be just generic

var list = xpQuery.SelectDistinct("FullName").ToList();

And methods realisation:

public static class QueryableExtensions
{
    public static IQueryable<TValue> Select<TValue>(this IQueryable query, string propName)
    {
        var entityParam = Expression.Parameter(query.ElementType, "e");
        Expression propExpression = Expression.Property(entityParam, propName);

        if (propExpression.Type != typeof(TValue))
            propExpression  = Expression.Convert(propExpression, typeof(TValue));

        var selector = Expression.Lambda(propExpression, entityParam);

        var queryExpression = query.Expression;

        queryExpression = Expression.Call(typeof(Queryable), nameof(Queryable.Select),
            new[] { query.ElementType, typeof(TValue) }, queryExpression, Expression.Quote(selector));

        return query.Provider.CreateQuery<TValue>(queryExpression);
    }

    public static IQueryable<TValue> SelectDistinct<TValue>(this IQueryable query, string propName)
    {
        return query.Select<TValue>(propName).Distinct();
    }		
    
    public static IQueryable<string> SelectDistinct(this IQueryable query, string propName)
    {
        return query.SelectDistinct<string>(propName);
    }
};