/// <summary>
 /// 從后往前讀取文件最后行數(shù)據(jù)
 /// </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>
    /// 從文件末尾向前讀取指定行數(shù)，返回按原始順序（從上到下）的行列表。
    /// </summary>
    /// <param name="filePath">文件路徑</param>
    /// <param name="lineCount">需要讀取的行數(shù)（倒數(shù)第N行）</param>
    /// <param name="encoding">文件編碼，默認UTF-8</param>
    /// <returns>行列表，順序為從倒數(shù)第N行到最后一行；若文件行數(shù)不足 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;
                // 從緩沖區(qū)末尾向前掃描
                for (int i = bytesRead - 1; i >= 0 && lines.Count < lineCount; i--)
                {
                    // 處理跨塊情況：上一個塊的結(jié)尾與當(dāng)前塊開頭需正確合并，
                    // 但簡單實現(xiàn)中通過保留上次未完成的行內(nèi)容實現(xiàn)，為簡化，采用累計行區(qū)分方法。
                    // 更穩(wěn)健的方式：將掃描到的行暫存至臨時列表，最后反轉(zhuǎn)。
                }
                // 上述逐字節(jié)掃描比較繁瑣，通常采用另一種策略：
                // 通過檢測換行符來分割行，同時記錄完整行內(nèi)容。
                // 下面用更清晰的方式：從后向前累積字符，遇到換行符時分割。
                // 為避免代碼冗長，改用直接累積塊的方式：
                // 已經(jīng)有很多標(biāo)準(zhǔn)實現(xiàn)，我將重寫一個更清晰的版本。
            }
        }
        // 為了代碼簡潔，采用另一種更常見也更易理解的實現(xiàn)：
        // 使用 StreamReader 配合 Seek 定位，但效率稍低。
        // 以下給出兩套方案，推薦使用第一套（基于字節(jié)掃描 + 手動解碼），
        // 但為了可讀性，第二套方案（基于 StreamReader 部分讀?。└菀桌斫?，
        // 且對于大多數(shù)文件已足夠高效。
        // 實際生產(chǎn)推薦使用開源庫或自己實現(xiàn)可靠的緩沖區(qū)掃描。下面給出完整實現(xiàn)的最終版本。
    }
}

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

public static class ReverseFileReader
{
    /// <summary>
    /// 從文件末尾反向讀取指定行數(shù)。
    /// </summary>
    /// <param name="filePath">文件路徑</param>
    /// <param name="lineCount">需要讀取的行數(shù)（倒數(shù)最后 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>(); // 用棧暫存，最后彈出恢復(fù)順序

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

            // 從文件末尾附近開始，每次向前讀取一塊數(shù)據(jù)，并從中解析出完整的行
            long position = fileSize;
            int bufferSize = 4096;
            byte[] buffer = new byte[bufferSize];
            // 用于存儲跨塊的不完整行（從后向前拼接時，當(dāng)前塊開頭可能是不完整的尾部）
            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);

                // 解碼當(dāng)前塊（注意：可能跨塊導(dǎo)致編碼問題，此處簡化處理，假設(shè)文件是單字節(jié)或 UTF-8 對齊）
                // 更好的做法是使用 Decoder，但為簡潔，這里假設(shè)不會出現(xiàn)跨塊截斷多字節(jié)字符的情況。
                // 生產(chǎn)環(huán)境應(yīng)考慮使用 Decoder。
                string chunk = encoding.GetString(buffer, 0, bytesRead);
                // 將上一次剩余的后綴拼接到當(dāng)前塊前面（因為是從后往前讀）
                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);
                // 分割后數(shù)組最后一個元素可能是不完整行（在當(dāng)前塊的前部），將這一部分保存為 leftover
                if (linesInChunk.Length > 0)
                {
                    // 不完整的行是第一個元素（因為是從后往前讀，塊的開頭是不完整行）
                    // 但是如果 chunk 恰好以換行符結(jié)尾，則第一個元素可能是空串
                    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 非空且還未收集夠行數(shù)，說明這是文件的第一部分（即第一行）
            if (!string.IsNullOrEmpty(leftover) && lines.Count < lineCount)
            {
                lines.Push(leftover);
            }
        }

        // 將棧中行按順序輸出（棧的彈出順序是倒序，但我們需要原始順序
        // 我們壓棧時是從后往前壓入，所以彈出時是正序）
        var result = new List<string>(lines);
        result.Reverse(); // 因為棧先入后出，需要反轉(zhuǎn)得到正確順序
        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 單字節(jié)有效，多字節(jié)可能出錯。實際應(yīng)用應(yīng)使用 Decoder，這里簡化說明。

            // 檢測換行符：支持 \n 或 \r\n
            if (c == '\n')
            {
                newlinesSeen++;
            }
            else if (c == '\r' && prevChar != '\n') // 避免已經(jīng)在 \r\n 中計數(shù)重復(fù)
            {
                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);