A korábban tárgyalt Join felfogható egyfajta halmazműveletként és a Distinct is. Azonban ha szükségünk van két IEnumerable<T> kollekciónak az uniójára vagy metszetére, akkor erre is lehetőséget biztosít a LINQ, méghozzá a Union és Intersect metódusokkal.
Ezek megfelelő használatához elengedhetetlen, hogy a típus rendelkezzen egy megfelelően felülírt Equals metódussal, vagy szolgáltatnunk kell egy IEqualityComparer<T> interface-t megvalósító típuspéldányt a metódus második argumentumának.
int[] ints1 = { 5, 3, 9, 7, 5, 9, 3, 7 };
int[] ints2 = { 8, 3, 6, 4, 4, 9, 1, 0 };
//5,3,9,7,8,6,4,1,0
IEnumerable<int> union = ints1.Union(ints2);
//3,9
IEnumerable<int> intersect = ints1.Intersect(ints2);
//5,7
IEnumerable<int> except = ints1.Except(ints2);
.NET 6 óta lehetőségünk van a IntersectBy és a UnionBy műveletek használatára is. Ezek kifejezetten hasznosak összetett típusok alapján, mivel egy lamda kifejezéssel mondhatjuk meg, hogy mi alapján szeretnénk uniót vagy metszetet képezni.
struct Pelda
{
public int X { get; set; }
public int Y { get; set; }
}
var elemek = new List<Pelda>
{
new Pelda { X = 10, Y = 20 },
new Pelda { X = 11, Y = 23 },
};
var elemek2 = new List<Pelda>
{
new Pelda { X = 10, Y = 12 },
new Pelda { X = 44, Y = 20 },
};
// {10, 20}, {11, 23}, {44, 20}
var union = elemek.UnionBy(elemek2, x => x.X);
//szintén helyes:
var union2 = elemek.UnionBy(elemek2, x => x.X > 5);
// {10, 20}
var intersect = elemek.IntersectBy(elemek2.Select(x => x.X), x => x.X);
// {11, 23}
var except = elemek.ExceptBy(elemek2.Select(x => x.X), x => x.X);
Az IntersectBy és a ExceptBy metódusok definíciói eltérnek a UnionBy által használttól. Ennek okai abban keresendők, hogy az unió csak azonos típusok esetén működik, míg a metszet és különbség két különböző típus alapján is működhet. Ezért kell a IntersectBy és a ExceptBy esetén az első kollekció elemeinek megfeleltethetőnek kell lenniük a második kollekcó elemeinek.
Összefűzés
Szimpla összefűzésre a Concat használható. Ez nem szűri ki az ismétlődő elemeket.
int[] a = { 1, 2, 3};
int[] b = { 4, 5, 6 };
// 1, 2, 3, 4, 5, 6
var result = a.Concat(b);
De mi van akkor, ha olyan módon szeretnénk összefűzni elemeket, hogy 1 elemet szeretnénk venni az első kollekcióból, majd egy elemet a második kollekcióból? Erre a Zip művelet képes, ami ValueTuple formában adja vissza az elemeket.
//(1, 4),(2, 5),(3, 6)
var result = a.Zip(b);
A Zip művelet .NET 6 óta képes három kollekció összefűzésére is. Opcionálisan a Zip kiegészíthetó egy szelekciós lambdával is:
//4,10,18
var result = a.Zip(b, (i, j) => i*j);
Szeletelés
A .NET 6 bevezette a Chunk műveletet, amivel egy Enumerable<T> típust fel tudunk szeletelni több, megadott maximum elemszámú T típusú tömbre.
int[] a = { 1, 2, 3, 4};
// [1, 2] és [3, 4] elemű tömböket produkál.
IEnumerable<int[]> result = a.Chunk(2);
A Chunk műveletnek akkor van értelme, ha nagymennyiségű adatot kell feldolgozni és bizonyos műveletek esetén Span<T> típust szeretnénk alkalmazni StackOverflowException veszélye nélkül.