C#实现从后往前反向读取文件指定行数

 /// <summary>
 /// 从后往前读取文件最后行数据
 /// </summary>
 /// <param name="filePath"></param>
 /// <param name="count"></param>
 /// <returns></returns>
 public static List<string> ReadFileRevLastLine(string filePath, int count)
 {
     var lines = new List<string>();
     try
     {
         foreach (string line in File.ReadLines(filePath, Encoding.Default).Reverse())
         {
             lines.Add(line);
             if (lines.Count >= count)
             {
                 break;
             }
         }
     }
     catch (Exception ex)
     {
     }
     return lines;
 }

using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
public static class ReverseFileReader
{
    /// <summary>
    /// 从文件末尾向前读取指定行数，返回按原始顺序（从上到下）的行列表。
    /// </summary>
    /// <param name="filePath">文件路径</param>
    /// <param name="lineCount">需要读取的行数（倒数第N行）</param>
    /// <param name="encoding">文件编码，默认UTF-8</param>
    /// <returns>行列表，顺序为从倒数第N行到最后一行；若文件行数不足 lineCount，则返回所有行</returns>
    public static List<string> ReadLastLines(string filePath, int lineCount, Encoding encoding = null)
    {
        if (lineCount <= 0)
            return new List<string>();
        if (encoding == null)
            encoding = Encoding.UTF8;
        var lines = new List<string>();
        long position;
        byte[] buffer;
        int bytesRead;
        int newlineCount = 0;
        bool lastCharIsNewline = false;
        using (var fs = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read, 4096, FileOptions.SequentialScan))
        {
            long fileSize = fs.Length;
            if (fileSize == 0)
                return lines;
            // 从文件末尾开始，逐块向前读取
            int bufferSize = 4096; // 每次读取 4KB
            position = fileSize;
            bool done = false;
            while (!done && lines.Count < lineCount)
            {
                // 计算本次读取的起始位置和实际大小
                long startOffset = Math.Max(0, position - bufferSize);
                int needRead = (int)(position - startOffset);
                buffer = new byte[needRead];
                fs.Seek(startOffset, SeekOrigin.Begin);
                bytesRead = fs.Read(buffer, 0, needRead);
                if (bytesRead == 0)
                    break;
                // 从缓冲区末尾向前扫描
                for (int i = bytesRead - 1; i >= 0 && lines.Count < lineCount; i--)
                {
                    // 处理跨块情况：上一个块的结尾与当前块开头需正确合并，
                    // 但简单实现中通过保留上次未完成的行内容实现，为简化，采用累计行区分方法。
                    // 更稳健的方式：将扫描到的行暂存至临时列表，最后反转。
                }
                // 上述逐字节扫描比较繁琐，通常采用另一种策略：
                // 通过检测换行符来分割行，同时记录完整行内容。
                // 下面用更清晰的方式：从后向前累积字符，遇到换行符时分割。
                // 为避免代码冗长，改用直接累积块的方式：
                // 已经有很多标准实现，我将重写一个更清晰的版本。
            }
        }
        // 为了代码简洁，采用另一种更常见也更易理解的实现：
        // 使用 StreamReader 配合 Seek 定位，但效率稍低。
        // 以下给出两套方案，推荐使用第一套（基于字节扫描 + 手动解码），
        // 但为了可读性，第二套方案（基于 StreamReader 部分读取）更容易理解，
        // 且对于大多数文件已足够高效。
        // 实际生产推荐使用开源库或自己实现可靠的缓冲区扫描。下面给出完整实现的最终版本。
    }
}

using System;
using System.Collections.Generic;
using System.IO;
using System.Text;

