确定序列中两个或多个元素是否具有相同属性

Question

如果序列中两个或多个元素在列表中具有相同属性，我想识别并提取元素。 例如 我有一个列表 有一个名为IsValid的 现在我想确定是否在序列中的两个或多个文档具有的IsValid ==文档属性真正 假设结构

IsValid = false 
IsValid = true 
IsValid = true 
IsValid = false 
IsValid = true 
IsValid = false 

我的查询应该只返回元素2和3，因为只有这两个顺序，并且ISvalid = true 我该如何实现它？

Answer 1

您只需检查当前项目是否有效，以及上一个项目是否在同一时间有效。这将捕获大多数情况，但是如果尚未存储之前需要确保保留之前的项目。

类似下面的代码应该做的。请注意，它是从内存写入的，未经测试，而我不是最有效的方法。

public List<Document> GetConsecutiveTrueDocs(List<Document> list) 
{ 
    var result = new List<Document>(); 

    if(list.Count < 2) 
     return result; 

    for(int i = 1; i < list.Count; i++) 
    { 
     if(list[i].IsValid && list[i-1].IsValid) 
     { 
      if(!result.Contains(list[i-1])) 
       result.Add(list[i-1]); 

      result.Add(list[i]); 
     } 
    } 

    return result; 
} 

Answer 2

你可以写一个简单的LINQ扩展方法：

public static IEnumerable<IEnumerable<TSource>> 
    ContinuouslyEqualSubSequences<TSource, TResult>(
     this IEnumerable<TSource> source, 
     Func<TSource, TResult> func 
) { 
    var e = source.GetEnumerator(); 
    var currentSequence = default(List<TSource>); 
    var resultOfCurrentSequence = default(TResult); 
    if (e.MoveNext()) { 
     currentSequence = new List<TSource>() { e.Current }; 
     resultOfCurrentSequence = func(e.Current); 
    } 
    while (e.MoveNext()) { 
     var currentResult = func(e.Current); 
     if(Object.Equals(resultOfCurrentSequence, currentResult)) { 
      currentSequence.Add(e.Current); 
     } 
     else { 
      if(currentSequence.Count > 1) { 
       yield return currentSequence; 
      } 
      currentSequence = new List<TSource>() { e.Current }; 
      resultOfCurrentSequence = currentResult; 
      } 
     } 

     if (currentSequence.Count > 1) { 
      yield return currentSequence; 
     } 
    } 

在

var sequence = new { 3, 4, 7, 8, 9, 2, 4, 6, 0, 1, 1, 17, 2, 3, 2, 20 }; 
var subsequences = sequence.ContinuouslyEqualSubSequences(x => x % 2); 

我找回序列

2 4 6 0 
1 1 17 
2 20 

如预期，因为我们正在寻找这里为奇数o的连续子序列r偶数。

Answer 3

下面是一个相对简单的扩展方法，它的来源序列，并告诉任何两个元素是否被视为相等的功能，并返回元素的一个序列：

public static IEnumerable<T> Consecutives<T>(this IEnumerable<T> source, 
              Func<T, T, bool> equals) 
{ 
    T last = default(T); 
    bool first = true; 
    bool returnedLast = false; 
    foreach (T current in source) 
    { 
     if (!first && equals(current, last)) 
     { 
      if (!returnedLast) 
       yield return last; 
      returnedLast = true; 
      yield return current; 
     } 
     else 
      returnedLast = false; 
     first = false; 
     last = current; 
    } 
} 

如果用

尝试

var sequence = new[] { 3, 4, 7, 8, 9, 2, 4, 6, 0, 1, 1, 17, 2, 3, 2, 20 }; 
var subsequences = sequence.Consecutives((x, y) => x % 2 == y % 2); 

你将得到： 2 4 6 0 1 1 17 2 20

如果你的序列不具有任何重复，T他雷蒙德的解决方案的扩展是效率低下，而且很简单：

public static IEnumerable<T> Consecutives<T>(this IEnumerable<T> source, 
              Func<T, T, bool> equals) 
{ 
    return source.Zip(source.Skip(1), (x, y) => new[] { x, y }) 
       .Where(d => equals(d[0], d[1])) 
       .SelectMany(d => d) 
       .Distinct(); 
} 

Answer 4

这可以通过自身的偏移版本荏苒序列减少到一个班轮。

public static IEnumerable<Tuple<TSource,TSource>> 
    Consecutives<TSource>(this IEnumerable<TSource> source, 
          Func<TSource, TSource, bool> equals) 
{ 
    return source.Zip(source.Skip(1), (x, y) => Tuple.Create(x,y)) 
       .Where(d => equals(d.Item1, d.Item2)); 
}