How do I do a left outer join with Dynamic Linq?

I am trying to mimick the left outer join here but using dynamic linq extension methods. What i have:

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)));            
}

and开发者_如何学编程:

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)));
}

However where I fall down is with the DefaultIfEmpty within the SelectMany

---

Add void DefaultIfEmpty(); to interface IEnumerableSignatures

Then use

public static object DefaultIfEmpty(this IQueryable source)
{
    if (source == null) throw new ArgumentNullException("source");
        return source.Provider.Execute(
    Expression.Call(
        typeof(Queryable), "DefaultIfEmpty",
        new Type[] { source.ElementType },
        source.Expression));
}

Then you have a call like

var qry = Foo.GroupJoin(Bar, "outer.Id", "inner.Id", "new(outer.Id as Foo, group as Bars)").SelectMany("Bars.DefaultIfEmpty()", "new(outer.Foo as Foo, inner as Bar)");