Come posso leggere un file di testo senza bloccarlo?

Ho un servizio Windows che scrive il suo registro in un file di testo in un formato semplice.

Ora creerò una piccola applicazione per leggere il registro del servizio e mostrare sia il registro esistente che quello aggiunto come visualizzazione live.

Il problema è che il servizio blocca il file di testo per l'aggiunta delle nuove righe e allo stesso tempo l'applicazione visualizzatore blocca il file per la lettura.

Il codice del servizio:

void WriteInLog(string logFilePath, data)
{
    File.AppendAllText(logFilePath, 
                       string.Format("{0} : {1}\r\n", DateTime.Now, data));
}

Il codice del visualizzatore:

int index = 0;
private void Form1_Load(object sender, EventArgs e)
        {
            try
            {
                using (StreamReader sr = new StreamReader(logFilePath))
                {
                    while (sr.Peek() >= 0)  // reading the old data
                    {
                        AddLineToGrid(sr.ReadLine());
                        index++;
                    }
                    sr.Close();
                }

                timer1.Start();
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }


private void timer1_Tick(object sender, EventArgs e)
        {
            using (StreamReader sr = new StreamReader(logFilePath))
            {
                // skipping the old data, it has read in the Form1_Load event handler
                for (int i = 0; i < index ; i++) 
                    sr.ReadLine();

                while (sr.Peek() >= 0) // reading the live data if exists
                {
                    string str = sr.ReadLine();
                    if (str != null)
                    {
                        AddLineToGrid(str);
                        index++;
                    }
                }
                sr.Close();
            }
        }

C'è qualche problema nel mio codice in lettura e scrittura?

Come risolvere il problema?

È necessario assicurarsi che sia il servizio che il lettore aprano il file di registro in modo non esclusivo. Prova questo:

Per il servizio, il writer nel tuo esempio, utilizza FileStreamun'istanza creata come segue:

var outStream = new FileStream(logfileName, FileMode.Open, 
                               FileAccess.Write, FileShare.ReadWrite);

Per il lettore usa lo stesso ma cambia l'accesso ai file:

var inStream = new FileStream(logfileName, FileMode.Open, 
                              FileAccess.Read, FileShare.ReadWrite);

Inoltre, poiché FileStreamimplements IDisposableassicurati che in entrambi i casi consideri l'utilizzo di usingun'istruzione, ad esempio per l'autore:

using(var outStream = ...)
{
   // using outStream here
   ...
}

In bocca al lupo!

Impostazione esplicita della modalità di condivisione durante la lettura del file di testo.

using (FileStream fs = new FileStream(logFilePath, 
                                      FileMode.Open, 
                                      FileAccess.Read,    
                                      FileShare.ReadWrite))
{
    using (StreamReader sr = new StreamReader(fs))
    {
        while (sr.Peek() >= 0) // reading the old data
        {
           AddLineToGrid(sr.ReadLine());
           index++;
        }
    }
}

new StreamReader(File.Open(logFilePath, 
                           FileMode.Open, 
                           FileAccess.Read, 
                           FileShare.ReadWrite))

-> questo non blocca il file.

Il problema è che quando scrivi nel log stai bloccando esclusivamente il file in modo che il tuo StreamReader non possa aprirlo affatto.

Devi provare ad aprire il file in modalità di sola lettura .

using (FileStream fs = new FileStream("myLogFile.txt", FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
    using (StreamReader sr = new StreamReader(fs))
    {
        while (!fs.EndOfStream)
        {
            string line = fs.ReadLine();
            // Your code here
        }
    }
}

Ricordo di aver fatto la stessa cosa un paio di anni fa. Dopo alcune domande su Google ho trovato questo:

    FileStream fs = new FileStream(@”c:\test.txt”, 
                                   FileMode.Open, 
                                   FileAccess.Read,        
                                   FileShare.ReadWrite);

cioè usa l'attributo FileShare.ReadWrite su FileStream ().

(trovato sul blog di Balaji Ramesh )

Hai provato a copiare il file e poi a leggerlo?

Aggiorna la copia ogni volta che vengono apportate modifiche importanti.

Questo metodo ti aiuterà a leggere più velocemente un file di testo e senza bloccarlo.

private string ReadFileAndFetchStringInSingleLine(string file)
    {
        StringBuilder sb;
        try
        {
            sb = new StringBuilder();
            using (FileStream fs = File.Open(file, FileMode.Open))
            {
                using (BufferedStream bs = new BufferedStream(fs))
                {
                    using (StreamReader sr = new StreamReader(bs))
                    {
                        string str;
                        while ((str = sr.ReadLine()) != null)
                        {
                            sb.Append(str);
                        }
                    }
                }
            }
            return sb.ToString();
        }
        catch (Exception ex)
        {
            return "";
        }
    }

Spero che questo metodo ti possa aiutare.