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);