I came to a following situation and need to decide which approach CalculateEntrySummaryInArray() (or) CalculateEntrySummaryInLINQ()
 is BEST in terms of

* Better Code
* Code maintainability
* Ability to understand the code
* Performance (The 'List events' contain max 100,000
events)

Please suggest.

```
 public enum EntryType
    {
        None,
        Entry,
        Exit
    }
public class EventEntity
    {
        public EventEntity()
        {
            Time = new DateTime(0);
            Name = string.Empty;
            Type = EntryType.None;
        }

        public DateTime Time { get; set; }
        public string Name { get; set; }
        public EntryType Type { get; set; }
    }    
    public class EntrySummary
    {
        public EntrySummary()
        {
            Time = new DateTime(0);
            Name = string.Empty;
            Count = 0;
        }

        public DateTime Time { get; set; }
        public string Name { get; set; }
        public int Count { get; set; }
    }

        public void CalculateEntrySummaryInArray(List<EventEntity> events)
        {
            List<EntrySummary> summary = new List<EntrySummary>();

            foreach (var entryEvent in events)
            {
                if (entryEvent.Type != EntryType.Entry) continue;

                if (summary.Count == 0)
                {
                    EntrySummary entrySummary = new EntrySummary();
                    entrySummary.Count = 1;
                    entrySummary.Name = entryEvent.Name;
                    entrySummary.Time = entryEvent.Time;

                    summary.Add(entrySummary);
                }
                else
                {
                    bool isAddedToSummary = false;

                    foreach (var item in summary)
                    {
                        if (item.Name == entryEvent.Name && item.Time.Date == entryEvent.Time.Date)
                        {
                            item.Count++;
                            isAddedToSummary = true; break;
                        }
                    }

                    if (isAddedToSummary == false)
                    {
                        EntrySummary entrySummary = new EntrySummary();
                        entrySummary.Count = 1;
                        entrySummary.Name = entryEvent.Name;
                        entrySummary.Time = entryEvent.Time;

                        summary.Add(entrySummary);
                    }
                }
            }

            foreach (var item in summary)
            {
                MessageBox.Show(item.Time.Date.ToString() + " " + item.Name + " " + item.Count);
            }
        }

        public void CalculateEntrySummaryInLINQ(List<EventEntity> events)
        {
            var summary = from entryEvent in events
                     where entryEvent.Type == EntryType.Entry
                     group entryEvent by new { entryEvent.Time.Date, entryEvent.Name} into groupedEvent
                     select new { groupedEvent.Key.Date, groupedEvent.Key.Name, Count = groupedEvent.Count() };

            foreach (var item in summary)
            {
                MessageBox.Show(item.Date.ToString() + " " + item.Name + " " + item.Count);
            }
        }

```