public static class ReverseFileReader
{
    /// <summary>
    /// 从文件末尾反向读取指定行数。
    /// </summary>
    /// <param name="filePath">文件路径</param>
    /// <param name="lineCount">需要读取的行数（倒数最后 N 行）</param>
    /// <param name="encoding">文件编码，默认为 UTF-8</param>
    /// <returns>行列表，按原始从上到下的顺序</returns>
    public static List<string> ReadLastLines(string filePath, int lineCount, Encoding encoding = null)
    {
        if (lineCount <= 0)
            return new List<string>();

        if (encoding == null)
            encoding = Encoding.UTF8;

        var lines = new Stack<string>(); // 用栈暂存，最后弹出恢复顺序

        using (var fs = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read, 4096, FileOptions.SequentialScan))
        {
            long fileSize = fs.Length;
            if (fileSize == 0)
                return new List<string>();

            // 从文件末尾附近开始，每次向前读取一块数据，并从中解析出完整的行
            long position = fileSize;
            int bufferSize = 4096;
            byte[] buffer = new byte[bufferSize];
            // 用于存储跨块的不完整行（从后向前拼接时，当前块开头可能是不完整的尾部）
            string leftover = null;

            while (lines.Count < lineCount && position > 0)
            {
                int readSize = (int)Math.Min(bufferSize, position);
                position -= readSize;
                fs.Seek(position, SeekOrigin.Begin);
                int bytesRead = fs.Read(buffer, 0, readSize);

                // 解码当前块（注意：可能跨块导致编码问题，此处简化处理，假设文件是单字节或 UTF-8 对齐）
                // 更好的做法是使用 Decoder，但为简洁，这里假设不会出现跨块截断多字节字符的情况。
                // 生产环境应考虑使用 Decoder。
                string chunk = encoding.GetString(buffer, 0, bytesRead);
                // 将上一次剩余的后缀拼接到当前块前面（因为是从后往前读）
                if (!string.IsNullOrEmpty(leftover))
                    chunk = chunk + leftover;

                // 按换行符分割，注意 Windows (\r\n)、Unix (\n)、Mac (\r) 三种换行符
                string[] linesInChunk = chunk.Split(new[] { "\r\n", "\n", "\r" }, StringSplitOptions.None);
                // 分割后数组最后一个元素可能是不完整行（在当前块的前部），将这一部分保存为 leftover
                if (linesInChunk.Length > 0)
                {
                    // 不完整的行是第一个元素（因为是从后往前读，块的开头是不完整行）
                    // 但是如果 chunk 恰好以换行符结尾，则第一个元素可能是空串
                    leftover = linesInChunk[0];
                    // 剩余的部分（除第一个外）按倒序压栈
                    for (int i = linesInChunk.Length - 1; i >= 1; i--)
                    {
                        if (lines.Count >= lineCount)
                            break;
                        lines.Push(linesInChunk[i]);
                    }
                }
                else
                {
                    leftover = chunk;
                }
            }

            // 如果最后 leftover 非空且还未收集够行数，说明这是文件的第一部分（即第一行）
            if (!string.IsNullOrEmpty(leftover) && lines.Count < lineCount)
            {
                lines.Push(leftover);
            }
        }

        // 将栈中行按顺序输出（栈的弹出顺序是倒序，但我们需要原始顺序
        // 我们压栈时是从后往前压入，所以弹出时是正序）
        var result = new List<string>(lines);
        result.Reverse(); // 因为栈先入后出，需要反转得到正确顺序
        return result;
    }
}

public static List<string> ReadLastLinesSimple(string filePath, int lineCount, Encoding encoding = null)
{
    if (lineCount <= 0) return new List<string>();
    if (encoding == null) encoding = Encoding.UTF8;

    List<string> lines = new List<string>();
    using (var fs = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read, 4096, FileOptions.SequentialScan))
    using (var reader = new StreamReader(fs, encoding, detectEncodingFromByteOrderMarks: true, bufferSize: 1024, leaveOpen: true))
    {
        // 先定位到文件末尾
        fs.Seek(0, SeekOrigin.End);
        long pos = fs.Position;
        int newlinesSeen = 0;
        char prevChar = '\0';
        while (pos > 0 && lines.Count < lineCount)
        {
            // 向前移动一个字符
            fs.Seek(--pos, SeekOrigin.Begin);
            int nextByte = fs.ReadByte();
            if (nextByte == -1) break;
            char c = (char)nextByte; // 仅对 ASCII/UTF-8 单字节有效，多字节可能出错。实际应用应使用 Decoder，这里简化说明。

            // 检测换行符：支持 \n 或 \r\n
            if (c == '\n')
            {
                newlinesSeen++;
            }
            else if (c == '\r' && prevChar != '\n') // 避免已经在 \r\n 中计数重复
            {
                newlinesSeen++;
            }
            prevChar = c;

            if (newlinesSeen >= lineCount)
                break;
        }
        // 计算读取的起始位置
        fs.Seek(pos, SeekOrigin.Begin);
        using (var sr = new StreamReader(fs, encoding, true))
        {
            string content = sr.ReadToEnd();
            string[] allLines = content.Split(new[] { "\r\n", "\n", "\r" }, StringSplitOptions.None);
            int skip = Math.Max(0, allLines.Length - lineCount);
            for (int i = skip; i < allLines.Length; i++)
                lines.Add(allLines[i]);
        }
    }
    return lines;
}

Install-Package ReverseLineReader

using ReverseLineReader;
var lines = FileReader.ReadLines("file.txt").TakeLast(10);