Как прочитать последнюю строку из файла csv с помощью метода ReadLineAsync?

Медленный (но надежный) метод — прочитать все строки файла и вернуть последнюю. Что-то вроде:

static string? GetLastLine(string filename)
{
    using StreamReader reader = new(filename);
    string? last = null;
    while (reader.ReadLine() is string line)
        last = line;
    return last;
}

Конечно, при этом без уважительной причины выделяется много строк, и сборщику мусора вскоре после этого придется избавиться от них всех. Не идеально, но так оно и есть. (Версия async достаточно проста в изготовлении, но она занимает несколько мс на МБ. На ваше усмотрение.)

Чтобы ускорить работу, вы можете попробовать просто прочитать последнюю часть файла — достаточную, чтобы получить пару строк — и обработать ее. Для этого вам нужно знать максимальную длину строки, чтобы гарантировать, что вы получите хотя бы одну полную строку. Предполагая, что вы работаете с данными ASCII или UTF8, вы, вероятно, можете сделать что-то вроде этого:

static string? GetLastLine(string filename, int maxLineLength)
{
    using Stream stream = File.OpenRead(filename);
    stream.Position = stream.Length - maxLineLength * 3 / 2;
    using StreamReader reader = new(stream);
    string? last = null;
    while (reader.ReadLine() is string line)
        last = line;
    return last;
}

(Это должно работать за достаточно постоянное время, независимо от размера файла, поскольку оно всегда будет обрабатывать один и тот же объем данных — около 100 микросекунд на моей машине для файла размером 1 МБ с использованием maxLineLength = 150. Опять же, преобразование в версию async просто.)

И, наконец, если вы ожидаете, что строки будут добавляться в файл с течением времени, и вы хотите просто прочитать новые строки из файла, отслеживайте размер файла и возобновляйте чтение оттуда, когда размер файла изменится.

Как указано в комментариях, вышеизложенное не особенно полезно, если вы хотите читать новые строки, поступающие из-за пределов вашей программы. Он не только всегда возвращает последнюю строку файла, независимо от изменений, но и если добавлено несколько строк, вы получите только последнюю. Почти наверняка это не то, что вы хотите.

Вероятно, вам нужен способ читать новые строки по мере их поступления и не пропускать новые строки. Это означает отслеживание изменений длины файла и возобновление чтения по одной строке за раз. Вы не хотите блокировать файл слишком долго, и поскольку StreamReader буферизируется впереди, вы не можете рассчитывать на то, что stream.Position выровняется с концом строки, которую вы только что прочитали.

Решение состоит в том, чтобы каждый раз читать все возможные строки и сохранять их для последующего чтения. Мы можем помещать новые строки в Queue<> и отслеживать размер файла, чтобы определить, когда есть что прочитать. Что-то вроде этого:

sealed class LineReader
{
    // File to read from.
    private readonly string _filename;
    
    // Queue for when multiple new lines are added between reads.
    private readonly Queue<string> _queue = new();
    
    // Length of file after last read.
    private long _lastPosition;
    
    // True if there's something to read.
    public bool LinesAvailable
    {
        get 
        {
            if (_queue.Count > 0)
                return true;
            FileInfo fi = new(_filename);
            return fi.Exists && fi.Length != _lastPosition;
        }
    }
    
    public LineReader(string filename, bool readExistingLines = false)
    {
        _filename = filename;
        FileInfo fi = new(_filename);
        _lastPosition = readExistingLines || !fi.Exists ? 0 : fi.Length;
    }
    
    // Returns when a line is read or token is cancelled.
    public async Task<string?> WaitNextLineAsync(CancellationToken token)
    {
        while (!token.IsCancellationRequested)
        {
            if (_queue.TryDequeue(out string? queued))
                return queued;
            if (await GetNextLineAsync() is string line)
                return line;
            try
            {
                await Task.Delay(20, token);
            }
            catch (TaskCanceledException)
            {
                break;
            }
        }
        return null;
    }
    
    // Read next line, or `null` if none available.
    public async Task<string?> GetNextLineAsync()
    {
        if (_queue.TryDequeue(out string? line))
            return line;
        
        // Check if file length has changed.
        FileInfo fi = new(_filename);
        if (!fi.Exists || fi.Length == _lastPosition)
            return null;
        
        // Open the stream. May fail if file is locked.
        Stream stream;
        try
        {
            stream = fi.OpenRead();
        }
        catch 
        {
            return null;
        }
        
        using (stream)
        {
            // If file is smaller assume it was cleared, read all lines.
            // Otherwise, go to our last position.
            if (stream.Length >= _lastPosition)
                stream.Position = _lastPosition;
            
            using StreamReader reader = new(stream);
            
            // Queue up new lines
            while (await reader.ReadLineAsync() is string next)
            {
                // Ignore empty lines.
                if (!string.IsNullOrEmpty(next))
                    _queue.Enqueue(next);
            }
        }
            
        // Update state and return the last read line if not empty.
        _lastPosition = stream.Length;
        _queue.TryDequeue(out line);
        return line;
    }
}

GetNextLineAsync() пытается получить следующую доступную строку, WaitNextLineAsync(...) вращается асинхронно, пока строка не будет прочитана. Отмена завершается вместо броска, что удобно, если вы хотите предоставить тайм-аут с помощью токена CancelAfter:

async Task ProcessNextLineAsync(LineReader reader, CancellationToken token)
{
    CancellationTokenSource source = CancellationTokenSource.CreateLinkedTokenSource(token);
    source.CancelAfter(TimeSpan.FromSeconds(1));

    if (await LineReader.WaitNextLineAsync(source.Token) is string line)
    {
        // do something with the line
    }
}

(Да, я мог бы сделать гораздо более простую версию. Хотя вы просили async.)

ПРИМЕЧАНИЕ. Это не является потокобезопасным.