F#技术问询：如何正确枚举多文件并实现流式float序列读取

这是一个很典型的大数据按需访问场景，我来给你一个C#的实现方案，完全符合你的需求——不用把所有数据加载到内存，按需从文件里读取转换：

基础版：仅支持顺序遍历（内存占用极低） #

我们可以实现一个IEnumerable<float>，利用C#的yield return实现延迟加载，每次迭代时才读取对应文件的下一个数据：

using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Linq;

public class OnDemandFloatSequence : IEnumerable<float>
{
    private readonly List<string> _sortedFiles;

    // 构造函数传入所有文件路径，自动按字典序排序
    public OnDemandFloatSequence(IEnumerable<string> filePaths)
    {
        // 先验证文件存在性与格式合法性
        foreach (var path in filePaths)
        {
            if (!File.Exists(path))
                throw new FileNotFoundException($"指定文件不存在: {path}");
            var fileInfo = new FileInfo(path);
            if (fileInfo.Length % 8 != 0)
                throw new InvalidDataException($"文件 {path} 大小不是8的倍数，不符合double数据格式要求");
        }

        // 按字典序排序文件路径
        _sortedFiles = filePaths.OrderBy(path => path).ToList();
    }

    public IEnumerator<float> GetEnumerator()
    {
        foreach (var filePath in _sortedFiles)
        {
            // 每次处理一个文件，用完自动释放资源
            using var fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read);
            using var binaryReader = new BinaryReader(fileStream);

            // 逐个读取小端序double，转换为float返回
            while (fileStream.Position < fileStream.Length)
            {
                double doubleValue = binaryReader.ReadDouble();
                yield return (float)doubleValue;
            }
        }
    }

    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
}

使用方式 #

// 替换为你的文件路径集合
var filePaths = new[] { "data_001.bin", "data_002.bin", "data_003.bin" };
var floatSequence = new OnDemandFloatSequence(filePaths);

// 按需遍历，比如只处理前1000个元素
foreach (var floatVal in floatSequence.Take(1000))
{
    // 在这里处理每个float值
    Console.WriteLine(floatVal);
}

进阶版：支持随机访问 #

如果你的场景需要随机访问指定索引的元素，可以扩展实现索引器，预先计算每个文件的元素范围，快速定位到目标文件：

public class IndexedOnDemandFloatSequence : IEnumerable<float>
{
    private readonly List<(string FilePath, long StartIndex)> _fileIndexMap;
    private long _totalElementCount;

    public IndexedOnDemandFloatSequence(IEnumerable<string> filePaths)
    {
        var sortedFiles = filePaths.OrderBy(path => path).ToList();
        _fileIndexMap = new List<(string, long)>();
        long currentStartIndex = 0;

        foreach (var path in sortedFiles)
        {
            if (!File.Exists(path))
                throw new FileNotFoundException($"指定文件不存在: {path}");
            var fileInfo = new FileInfo(path);
            if (fileInfo.Length % 8 != 0)
                throw new InvalidDataException($"文件 {path} 大小不是8的倍数，不符合double数据格式要求");

            long elementCount = fileInfo.Length / 8;
            _fileIndexMap.Add((path, currentStartIndex));
            currentStartIndex += elementCount;
        }

        _totalElementCount = currentStartIndex;
    }

    public long TotalCount => _totalElementCount;

    // 索引器：支持随机访问指定位置的float值
    public float this[long index]
    {
        get
        {
            if (index < 0 || index >= _totalElementCount)
                throw new IndexOutOfRangeException("索引超出序列范围");

            // 找到目标元素所在的文件
            var targetFile = _fileIndexMap.Last(entry => entry.StartIndex <= index);
            long elementOffsetInFile = index - targetFile.StartIndex;
            long byteOffset = elementOffsetInFile * 8; // 每个double占8字节

            using var fileStream = new FileStream(targetFile.FilePath, FileMode.Open, FileAccess.Read);
            using var binaryReader = new BinaryReader(fileStream);
            
            fileStream.Seek(byteOffset, SeekOrigin.Begin);
            double doubleValue = binaryReader.ReadDouble();
            return (float)doubleValue;
        }
    }

    public IEnumerator<float> GetEnumerator()
    {
        for (long i = 0; i < _totalElementCount; i++)
        {
            yield return this[i];
        }
    }

    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
}

关键说明 #

• 小端序兼容：.NET的BinaryReader.ReadDouble()默认以小端序解析数据，刚好匹配你的文件格式，无需额外字节转换。
• 内存优化：两种实现都不会一次性加载所有文件数据，基础版每次仅保留当前文件的流和读取器；进阶版随机访问时每次打开目标文件读取单个数据，内存占用始终极低。
• 异常处理：构造函数中提前验证文件有效性，避免运行时出现意外错误。

内容的提问来源于stack exchange，提问作者rabejens