C# 在自定义条件下联接两个集合

我有两个集合，

IEnumerable as

和

IEnumerable bs

我还有一个谓词

Func谓词

我想把

作为

和

bs

连接在一起，得到一个等价于

I可数连接

的东西，这样对于

连接

中的每个元素

组

，对于

组

中的每个元素

b

，

谓词（group.key，b）

要获得这样的分组，通常有

GroupBy

扩展方法，但它不能基于自定义谓词进行操作

我考虑了两种方法，一种是使用嵌套循环构建集合，另一种是使用

Aggregate

执行相同的操作。两个看起来都很难看。有更好的方法吗

在这种特殊情况下，对于

bs

中的每个元素

b

，在

as

中正好有一个

A

谓词，我不介意依赖该属性，如果这有助于更好的解决方案

---

就我所见，在一般情况下，它不能产生比

O（n*m）

更好的渐近运行时复杂性，其中

n

是

As

的长度，

m

是

bs

的长度。我同意。

考虑到你有

IEnumerable<A> aEnumerable;
IEnumerable<B> bEnumerable;

IEnumerable-aEnumerable；
i可数的b可数的；

及以下限制：

在这个特殊的情况下，对于bs中的每个元素b，as中正好有一个A，谓词用于该元素

您可以执行以下操作：

IEnumerable<IGrouping<A, B>> grouping = bEnumerable
    .GroupBy(b => aEnumerable.Single(a => func(a, b)));

IEnumerable分组=bEnumerable
.GroupBy（b=>aEnumerable.Single（a=>func（a，b）））；

另一个让人想到并且看起来更方便的选择是一本简单的字典：

IEnumerable<A> aEnumerable;
IEnumerable<B> bEnumerable;

Dictionary<A, B[]> dict = aEnumerable
    .ToDictionary(a => a, 
                  a => bEnumerable.Where(b => func(a, b)).ToArray());

IEnumerable-aEnumerable；
i可数的b可数的；
字典dict=aEnumerable
.ToDictionary（a=>a，
a=>bEnumerable.Where（b=>func（a，b））.ToArray（）；

---

对于该词典中的每个键A，都会有包含该谓词的项

考虑到你

IEnumerable<A> aEnumerable;
IEnumerable<B> bEnumerable;

IEnumerable-aEnumerable；
i可数的b可数的；

及以下限制：

在这个特殊的情况下，对于bs中的每个元素b，as中正好有一个A，谓词用于该元素

您可以执行以下操作：

IEnumerable<IGrouping<A, B>> grouping = bEnumerable
    .GroupBy(b => aEnumerable.Single(a => func(a, b)));

IEnumerable分组=bEnumerable
.GroupBy（b=>aEnumerable.Single（a=>func（a，b）））；

另一个让人想到并且看起来更方便的选择是一本简单的字典：

IEnumerable<A> aEnumerable;
IEnumerable<B> bEnumerable;

Dictionary<A, B[]> dict = aEnumerable
    .ToDictionary(a => a, 
                  a => bEnumerable.Where(b => func(a, b)).ToArray());

IEnumerable-aEnumerable；
i可数的b可数的；
字典dict=aEnumerable
.ToDictionary（a=>a，
a=>bEnumerable.Where（b=>func（a，b））.ToArray（）；

---

对于该词典中的每个键A，都会有包含该谓词的项

你能更好地解释group by predicate是如何工作的吗？@GiladGreen关于这个问题的范围，假设我从某个地方得到它，而我对它一无所知。我的意思是，这个谓词的签名是什么？Func？@GiladGreen这是

Func谓词

这听起来像是嵌套循环，即类似于

As.Select（a=>new{Key=a，Elements=Bs.Where（b=>predicate（a，b））}），导致O（N*M）时间复杂度。我看不出仅仅基于谓词是如何优化的。你能更好地解释group by predicate是如何工作的吗？@GiladGreen关于这个问题的范围，假设我从某个地方得到它，而我对此一无所知。我的意思是，谓词的签名是什么？Func？@GiladGreen这是
Func谓词
这听起来像是嵌套循环，即类似于
As.Select（a=>new{Key=a，Elements=Bs.Where（b=>predicate（a，b））}），导致O（N*M）时间复杂度。我不认为仅仅基于谓词就可以优化它。