Question

I have a List of MyObject as below:

public MyObject(reqVal, reqTime)
{
    _value = reqVal;
    _time = reqTime;

}

public double Value
{
     get {return _value;}
}

public DateTime Time
{
     get {return _time;}
}

var myList = new List<MyObject>();
myList.Add(new MyObject(100, new DateTime(2012, 03, 01, 10, 0, 0));
myList.Add(new MyObject(50, new DateTime(2012, 03, 01, 10, 3, 0));
myList.Add(new MyObject(10, new DateTime(2012, 03, 01, 10, 6, 0));
myList.Add(new MyObject(230, new DateTime(2012, 03, 01, 10, 9, 0));
....

As you can see this list holds the values for a whole day and each value is generated every 3 min. How can I find the following based on the chunk of 15 min:

1. maxVal
2. minVal
3. openVal
4. closeVal

so if the 1st datetime value is 2012/03/01 10:00
I need to find the 4 above between 10:00 and 10:15 then next set of 4 between 10:15 and 10:30 and so on …

so all these values will be calculated based on their time range
for example 2nd maxVal or openVal will be the maxVal and openVal between 10:15 and 10:30

any help would be much appreciated,

Thanks.

Answer 1

You could try to group the list by which 15-minute interval it’s in. Here’s a somewhat quick-and-dirty example (I’ve changed some of your values to present better test cases, and TimeData is the same as MyObject):

List<TimeData> myList = new List<TimeData>();
myList.Add(new TimeData(100, new DateTime(2012, 03, 01, 10, 0, 0)));
myList.Add(new TimeData(50, new DateTime(2012, 03, 01, 10, 3, 0)));
myList.Add(new TimeData(10, new DateTime(2012, 03, 01, 10, 35, 0)));
myList.Add(new TimeData(230, new DateTime(2012, 03, 01, 10, 46, 0)));

var grouped = myList.GroupBy(t => t.Time.Day.ToString()
       + "_" + t.Time.Month.ToString()
       + "_" + t.Time.Year.ToString()
       + "_" + t.Time.Hour.ToString() + "_"
       + (t.Time.Minute / 15).ToString())
   .Select(gr => new { TimeSlot = gr.Key, Max = gr.Max(item => item.Value),
         Min = gr.Min(item => item.Value),
         Open = gr.OrderBy(g => g.Time).First().Value,
         Close = gr.OrderBy(g => g.Time).Last().Value });

So what is happening is:

• Group by the day + month + year + hour + (minute / 15).
  • The (t.Time.Minute / 15) is integer division, which means that any minute value from 0 to 14 will equate to 0, 15 to 29 will be 1, and so on.
• Convert each group into a new class (I’ve made it anonymous for space’s sake), with each group’s key (the string generated in the GroupBy) and the max, min, first and last values in the group.

You could probably make this run faster by doing the GroupBy a bit differently (i.e. using a class as the group key instead of building a string for each one).

UPDATE: I generated myself a better test case for this by adding 10,000 elements to myList with random values for the value and minute. I added a .ToList() on the end of the generation of grouped to make sure lazy evaluation wasn’t a factor. It ran in 34 milliseconds. I tried with 100,000 elements and it ran in 226 milliseconds (as measured by a StopWatch). Looks like performance isn’t a huge issue unless resources are constrained and you’ve got hundreds of thousands of elements in myList.