如何用Span<char>/Memory<char>逐行读取文件优化COBOL预处理器？

直接逐行读取文件并返回Span<char>/Memory<char>是不可行的——因为磁盘文件的内容并非直接映射到托管内存的连续块，Span<char>只能指向栈、托管堆或非托管内存的连续区域。但我们可以通过一次性加载文件到连续内存块，再在内存内拆分、处理行的方式，完全避免大量字符串分配，实现高效预处理。

核心思路 #

1. 把整个COBOL源文件加载到一块Memory<char>中，避免逐行读取带来的多次内存分配。
2. 在内存块内直接拆分出ReadOnlySpan<char>形式的行切片，所有行操作都基于原内存的视图，不生成新字符串。
3. 预处理完成后，将结果一次性写入文件，全程最小化内存开销。

具体实现步骤 #

1. 加载文件到Memory<char>

避免使用File.ReadAllText（会生成完整字符串），改用字节读取+解码的方式直接得到Memory<char>：

// 根据COBOL文件实际编码调整，常见为IBM-1047、ASCII或OEM编码
var encoding = Encoding.GetEncoding(1047);
var fileBytes = File.ReadAllBytes("source.cbl");

// 直接解码到char数组并转为Memory<char>，无额外字符串分配
var fileMemory = encoding.GetChars(fileBytes).AsMemory();

2. 枚举内存中的行（返回ReadOnlySpan<char>）

自己实现行拆分逻辑，跳过string.Split带来的数组分配：

IEnumerable<ReadOnlySpan<char>> EnumerateLines(ReadOnlyMemory<char> memory)
{
    var span = memory.Span;
    int startIndex = 0;
    var newLineChars = Environment.NewLine.AsSpan();

    for (int i = 0; i < span.Length; i++)
    {
        // 匹配CRLF或LF换行符
        if (span[i] == '\n')
        {
            int endIndex = i;
            if (i > 0 && span[i-1] == '\r')
                endIndex--;
            
            yield return span.Slice(startIndex, endIndex - startIndex);
            startIndex = i + 1;
        }
    }

    // 处理最后一行（无换行符的情况）
    if (startIndex < span.Length)
        yield return span.Slice(startIndex);
}

3. 高效预处理逻辑

基于ReadOnlySpan<char>处理每行，所有操作都是内存切片的视图，无额外分配：

bool isFixedFormat = false;
var processedLines = new List<ReadOnlySpan<char>>();

foreach (var line in EnumerateLines(fileMemory))
{
    // 处理FREE/FIXED指令，直接跳过指令行
    if (line.StartsWith("*FREE"))
    {
        isFixedFormat = false;
        continue;
    }
    else if (line.StartsWith("*FIXED"))
    {
        isFixedFormat = true;
        continue;
    }

    // 处理行内容：FIXED格式移除前7个字符
    ReadOnlySpan<char> processedLine = line;
    if (isFixedFormat && line.Length >= 7)
    {
        processedLine = line.Slice(7);
    }

    // 示例：插入自定义行逻辑
    if (processedLine.StartsWith("PROCEDURE DIVISION"))
    {
        processedLines.Add("* PREPROCESSED: ADDED COMMENT".AsSpan());
    }

    processedLines.Add(processedLine);
}

4. 输出处理结果

计算总长度后一次性写入，避免多次IO和字符串拼接：

// 计算最终内容总长度（包含换行符）
int totalLength = 0;
var newLineSpan = Environment.NewLine.AsSpan();
foreach (var line in processedLines)
{
    totalLength += line.Length + newLineSpan.Length;
}
totalLength -= newLineSpan.Length; // 最后一行无需换行符

// 分配结果内存并复制内容
var resultBuffer = new char[totalLength];
int writePos = 0;

foreach (var line in processedLines)
{
    line.CopyTo(resultBuffer.AsSpan(writePos));
    writePos += line.Length;
    
    if (writePos < totalLength)
    {
        newLineSpan.CopyTo(resultBuffer.AsSpan(writePos));
        writePos += newLineSpan.Length;
    }
}

// 写入最终文件
File.WriteAllText("processed.cbl", new string(resultBuffer), encoding);

进阶优化（超大文件场景） #

如果处理GB级别的COBOL源文件，可以使用MemoryMappedFile将文件直接映射到内存，无需加载整个文件到托管堆：

using var mmf = MemoryMappedFile.CreateFromFile("source.cbl", FileMode.Open);
using var stream = mmf.CreateViewStream();
var buffer = new byte[4096];
// 按块读取映射内存，结合Span<char>处理（逻辑类似上述步骤）

这种方式能进一步降低内存占用，适合极端大文件场景。

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