Group lines of log-file using Linq

I have an array of strings from a log file with the following format:

var lines = new []
{
    "--------",
    "TimeStamp: 12:45",
    "Message: Message #1",
    "--------",
    "--------",
    "TimeStamp: 12:54",
    "Message: Message #2",
    "--------",
    "--------",
    "Message: Message #3",
    "TimeStamp: 12:55",
    "--------"
}

I want to group each set of lines (as delimited by "--------") into a list using LINQ. Basically, I want a List<List<string>> or similar where each inner list contains 4 strings - 2 separators, a timestamp and a message.

I should add that I would like to make this as generic as possible, as the log-file format could change.

Can this be done?

Will this work?

var result = Enumerable.Range(0, lines.Length / 4)
                       .Select(l => lines.Skip(l * 4).Take(4).ToList())
                       .ToList()

EDIT:

This looks a little hacky but I'm sure it can be cleaned up

    IEnumerable<List<String>> GetLogGroups(string[] lines)
    {
        var list = new List<String>();
        foreach (var line in lines)
        {
            list.Add(line);
            if (list.Count(l => l.All(c => c == '-')) == 2)
            {
                yield return list;
                list = new List<string>();
            }
        }
    }

You should be able to actually do better than returning a List>. If you're using C# 4, you could project each set of values into a dynamic type where the string before the colon becomes the property name and the value is on the left-hand side. You then create a custom iterator which reads the lines until the end "------" appears in each set and then yield return that row. On MoveNext, you read the next set of lines. Rinse and repeat until EOF. I don't have time at the moment to write up a full implementation, but my sample on reading in CSV and using LINQ over the dynamic objects may give you an idea of what you can do. See http://www.thinqlinq.com/Post.aspx/Title/LINQ-to-CSV-using-DynamicObject. (note this sample is in VB, but the same can be done in C# as well with some modifications).

The iterator implementation has the added benefit of not having to load the entire document into memory before parsing. With this version, you only load the amount for one set of blocks at a time. It allows you to handle really large files.

Assuming that your structure is always

delimeter
TimeStamp
Message
delimeter

public List<List<String>> ConvertLog(String[] log)
{
    var LogSet = new List<List<String>>();
    for(i = 0; i < log.Length(); i += 4)
    {
        if (log.Length <= i+3)
        {
           var set = new List<String>() { log[i], log[i+1], log[i+2], log[i+3] };
           LogSet.Add(set);
        }
    }

}

Or in Linq

public List<List<String> ConvertLog(String[] log)
{
   return Enumerable.Range(0, lines.Length / 4)
                    .Select(l => lines.Skip(l * 4).Take(4).ToList())
                    .ToList()

}