c# – 使用LINQ进行Lazily分区序列

我有以下扩展方法来查找序列中的元素,然后返回两个IEnumerable< T> s：一个包含该元素之前的所有元素,一个包含该元素和后面的所有元素.我更喜欢这种方法是懒惰的,但我还没有找到办法做到这一点.任何人都可以提出解决方案吗？

public static PartitionTuple<T> Partition<T>(this IEnumerable<T> sequence,Func<T,bool> partition)
{
    var a = sequence.ToArray();
    return new PartitionTuple<T>
    {
        Before = a.TakeWhile(v => !partition(v)),After = a.Skipwhile(v => !partition(v))
    };
}

执行sequence.ToArray()会立即失去懒惰的要求.然而,没有该行,可以迭代昂贵的迭代序列两次.而且,取决于调用代码的作用,还有很多次.

解决方法

这是一个有趣的问题,要做到正确,你必须知道“正确”是什么.对于操作的语义,我认为这个定义是有道理的：

>即使生成的序列被多次枚举,源序列也只被枚举一次.
>在枚举其中一个结果之前,不会枚举源序列.
>每个结果都应该可以独立枚举.
>如果源序列发生变化,则未定义将发生什么.

我不完全确定我正确处理了匹配对象,但我希望你能得到这个想法.我将很多工作推迟到PartitionTuple< T>上课可以偷懒.

public class PartitionTuple<T>
{
  IEnumerable<T> source;
  IList<T> before,after;
  Func<T,bool> partition;

  public PartitionTuple(IEnumerable<T> source,bool> partition)
  {
    this.source = source;
    this.partition = partition;
  }

  private void EnsureMaterialized()
  {
    if(before == null)
    {
      before = new List<T>();
      after = new List<T>();

      using(var enumerator = source.GetEnumerator())
      {
        while(enumerator.MoveNext() && !partition(enumerator.Current))
        {
          before.Add(enumerator.Current);   
        }

        while(!partition(enumerator.Current) && enumerator.MoveNext());

        while(enumerator.MoveNext())
        {
          after.Add(enumerator.Current);
        }
      }
    }
  }

  public IEnumerable<T> Before 
  { 
    get
    {
      EnsureMaterialized();
      return before;
    }
  }

  public IEnumerable<T> After
  {
    get
    {
      EnsureMaterialized();
      return after;
    }
  }
}

public static class Extensions
{
  public static PartitionTuple<T> Partition<T>(this IEnumerable<T> sequence,bool> partition)
  {
    return new PartitionTuple<T>(sequence,partition);
  }
}