创建C#LINQ可选连接扩展

我正在尝试为Linq做一个扩展，可以与可选连接一起使用。我想我很接近，但我错过了一些东西。你能认出它吗

public static IQueryable<T> OptionalJoin<T>(this IQueryable<T> source, bool condition, 
        Expression<IEnumerable<T>> TInner, 
        Expression<Func<T, object>> outerKeySelector, 
        Expression<Func<T, object>> innerKeySelector,
        Expression<Func<IQueryable<T>, IEnumerable<T>, object>> resultSelector)
    {
        return condition ? source.Join(TInner, outerKeySelector, innerKeySelector, resultSelector) : source;
    }

public static IQueryable OptionalJoin（此IQueryable源、bool条件、，
表达罐头，
表达式外部选择器，
表达式innerKeySelector，
表达式结果选择器）
{
返回条件？source.Join（TInner、outerKeySelector、innerKeySelector、resultSelector）：source；
}

可选连接实际上没有多大意义。您的返回类型为

IQueryable

，如果要返回原始集合，则该类型是正确的。但是，如果您想将某些内容加入其中，则必须更改返回类型。并且不能有一个方法根据运行时条件返回不同的编译时类型

正因为如此，我认为你想做的是不可能的

如果有两个结果选择器，我能想象这样的事情会起作用的唯一方法是：一个是当

条件

为真时，另一个是当它为假时。它们都将返回相同的类型

另外，您的代码中有几个错误，我试图修复这些错误

public static IQueryable<TResult> OptionalJoin<TSource, TInner, TKey, TResult>(
        this IQueryable<TSource> source,
        bool condition, 
        IQueryable<TInner> innerCollection,
        Expression<Func<T, TKey>> outerKeySelector, 
        Expression<Func<T, TKey>> innerKeySelector,
        Expression<Func<TSource, TInner, TResult>> trueResultSelector,
        Expression<Func<TSource, TResult>> falseResultSelector)
{
    return condition
        ? source.Join(innerCollection, outerKeySelector, innerKeySelector, trueResultSelector)
        : source.Select(falseResultSelector);
}

公共静态IQueryable OptionalJoin(
这是可靠的消息来源，
布尔条件，
IQueryable innerCollection，
表达式外部选择器，
表达式innerKeySelector，
表达式trueResultSelector，
表达式falseResultSelector）
{
返回条件
？source.Join（innerCollection、outerKeySelector、innerKeySelector、trueResultSelector）
：source.Select（FalseSultSelector）；
}

可选连接实际上没有多大意义。您的返回类型为

IQueryable

，如果要返回原始集合，则该类型是正确的。但是，如果您想将某些内容加入其中，则必须更改返回类型。并且不能有一个方法根据运行时条件返回不同的编译时类型

正因为如此，我认为你想做的是不可能的

如果有两个结果选择器，我能想象这样的事情会起作用的唯一方法是：一个是当

条件

为真时，另一个是当它为假时。它们都将返回相同的类型

另外，您的代码中有几个错误，我试图修复这些错误

public static IQueryable<TResult> OptionalJoin<TSource, TInner, TKey, TResult>(
        this IQueryable<TSource> source,
        bool condition, 
        IQueryable<TInner> innerCollection,
        Expression<Func<T, TKey>> outerKeySelector, 
        Expression<Func<T, TKey>> innerKeySelector,
        Expression<Func<TSource, TInner, TResult>> trueResultSelector,
        Expression<Func<TSource, TResult>> falseResultSelector)
{
    return condition
        ? source.Join(innerCollection, outerKeySelector, innerKeySelector, trueResultSelector)
        : source.Select(falseResultSelector);
}

公共静态IQueryable OptionalJoin(
这是可靠的消息来源，
布尔条件，
IQueryable innerCollection，
表达式外部选择器，
表达式innerKeySelector，
表达式trueResultSelector，
表达式falseResultSelector）
{
返回条件
？source.Join（innerCollection、outerKeySelector、innerKeySelector、trueResultSelector）
：source.Select（FalseSultSelector）；
}

我想你需要这样的东西：

public static IQueryable<TResult> OptionalJoin<TOuter, TInner, TKey, TResult>(
    this IQueryable<TOuter> outer,
    bool condition,
    IEnumerable<TInner> inner,
    Expression<Func<TOuter, TKey>> outerKeySelector,
    Expression<Func<TInner, TKey>> innerKeySelector,
    Expression<Func<TOuter, TInner, TResult>> joinResultSelector,
    Expression<Func<TOuter, TResult>> outerResultSelector)
{
    return condition
        ? outer.Join(inner,
            outerKeySelector,
            innerKeySelector,
            joinResultSelector)
        : outer.Select(outerResultSelector);
}

你的代码有一些签名错误

此外，您可以简化我的答案，以便轻松地使用

T

：

public static IQueryable<T> OptionalJoin<T, K>(
    this IQueryable<T> outer,
    bool condition,
    IEnumerable<T> inner,
    Expression<Func<T, K>> outerKeySelector,
    Expression<Func<T, K>> innerKeySelector,
    Expression<Func<T, T, T>> joinResultSelector)
{
    return condition
        ? outer.Join(inner,
            outerKeySelector,
            innerKeySelector,
            joinResultSelector)
        : outer;
}

公共静态IQueryable OptionalJoin(
这是一件易懂的外套，
布尔条件，
我可数的内心世界，
表达式外部选择器，
表达式innerKeySelector，
表达式joinResultSelector）
{
返回条件
？外部。连接（内部，
外部选择器，
选举人，
joinResultSelector）
：外部；
}

---

我希望这有帮助。

我想你需要这样的东西：

public static IQueryable<TResult> OptionalJoin<TOuter, TInner, TKey, TResult>(
    this IQueryable<TOuter> outer,
    bool condition,
    IEnumerable<TInner> inner,
    Expression<Func<TOuter, TKey>> outerKeySelector,
    Expression<Func<TInner, TKey>> innerKeySelector,
    Expression<Func<TOuter, TInner, TResult>> joinResultSelector,
    Expression<Func<TOuter, TResult>> outerResultSelector)
{
    return condition
        ? outer.Join(inner,
            outerKeySelector,
            innerKeySelector,
            joinResultSelector)
        : outer.Select(outerResultSelector);
}

你的代码有一些签名错误

此外，您可以简化我的答案，以便轻松地使用

T

：

public static IQueryable<T> OptionalJoin<T, K>(
    this IQueryable<T> outer,
    bool condition,
    IEnumerable<T> inner,
    Expression<Func<T, K>> outerKeySelector,
    Expression<Func<T, K>> innerKeySelector,
    Expression<Func<T, T, T>> joinResultSelector)
{
    return condition
        ? outer.Join(inner,
            outerKeySelector,
            innerKeySelector,
            joinResultSelector)
        : outer;
}

公共静态IQueryable OptionalJoin(
这是一件易懂的外套，
布尔条件，
我可数的内心世界，
表达式外部选择器，
表达式innerKeySelector，
表达式joinResultSelector）
{
返回条件
？外部。连接（内部，
外部选择器，
选举人，
joinResultSelector）
：外部；
}

我希望这有帮助