LINQ查询通过某些条件将有序列表拆分为连续点的子列表

寻找帮助在某些对象上编写LINQ查询。 我觉得如果我的LINQ技能更加忍者,我可以通过一些聪明的GroupBy / SelectMany(或其他东西?!)来做到这一点。

一般来说,问题是:给定一个按某种顺序排列的对象列表,其中每个对象都有一个Flag,如何将列表拆分为子列表,其中每个子列表都是设置标志的所有连续点?

这样做的必要方法就像下面的伪代码:

foreach object obj if(obj.FlagSet) add it to my currentsublist else skip to the next obj where FlagSet and start a new sublist 

因此,给出以下输入:

{1,Flag},{2,Flag},{3,NoFlag},{4,Flag},{5,NoFlag},{6,Flag} ……

我想要以下输出:

清单1:{1,2}清单2:{4}清单3:{6}

我想通过LINQ在function上做到这一点。 有任何想法吗?

(我先看了一下,但是我能看到的所有问题似乎都想要简单地将一个列表分组或分成相同的大小,这对我没有帮助。)

此MSDN文章提供了按连续值分组的代码:

http://msdn.microsoft.com/en-us/library/cc138361.aspx

在链接腐烂的情况下,我从上面的链接中复制了代码:

 public static class MyExtensions { public static IEnumerable> ChunkBy(this IEnumerable source, Func keySelector) { return source.ChunkBy(keySelector, EqualityComparer.Default); } public static IEnumerable> ChunkBy(this IEnumerable source, Func keySelector, IEqualityComparer comparer) { // Flag to signal end of source sequence. const bool noMoreSourceElements = true; // Auto-generated iterator for the source array. var enumerator = source.GetEnumerator(); // Move to the first element in the source sequence. if (!enumerator.MoveNext()) yield break; // Iterate through source sequence and create a copy of each Chunk. // On each pass, the iterator advances to the first element of the next "Chunk" // in the source sequence. This loop corresponds to the outer foreach loop that // executes the query. Chunk current = null; while (true) { // Get the key for the current Chunk. The source iterator will churn through // the source sequence until it finds an element with a key that doesn't match. var key = keySelector(enumerator.Current); // Make a new Chunk (group) object that initially has one GroupItem, which is a copy of the current source element. current = new Chunk(key, enumerator, value => comparer.Equals(key, keySelector(value))); // Return the Chunk. A Chunk is an IGrouping, which is the return value of the ChunkBy method. // At this point the Chunk only has the first element in its source sequence. The remaining elements will be // returned only when the client code foreach's over this chunk. See Chunk.GetEnumerator for more info. yield return current; // Check to see whether (a) the chunk has made a copy of all its source elements or // (b) the iterator has reached the end of the source sequence. If the caller uses an inner // foreach loop to iterate the chunk items, and that loop ran to completion, // then the Chunk.GetEnumerator method will already have made // copies of all chunk items before we get here. If the Chunk.GetEnumerator loop did not // enumerate all elements in the chunk, we need to do it here to avoid corrupting the iterator // for clients that may be calling us on a separate thread. if (current.CopyAllChunkElements() == noMoreSourceElements) { yield break; } } } // A Chunk is a contiguous group of one or more source elements that have the same key. A Chunk // has a key and a list of ChunkItem objects, which are copies of the elements in the source sequence. class Chunk : IGrouping { // INVARIANT: DoneCopyingChunk == true || // (predicate != null && predicate(enumerator.Current) && current.Value == enumerator.Current) // A Chunk has a linked list of ChunkItems, which represent the elements in the current chunk. Each ChunkItem // has a reference to the next ChunkItem in the list. class ChunkItem { public ChunkItem(TSource value) { Value = value; } public readonly TSource Value; public ChunkItem Next = null; } // The value that is used to determine matching elements private readonly TKey key; // Stores a reference to the enumerator for the source sequence private IEnumerator enumerator; // A reference to the predicate that is used to compare keys. private Func predicate; // Stores the contents of the first source element that // belongs with this chunk. private readonly ChunkItem head; // End of the list. It is repositioned each time a new // ChunkItem is added. private ChunkItem tail; // Flag to indicate the source iterator has reached the end of the source sequence. internal bool isLastSourceElement = false; // Private object for thread syncronization private object m_Lock; // REQUIRES: enumerator != null && predicate != null public Chunk(TKey key, IEnumerator enumerator, Func predicate) { this.key = key; this.enumerator = enumerator; this.predicate = predicate; // A Chunk always contains at least one element. head = new ChunkItem(enumerator.Current); // The end and beginning are the same until the list contains > 1 elements. tail = head; m_Lock = new object(); } // Indicates that all chunk elements have been copied to the list of ChunkItems, // and the source enumerator is either at the end, or else on an element with a new key. // the tail of the linked list is set to null in the CopyNextChunkElement method if the // key of the next element does not match the current chunk's key, or there are no more elements in the source. private bool DoneCopyingChunk { get { return tail == null; } } // Adds one ChunkItem to the current group // REQUIRES: !DoneCopyingChunk && lock(this) private void CopyNextChunkElement() { // Try to advance the iterator on the source sequence. // If MoveNext returns false we are at the end, and isLastSourceElement is set to true isLastSourceElement = !enumerator.MoveNext(); // If we are (a) at the end of the source, or (b) at the end of the current chunk // then null out the enumerator and predicate for reuse with the next chunk. if (isLastSourceElement || !predicate(enumerator.Current)) { enumerator = null; predicate = null; } else { tail.Next = new ChunkItem(enumerator.Current); } // tail will be null if we are at the end of the chunk elements // This check is made in DoneCopyingChunk. tail = tail.Next; } // Called after the end of the last chunk was reached. It first checks whether // there are more elements in the source sequence. If there are, it // Returns true if enumerator for this chunk was exhausted. internal bool CopyAllChunkElements() { while (true) { lock (m_Lock) { if (DoneCopyingChunk) { // If isLastSourceElement is false, // it signals to the outer iterator // to continue iterating. return isLastSourceElement; } else { CopyNextChunkElement(); } } } } public TKey Key { get { return key; } } // Invoked by the inner foreach loop. This method stays just one step ahead // of the client requests. It adds the next element of the chunk only after // the clients requests the last element in the list so far. public IEnumerator GetEnumerator() { //Specify the initial element to enumerate. ChunkItem current = head; // There should always be at least one ChunkItem in a Chunk. while (current != null) { // Yield the current item in the list. yield return current.Value; // Copy the next item from the source sequence, // if we are at the end of our local list. lock (m_Lock) { if (current == tail) { CopyNextChunkElement(); } } // Move to the next ChunkItem in the list. current = current.Next; } } System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { return GetEnumerator(); } } } 

它不漂亮,但效果很好。

在你的情况下,它将是这样的:

 myList.ChunkBy( o => o.FlagSet ) 

除了@spenders优秀链接(+1!) ,我还要补充:

很漂亮,效果很好:

  • 它完全以懒惰模式运行
  • 它是线程安全的
  • 通过提供实现IGrouping<> Chunk<>来集成到标准linq中
  • 它有一些样式问题(命名,超出范围,缺少m_lock的readonly修饰符;类似的东西)

我现在看到的唯一真正的抱怨是,它无法主动处理从可枚举来源获得的枚举数。 这是我的相关修复:

 public static IEnumerable> ChunkBy(this IEnumerable source, Func keySelector, IEqualityComparer comparer) { // ... using (var enumerator = source.GetEnumerator()) // <--- FIXED { 

更新

这是我完全修改过的源代码,修复了上面列出的所有问题。 **这也使得Chunk<>一次性:

 using System; using System.Collections.Generic; using System.Linq; namespace ChunkIt { public static class MyExtensions { public static IEnumerable> ChunkBy(this IEnumerable source, Func keySelector) { return source.ChunkBy(keySelector, EqualityComparer.Default); } public static IEnumerable> ChunkBy(this IEnumerable source, Func keySelector, IEqualityComparer comparer) { const bool noMoreSourceElements = true; using (var enumerator = source.GetEnumerator()) { if (!enumerator.MoveNext()) yield break; Chunk current; while (true) { var key = keySelector(enumerator.Current); current = new Chunk(key, enumerator, value => comparer.Equals(key, keySelector(value))); yield return current; if (current.CopyAllChunkElements() == noMoreSourceElements) yield break; } } } class Chunk : IGrouping, IDisposable { class ChunkItem { public ChunkItem(TSource value) { Value = value; } public readonly TSource Value; public ChunkItem Next; } private readonly TKey _key; private IEnumerator _enumerator; private Func _predicate; private readonly ChunkItem _head; private ChunkItem _tail; private bool _isLastSourceElement; private readonly object _mLock; public Chunk(TKey key, IEnumerator enumerator, Func predicate) { _key = key; _enumerator = enumerator; _predicate = predicate; _head = new ChunkItem(enumerator.Current); _tail = _head; _mLock = new object(); } private bool DoneCopyingChunk { get { return _tail == null; } } private void CopyNextChunkElement() { _isLastSourceElement = !_enumerator.MoveNext(); if (_isLastSourceElement || !_predicate(_enumerator.Current)) { _enumerator = null; _predicate = null; } else { _tail.Next = new ChunkItem(_enumerator.Current); } _tail = _tail.Next; } internal bool CopyAllChunkElements() { while (true) lock (_mLock) { if (DoneCopyingChunk) return _isLastSourceElement; CopyNextChunkElement(); } } public TKey Key { get { return _key; } } public IEnumerator GetEnumerator() { ChunkItem current = _head; while (current != null) { yield return current.Value; lock (_mLock) if (current == _tail) CopyNextChunkElement(); current = current.Next; } } System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { return GetEnumerator(); } #region Implementation of IDisposable public void Dispose() { if (null!=_enumerator) _enumerator.Dispose(); } #endregion } } } 

我认为方法是你管理两个列表和其他过去只是将第一个列表添加到最终列表并清除第一个列表并在设置标志时将对象添加到第一个列表

通过LINQ

 var list = new[] { new KeyValuePair("A", "We"), new KeyValuePair("A", "Think"), new KeyValuePair("A", "That"), new KeyValuePair("B", "Linq"), new KeyValuePair("C", "Is"), new KeyValuePair("A", "Really"), new KeyValuePair("B", "Cool"), new KeyValuePair("B", "!") }; var queryGroup = list.Select(data => data). GroupBy(g => g.Key, //group key i => i.Value //value ); foreach (var group in queryGroup) { foreach (var data in group) { } } //even/odd grouping int groupCount = 2; var queryEvenOdd = list.Select((data, index) => new { data, index }). GroupBy( g => g.index % groupCount,//group key i => i.data //value );