Merge elements in list by property

debugcn Published at Dev

Chostakovitch

Context

I have a list of time intervals. Time interval type is HistoMesures.

Each HistoMesure is defined by a Debut (begin) property, a Fin (end) property, and a Commentaires (a little note) property.

My list is made in such a way that :

All HistoMesure are exclusive, I mean that they can't be overlapping each other.
The list is sorted by Debut, so by the beggining of the interval.
Edit : All HistoMesure are contiguous in this configuration.

Question

I want to merge (transform two little intervals in one big interval) all adjacent HistoMesure which have the same Commentaires. Currently I achieve this that way :

//sortedHistos type is List<HistoMesure>
int i = 0;
while (i < sortedHistos.Count - 1)
{
    if (sortedHistos[i].Commentaires == sortedHistos[i + 1].Commentaires)
    {
        sortedHistos[i].Fin = sortedHistos[i + 1].Fin;
        sortedHistos.RemoveAt(i + 1);
    }
    else
    {
        ++i;
    }
}

But I feel that it exists a more elegant way to do this, maybe with LINQ. Do you have any suggestion ?

DavidG

Using Linq and borrowing from this article to group by adjacent values, this should work:

Your query:

var filteredHistos = sortedHistos
    .GroupAdjacent(h => h.Commentaires)
    .Select(g => new HistoMesure
    {
        Debut = g.First().Debut,
        Fin = g.Last().Fin,
        Commentaires = g.Key
    });

And copying from the article, the rest of the code to group by:

public class GroupOfAdjacent<TSource, TKey> : IEnumerable<TSource>, IGrouping<TKey, TSource>
{
    public TKey Key { get; set; }
    private List<TSource> GroupList { get; set; }
    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
    {
        return ((System.Collections.Generic.IEnumerable<TSource>)this).GetEnumerator();
    }
    System.Collections.Generic.IEnumerator<TSource> System.Collections.Generic.IEnumerable<TSource>.GetEnumerator()
    {
        foreach (var s in GroupList)
            yield return s;
    }
    public GroupOfAdjacent(List<TSource> source, TKey key)
    {
        GroupList = source;
        Key = key;
    }
}
public static class LocalExtensions
{
    public static IEnumerable<IGrouping<TKey, TSource>> GroupAdjacent<TSource, TKey>(
        this IEnumerable<TSource> source,
        Func<TSource, TKey> keySelector)
    {
        TKey last = default(TKey);
        bool haveLast = false;
        List<TSource> list = new List<TSource>();
        foreach (TSource s in source)
        {
            TKey k = keySelector(s);
            if (haveLast)
            {
                if (!k.Equals(last))
                {
                    yield return new GroupOfAdjacent<TSource, TKey>(list, last);
                    list = new List<TSource>();
                    list.Add(s);
                    last = k;
                }
                else
                {
                    list.Add(s);
                    last = k;
                }
            }
            else
            {
                list.Add(s);
                last = k;
                haveLast = true;
            }
        }
        if (haveLast)
            yield return new GroupOfAdjacent<TSource, TKey>(list, last);
    }
}

Collected from the Internet

Please contact [email protected] to delete if infringement.