C# 使用聚合连接ISet

我试图在多个ISet上使用

Concat（）

，以生成一个更大的ISet。因此，我尝试了以下代码：

public class Foo
{
    private Dictionary<Bii, ISet<Faa>> items = new Dictionary<Bii, ISet<Faa>>();

    public ISet<Faa> GetCompleteList()
    {
        ISet<Faa> result = items.Values.Aggregate((x,y) => x.Concat(y));
        return result;
    }
}

公共类Foo
{
私有字典项=新字典（）；
公共ISet GetCompleteList（）
{
ISet结果=items.Values.Aggregate（（x，y）=>x.Concat（y））；
返回结果；
}
}

问题是，这会导致编译器错误：

无法将类型

System.Collections.Generic.IEnumerable

隐式转换为

System.Collections.Generic.ISet

。存在显式转换（是否缺少强制转换？）

还有第二个错误：

无法将lambda表达式转换为委托类型

System.Func

，因为块中的某些返回类型不能隐式转换为委托返回类型

我还试着使用一个类似于：

ISet<Faa> result = items.Values.Aggregate((x,y) => (ISet<Faa>)x.Concat(y));

ISet结果=items.Values.Aggregate（（x，y）=>（ISet）x.Concat（y））；

但这会给我一个

无效的castedexception

，因为它应该是

ConcatIterator

或某种类型的

---

如何才能很好地将所有ISet加入到一个ISet中？

您可以尝试以下方法：

ISet<Faa> result = items.Values.Aggregate(new HashSet<Faa>(),
                                          (a, x) => { a.UnionWith(x)); return a; });

public ISet<Faa> GetCompleteList()
{
    ISet<Faa> result = new HashSet<Faa>(items.Values.SelectMany(x => x));
    return result;
}

ISet结果=items.Values.Aggregate（新HashSet（），
（a，x）=>{a.UnionWith（x））；返回a；}）；

您可以尝试以下方法：

ISet<Faa> result = items.Values.Aggregate(new HashSet<Faa>(),
                                          (a, x) => { a.UnionWith(x)); return a; });

public ISet<Faa> GetCompleteList()
{
    ISet<Faa> result = new HashSet<Faa>(items.Values.SelectMany(x => x));
    return result;
}

ISet结果=items.Values.Aggregate（新HashSet（），
（a，x）=>{a.UnionWith（x））；返回a；}）；

LINQ函数，如

Concat

返回一个

IEnumerable

。此调用后，不再有

ISet

。但您可以重建一个：

ISet<Faa> result = new HashSet<Faa>(items.Values.Aggregate((x,y) => x.Concat(y)));

---

诸如

Concat

之类的LINQ函数返回一个

IEnumerable

。此调用后，不再有

ISet

。但您可以重建一个：

ISet<Faa> result = new HashSet<Faa>(items.Values.Aggregate((x,y) => x.Concat(y)));

---

如果不想更改任何传入集，可以执行以下操作：

ISet<Faa> result = items.Values.Aggregate(new HashSet<Faa>(),
                                          (a, x) => { a.UnionWith(x)); return a; });

public ISet<Faa> GetCompleteList()
{
    ISet<Faa> result = new HashSet<Faa>(items.Values.SelectMany(x => x));
    return result;
}

public ISet GetCompleteList（）
{
ISet结果=新哈希集（items.Values.SelectMany（x=>x））；
返回结果；
}

---

如果您不想引入具体类型，可以将其附加到第一个传入集，但您可能会更改小于stellar的类型。

如果您不想更改任何传入集，可以执行以下操作：

ISet<Faa> result = items.Values.Aggregate(new HashSet<Faa>(),
                                          (a, x) => { a.UnionWith(x)); return a; });

public ISet<Faa> GetCompleteList()
{
    ISet<Faa> result = new HashSet<Faa>(items.Values.SelectMany(x => x));
    return result;
}

public ISet GetCompleteList（）
{
ISet结果=新哈希集（items.Values.SelectMany（x=>x））；
返回结果；
}

---

如果你不想引入一个具体的类型，你可以附加到第一个传入的集合中，但是你会修改那些不太stellar的集合。

虽然我认为这是更好的。你能告诉我为什么吗？更快吗？@Marnix：我认为

SelectMany

版本更简单，可读性更强。我希望性能几乎完全相同（不管怎样，

HashSet

构造函数可能在幕后使用

UnionWith

或等效的方法）。不过，你必须确定自己的基准。虽然我认为这更可取。你能告诉我为什么吗？更快吗？@Marnix：我认为

SelectMany

版本更简单，可读性更强。我希望性能几乎完全相同（不管怎样，

HashSet

构造函数可能在幕后使用

UnionWith

或等效的方法）。不过，您必须进行基准测试才能确定。