假设我们有一个 Foo类:

public class Foo
{
    public DateTime Timestamp { get; set; }
    public double Value { get; set; }

    // some other properties

    public static Foo CreateFromXml(Stream str)
    {
        Foo f = new Foo();

        // do the parsing

        return f;
    }

    public static IEnumerable<Foo> GetAllTheFoos(DirectoryInfo dir)
    {
        foreach(FileInfo fi in dir.EnumerateFiles("foo*.xml", SearchOption.TopDirectoryOnly))
        {
            using(FileStream fs = fi.OpenRead())
                yield return Foo.CreateFromXML(fs);
        }
    }
}

为了让您了解情况，我可以说这些文件中的数据已经以通常每分钟几个 Foo 的频率记录了大约 2 年。

现在:我们有一个名为 TimeSpan TrainingPeriod 的参数例如大约 15 天。我想要完成的是调用:

var allTheData = GetAllTheFoos(myDirectory);

并获得IEnumerable<Foo> TrainingSet, TestSet其中，TrainingSet由 Foos 组成从记录的前 15 天开始，以及 TestSet所有其余的。然后，出 TrainingSet我们想要计算一些常量内存数据(如平均值 Value 、一些线性回归等)，然后使用计算值开始使用测试集。换句话说，我的代码应该语义上等同于:

TimeSpan TrainingPeriod = new TimeSpan(15, 0, 0); // hope it says 15 days

var allTheData = GetAllTheFoos(myDirectory);
List<Foo> allTheDataList = allTheData.ToList();

var threshold = allTheDataList[0].Timestamp + TrainingPeriod;

List<Foo> TrainingSet = allTheDataList.Where(foo => foo.Timestamp < threshold).ToList();
List<Foo> TestSet = allTheDataList.Where(foo => foo.Timestamp >= threshold).ToList();

顺便说一句，XML 文件命名约定向我保证，Foos 将按时间顺序返回。 当然，我不想将其全部存储在内存中，每次都会发生这种情况 .ToList()叫做。所以我想到了另一个解决方案:

TimeSpan TrainingPeriod = new TimeSpan(15, 0, 0);

var allTheData = GetAllTheFoos(myDirectory);

var threshold = allTheDataList.First().Timestamp + TrainingPeriod; // a minor issue

var grouped = from foo in allTheData
              group foo by foo.Timestamp < Training;

var TrainingSet = grouped.First(g => g.Key);
var TestSet = grouped.First(g => !g.Key); // the major one

但是，关于那段代码有一个小问题和一个大问题。次要的是第一个文件至少被读取了两次——实际上并不重要。但看起来 TrainingSet 和 TestSet 独立访问目录，读取每个文件两次并仅选择那些持有特定时间戳约束的文件。我对此并不太困惑 - 事实上，如果它有效，我会感到困惑并且不得不再次重新考虑 LINQ。但这会引发文件访问问题，并且每个文件都会被解析两次，这完全是在浪费 CPU 时间。

所以我的问题是:我可以只使用简单的 LINQ/C# 工具来实现这种效果吗？我想我可以用一种很好的蛮力方式来做到这一点，覆盖一些 GetEnumerator() , MoveNext()方法等等 - 请不要费心输入，我完全可以自己处理。

但是，如果对此有一些优雅、简短和甜蜜的解决方案，我们将不胜感激。

谢谢!

另一个编辑:

我最终想出的代码如下:

public static void Handle(DirectoryInfo dir)
{
    var allTheData = Foo.GetAllTheFoos(dir);

    var it = allTheData.GetEnumerator();

    it.MoveNext();

    TimeSpan trainingRange = new TimeSpan(15, 0, 0, 0);

    DateTime threshold = it.Current.Timestamp + trainingRange;

    double sum = 0.0;
    int count = 0;

    while(it.Current.Timestamp <= threshold)
    {
        sum += it.Current.Value;
        count++;

        it.MoveNext();
    }

    double avg = sum / (double)count;

    // now I can continue on with the 'it' IEnumerator
}

当然仍然存在一些小问题，即非常重视 MoveNext() 的输出(它是否已经结束 IEnumerable？)，但我希望总体思路很清楚。 但是 在实际代码中，我计算的不仅仅是平均值，还有不同类型的回归等。所以我想以某种方式提取第一部分，将其作为 IEnumerable 传递给派生自的类我的

public abstract class AbstractAverageCounter
{
    public abstract void Accept(IEnumerable<Foo> theData);
    public AverageCounterResult Result { get; protected set; }
}

分离训练数据提取和处理的职责。加上在我得到 IEnumerator<Foo> 之前描述的过程之后，但我认为 IEnumerable<Foo>最好将它传递给我的 TheRestOfTheDataHandler实例。

最佳答案

您可以尝试在从初始 ienumerable 获得的 ienumerator 上实现有状态迭代器模式。

IEnumerable<T> StatefulTake(IEnumerator<T> source, Func<bool> getDone, Action setDone);

此方法仅检查完成，调用 MoveNext，产生 Current 并在 movenext 返回 false 时更新完成。

然后您将您的集合拆分为对该方法的后续调用，并使用以下方法对其进行部分枚举: 暂时 任何 第一的 ... 然后您可以在此基础上执行任何操作，但每个操作都必须枚举到最后。

var source = GetThemAll();
using (var e = source.GetEnumerator()){
 bool done=!source.MoveNext();
 foreach(var i in StatefulTake(e, ()=>done,()=>done=true).TakeWhile(i=>i.Time<...)){
  //...
 }

 var theRestAverage = StatefulTake(e,()=>done,()=>done=true).Avg(i=>i.Score);
 //...
}

这是我在我的异步工具包中经常使用的模式。

更新:修复了 StatefulTake 方法的签名，它不能使用 ref 参数。对 MoveNext 的初始调用也是必要的。三种done 变量引用和方法本身应该封装在上下文类中。

关于c# - 使用条件将一次性大型 IEnumerable<T> 分成两半，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/28542995/