Question

I have a list of prices ordered by date. I need to select all monotonously decreasing values. The following code works:

    public static List<DataPoint> SelectDecreasingValues(List<DataPoint> dataPoints)
    {
        var ret = new List<DataPoint>(dataPoints.Count);
        var previousPrice = dataPoints[0].Price;
        for (int i = 0; i < dataPoints.Count; i++)
        {
            if (dataPoints[i].Price <= previousPrice)
            {
                ret.Add(dataPoints[i]);
                previousPrice = dataPoints[i].Price;
            }
        }
        return ret;
    }

However, is there a shorter/cleaner way to accomplish it with Linq?

Answer 1

This code is equivalent:

previousPrice = dataPoints[0].Price;
var ret = dataPoints.Where(x => {
                                   if(x.Price <= previousPrice)
                                   { previousPrice = x.Price; return true;}
                                   return false; 
                                }).ToList();

However, if you don’t need to have a list, go with plain enumerables and drop the ToList at the end. That way you can make use of the deferred execution feature built into LINQ.

---

The following code is also equivalent:

DataPoint previous = dataPoints.FirstOrDefault();
var ret = dataPoints.Where(x => x.Price <= previous.Price)
                    .Select(x => previous = x).ToList();

This works because of the deferred execution in LINQ. For each item in dataPoints it will first execute the Where part and then the Select part and only then will it move to the second item in dataPoints.

You need to decide which version you want to use. The second one is not as intention revealing as the first one, because you need to know about the internal workings of LINQ.