¿Cómo hago una unión externa izquierda con Dynamic Linq?

Estoy tratando de imitar la combinación externa izquierdaaqu pero usando métodos dinámicos de extensión linq. Lo que tengo

public static IQueryable SelectMany(this IQueryable source, string selector, 
    string resultsSelector, params object[] values)
{
    if (source == null) throw new ArgumentNullException("source");
    if (selector == null) throw new ArgumentNullException("selector");

    // Parse the lambda 
    LambdaExpression lambda = DynamicExpression.ParseLambda(
        source.ElementType, null, selector, values);

    // Fix lambda by recreating to be of correct Func<> type in case  
    // the expression parsed to something other than IEnumerable<T>. 
    // For instance, a expression evaluating to List<T> would result  
    // in a lambda of type Func<T, List<T>> when we need one of type 
    // an Func<T, IEnumerable<T> in order to call SelectMany(). 
    Type inputType = source.Expression.Type.GetGenericArguments()[0];
    Type resultType = lambda.Body.Type.GetGenericArguments()[0];
    Type enumerableType = typeof(IEnumerable<>).MakeGenericType(resultType);
    Type delegateType = typeof(Func<,>).MakeGenericType(inputType, 
        enumerableType);
    lambda = Expression.Lambda(delegateType, lambda.Body, lambda.Parameters);

    ParameterExpression[] parameters = new ParameterExpression[] { 
        Expression.Parameter(source.ElementType, "outer"), 
        Expression.Parameter(resultType, "inner") 
    };

    LambdaExpression resultsSelectorLambda = DynamicExpression.ParseLambda(
        parameters, null, resultsSelector, values);

    // Create the new query 
    return source.Provider.CreateQuery(Expression.Call(typeof(Queryable), 
        "SelectMany", new Type[] { 
            source.ElementType, 
            resultType, 
            resultsSelectorLambda.Body.Type 
        }, source.Expression, Expression.Quote(lambda), 
        Expression.Quote(resultsSelectorLambda)));            
}

y

public static IQueryable GroupJoin(this IQueryable outer, IEnumerable inner,
    string outerKeySelector, string innerKeySelector, string resultSelector, 
    params object[] values)
{
    Type innerElementType = inner.AsQueryable().ElementType;

    var outerParameter = Expression.Parameter(outer.ElementType, "outer");
    var innerParameter = Expression.Parameter(innerElementType, "inner");
    var groupParameter = Expression.Parameter(typeof(IEnumerable<>)
        .MakeGenericType(innerElementType), "group");

    var outerLambda = DynamicExpression.ParseLambda(new[] { outerParameter },
        null, outerKeySelector, values);
    var innerLambda = DynamicExpression.ParseLambda(new[] { innerParameter },
        outerLambda.Body.Type, innerKeySelector, values);
    var resultLambda = DynamicExpression.ParseLambda(new[] { 
        outerParameter, groupParameter }, null, resultSelector, values);

    return outer.Provider.CreateQuery(Expression.Call(typeof(Queryable), 
        "GroupJoin", new[] { outer.ElementType, innerElementType, 
        outerLambda.Body.Type, resultLambda.Body.Type },
        outer.Expression, Expression.Constant(inner),
        Expression.Quote(outerLambda), Expression.Quote(innerLambda),
        Expression.Quote(resultLambda)));
}

Sin embargo, donde me caigo es con elDefaultIfEmpty dentro deSelectMany