Usando LINQ Aggregate efetivamente

Tive alguns problemas para descobrir como usar o agregado do LINQ,
um dos motivos é que não encontrei boas referências na rede.

O problema foi resolvido; calcular a união entre um número arbitrário de retângulos

Isso foi algo que fiz no trabalho recentemente, quando trabalhava em um programa de análise de imagens.

A seguir, mostrarei 3 partes de código fazendo exatamente isso de 3 maneiras diferentes

• Um pedaço de código usando um loop
• Um pedaço de código usando uma função recursiva (principalmente para se divertir)
• E, por último, uma expressão LINQ usando agregado

Acho que os exemplos ajudarão a iluminar como funciona a expressão LINQ.

Usando um loop

static Rectangle GetRectUnionLoop(params Rectangle[] rectangles)
{
    if (rectangles.Length == 0)
        return Rectangle.Empty;

    Rectangle boundingBox = rectangles[0];
    foreach (var rectangle in rectangles) 
    {
        boundingBox = Rectangle.Union(boundingBox, rectangle);

    }
    return boundingBox;
}

Usando uma função recursiva

static Rectangle GetRectUnionRecursive(params Rectangle[] rectangles)
{
    return (rectangles.Length > 1)
        ? Rectangle.Union(rectangles[0],
            GetRectUnionRecursive(rectangles.Skip(1).ToArray()))
        : (rectangles.Length == 1)
            ? rectangles[0]
            : Rectangle.Empty;
}

Usando LINQ

static Rectangle GetRectUnionLINQ(params Rectangle[] rectangles)
{
    return (rectangles.Length == 0)
        ? Rectangle.Empty
        : rectangles
            .Aggregate(rectangles[0], (acc, rect) => Rectangle.Union(acc, rect));
}