Question: Does the .NET BCL have an immutable Set type? I'm programming in a functional dialect of C# and would like to do something like

```
new Set.UnionWith(A).UnionWith(B).UnionWith(C)

```

But the best I can find is `HashSet.UnionWith`, which would require the following sequence of calls:

```
HashSet composite = new HashSet();
composite.UnionWith(A);
composite.UnionWith(B);
composite.UnionWith(C);

```

This use is highly referentially opaque, making it hard to optimize and understand. Is there a better way to do this without writing a custom functional set type?

Answer: 
**Update**

This answer was written some time ago, and since then a set of immutable collections have been introduced in the [`System.Collections.Immutable`](https://msdn.microsoft.com/en-us/library/mt452182(v=vs.111).aspx) namespace.

**Original answer**

You can roll out your own method for this:

```
public static class HashSetExtensions {
  public static HashSet<T> Union<T>(this HashSet<T> self, HashSet<T> other) { 
    var set = new HashSet<T>(self); // don't change the original set
    set.UnionWith(other);
    return set;
  }
}

```

Use it like this:

```
var composite = A.Union(B).Union(C);

```

You can also use [LINQ's `Union`](http://msdn.microsoft.com/en-us/library/bb397728.aspx), but to get a set, you'll need to pass the result to the `HashSet` constructor:

```
var composite = new HashSet<string>(A.Union(B).Union(C));

```

But, `HashSet` itself is mutable. You could try to use [F#'s immutable set](http://msdn.microsoft.com/en-us/library/ee353619.aspx).

Also, as mentioned in the comments by [ErikE](https://stackoverflow.com/users/57611/erike), using `Concat` yields the same result and probably performs better:

```
var composite = new HashSet<string>(A.Concat(B).Concat(C));

```
There is a [ReadOnlyCollection](http://msdn.microsoft.com/en-us/library/ms132474.aspx), but it's not a hash table. LINQ adds the [Union](http://msdn.microsoft.com/en-us/library/bb341731.aspx) method as an extension.