Wie kann ich eine Textdatei lesen, ohne sie zu sperren?

Ich habe einen Windows-Dienst, der sein Protokoll in eine Textdatei in einem einfachen Format schreibt.

Jetzt werde ich eine kleine Anwendung erstellen, um das Protokoll des Dienstes zu lesen und sowohl das vorhandene als auch das hinzugefügte Protokoll als Live-Ansicht anzuzeigen.

Das Problem ist, dass der Dienst die Textdatei zum Hinzufügen der neuen Zeilen sperrt und gleichzeitig die Viewer-Anwendung die Datei zum Lesen sperrt.

Der Service Code:

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

Der Viewer-Code:

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

Gibt es ein Problem in meinem Code beim Lesen und Schreiben?

Wie löse ich das Problem?

Sie müssen sicherstellen, dass sowohl der Dienst als auch der Leser die Protokolldatei nicht ausschließlich öffnen. Versuche dies:

Verwenden Sie für den Dienst - den Writer in Ihrem Beispiel - eine FileStreamInstanz, die wie folgt erstellt wurde:

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

Verwenden Sie für den Leser dasselbe, ändern Sie jedoch den Dateizugriff:

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

Da FileStreamImplementierungen IDisposablesicherstellen, dass Sie in beiden Fällen eine usingAnweisung verwenden, z. B. für den Writer:

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

Viel Glück!

Richten Sie den Freigabemodus explizit ein, während Sie die Textdatei lesen.

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

-> Dadurch wird die Datei nicht gesperrt.

Das Problem ist, dass Sie beim Schreiben in das Protokoll die Datei ausschließlich sperren, damit Ihr StreamReader sie überhaupt nicht öffnen kann.

Sie müssen versuchen, die Datei im schreibgeschützten Modus zu öffnen .

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
        }
    }
}

Ich erinnere mich, dass ich vor ein paar Jahren dasselbe getan habe. Nach einigen Google-Anfragen fand ich Folgendes:

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

Verwenden Sie also das FileShare.ReadWrite-Attribut in FileStream ().

(gefunden auf Balaji Rameshs Blog )

Haben Sie versucht, die Datei zu kopieren und dann zu lesen?

Aktualisieren Sie einfach die Kopie, wenn große Änderungen vorgenommen werden.

Mit dieser Methode können Sie eine Textdatei am schnellsten lesen, ohne sie zu sperren.

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 "";
        }
    }

Hoffe, diese Methode wird Ihnen helfen.