Как группировать последовательные похожие элементы коллекции?

Question

Рассмотрите следующую коллекцию.

• Правда
• Ложные
• Ложные
• Ложные
• Правда
• Правда
• Ложные
• Ложные

Я хочу для отображения его структурированным способом, скажем, в TreeView. Я хочу иметь возможность рисовать границы вокруг целых групп и т. Д.

• Правда Группа
  • Правда
• Ложные Группа
  • Ложные
  • Ложные
  • Ложные
• Правда Группа
  • Правда
  • Правда
• Ложные Группа
  • Ложные
  • Ложные

Как выполним ли это с минимальным процедурным кодом?

Answer 1

Это делает то, что вы ищете и родовое:

private static IEnumerable<IGrouping<int, T>> GroupConsecutive<T>(this IEnumerable<T> set, Func<T, T, bool> predicate) 
{ 
    var i = 0; 
    var k = 0; 
    var ranges = from e in set 
       let idx = ++i 
       let next = set.ElementAtOrDefault(idx) 
       let key = (predicate(e, next)) ? k : k++ 
       group e by key into g 
       select g; 
    return ranges; 
} 

Использование:

var set = new List<bool> 
      { 
       true, 
       false, 
       false, 
       false, 
       true, 
       true, 
       false, 
       false, 
      }; 
var groups = set.GroupConsecutive((b1, b2) => (b1 == b2)); 
foreach (var g in groups) 
{ 
    Console.WriteLine(g.Key); 
    foreach (var b in g) 
     Console.WriteLine("\t{0}", b); 
} 

Выход:

0 
     True 
1 
     False 
     False 
     False 
2 
     True 
     True 
3 
     False 
     False 

Answer 2

last = null; 
foreach (var option in list) 
{ 
    if (last != option) 
     newlist.Add(new Group(option, new[])); 
    newlist.Last().Add(option); 
    last = option; 
} 

Answer 3

public class GroupConsecutiveEqualItemsConverter : IValueConverter 
{ 
    static readonly object UnsetValue = new object(); 

    public object Convert(object value, Type targetType, object parameter, CultureInfo culture) 
    { 
     IEnumerable source = value as IEnumerable; 
     if (source == null) return DependencyProperty.UnsetValue; 
     string propertyName = parameter as string; 
     var result = new ObservableCollection<List<object>>(); 

     var notify = value as INotifyCollectionChanged; 
     if (notify != null) notify.CollectionChanged += delegate { Reload(result, source, propertyName); }; 

     Reload(result, source, propertyName); 
     return result; 
    } 

    public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture) 
    { 
     throw new NotSupportedException(); 
    } 

    void Reload(ObservableCollection<List<object>> result, IEnumerable source, string propertyName) 
    { 
     result.Clear(); 
     object previous = UnsetValue; 
     List<object> group = null; 
     foreach (object i in source) 
     { 
      object current = UnsetValue; 
      if (propertyName == null) 
      { 
       current = i; 
      } 
      else 
      { 
       try 
       { 
        var property = i.GetType().GetProperty(propertyName); 
        if (property != null) current = property.GetValue(i, null); 
       } 
       catch (AmbiguousMatchException) { } 
      } 
      if (!object.Equals(previous, current)) 
      { 
       if (group != null) result.Add(group); 
       group = new List<object>(); 
      } 
      group.Add(i); 
      previous = current; 
     } 
     if (group != null && group.Count > 0) result.Add(group); 
    } 
} 

Answer 4

Вы можете хотите проверить псевдо TreeGrid на Delay's blog в http://blogs.msdn.com/delay/archive/2009/09/23/if-it-walks-like-a-duck-and-talks-like-a-duck-it-must-be-a-treegrid-a-simple-xaml-only-treegrid-ui-for-wpf.aspx

alt text http://blogs.msdn.com/blogfiles/delay/SimpleTreeGridUX.png

Answer 5

Хотя код в принятом ответе отвечает потребностям первоначального вопроса, он будет падать при обработке IEnumerables более сложных объектов (так как предикат будет стремиться генерировать исключение при сравнении последнего элемента в перечисляемом с «следующим» элементом [который по определению всегда будет null]).

Эта версия поддерживает более сложные объекты:

public static IEnumerable<IGrouping<int, T>> GroupConsecutive<T>(this IEnumerable<T> set, Func<T, T, bool> predicate) 
    { 
     var i = 0; 
     var k = 0; 
     var ranges = from e in set 
        let idx = ++i 
        let next = set.ElementAtOrDefault(idx) 
        let key = next == null ? k : (predicate(e, next)) ? k : k++ 
        group e by key into g 
        select g; 
     return ranges; 
    }