LINQ最小/最大和最小化迭代

Question

I'm writing a function that takes a series of System.Windows.Point and returns a ValueTuple with the boundary X and Y values for all the points. This is intended to determine the labels of graph axes.

I'm attempting to minimize the number of iterations of the list I perform to just one. After a good deal of googling, I've adapted (read: "copied") an approach like below which I am told will do just that. But I'm not sure how to verify that fact. I'm wondering if someone more familiar with LINQ can

1. Confirm that the below function will indeed only iterate the list once, even though it's calculating 4 different values
2. If so, explain to me how this is. Because it looks to me like the anonymous type being constructed calls "Min" and "Max"on the given list two times for each. Why doesn't that result in 4 iterations?
3. Perhaps even explain how I might have gone about verifying for myself the number of iterations that occurred so that in the future I won't need to ask such questions. I don't see how to do to that.

My LINQ-Fu is not yet strong.

Thanks

    /// <summary>
    /// X and Y axis boundaries in the form of a System.ValueTuple.
    /// </summary>
    public (double MinX, double MaxX, double MinY, double MaxY) 
    GetBounds(List<System.Windows.Point> pts)
    {


        // Calculate the bounds with a LINQ statement.  Is this one iteration or many?

        var a = pts.GroupBy(i => 1).Select(
            pp => new
            {
                MinY = pp.Min(p => p.Y),
                MaxY = pp.Max(p => p.Y),
                MinX = pp.Min(p => p.X),
                MaxX = pp.Max(p => p.X)
            }).FirstOrDefault();


        return a != null ? (a.MinX, a.MaxX, a.MinY, a.MaxY) : (0, 0, 0, 0);
    }

Answer 1

Confirm that the below function will indeed only iterate the list once, even though it's calculating 4 different values

No - the original list will effectively be iterated 4 times. You are creating a "null" grouping that will wrap the original collection so you can "project" the collection to a single object. Since you call 4 linq functions on the "grouping" - the original list will be iterated 4 times. It's functionally equivalent to:

var a = new
        {
            MinY = pts.Min(p => p.Y),
            MaxY = pts.Max(p => p.Y),
            MinX = pts.Min(p => p.X),
            MaxX = pts.Max(p => p.X)
        };

If that is a problem for you , the idiomatic way to find the bounds would be to use a foreach loop and keep track of the min and max x and y coordinates manually. It would be a relatively short function, and would reduce the number of iterations by 75%:

int MinX, MaxX, MinY, MaxY;
MaxX = MaxY = Int.MinValue;
MinX = MinY = Int.MaxValue;
foreach(Point p in pts)
{
    MinX = Math.Min(p.X, MinX);
    MaxX = Math.Max(p.X, MaxX);
    MinY = Math.Min(p.Y, MinY);
    MaxY = Math.Max(p.Y, MaxY);
}
var a = new
    {
        MinY,
        MaxY,
        MinX,
        MaxX
    };

You could use Aggregate to loop find the mins and maxes with a lambda:

var a = pts.Aggregate(
     new {
        MinX = int.MaxValue,
        MaxX = int.MinValue,
        MinY = int.MaxValue,
        MaxY = int.MinValue
    },
    (acc, p) => new {
        MinX = Math.Min(p.X, acc.MinX);
        MaxX = Math.Max(p.X, acc.MaxX);
        MinY = Math.Min(p.Y, acc.MinY);
        MaxY = Math.Max(p.Y, acc.MaxY);
    });

But the aggregator will create an object for each object in the source collection, plus one for the "initial" object. So the list will only be iterated once but multiple temporary objects will be created, increasing the amount of memory that needs to be GC'ed.

Answer 2

The approach you're using there iterates at least five times over the input values (one to "group" them, and once for each min/max) and is an extremely strange way to go about what you're doing.

When you want to take a collection of values and condense them down into one value, the go-to choice is .Aggregate (also known as reduce or fold in other languages).

In your case, you can do that like this. It should iterate over your collection only once:

public static (double minX, double maxX, double minY, double maxY) 
GetBounds(List<Point> pts)
{
    return pts.Aggregate(
        (Int32.MaxValue, Int32.MinValue, Integer.MaxValue, Int32.MinValue),
        (acc, point) => 
        (
            Math.Min(point.X, acc.Item1),
            Math.Max(point.X, acc.Item2),
            Math.Min(point.Y, acc.Item3),
            Math.Max(point.Y, acc.Item4)
        ));
}