CODEWITHSUNDEEP
c#filelockingstreamwriter
Greg
Greg

Reputation: 157

Streamwriter Lock Not Working

I'm taking over a C# project, and when testing it out I'm getting errors. The error is that the log file cannot be written to because it is in use by another process. Here's the code:

    public void WriteToLog(string msg)
    {
        if (!_LogExists) 
        {
            this.VerifyOrCreateLogFile();  // Creates log file if it does not already exist.
        }

        // do the actual writing on its own thread so execution control can immediately return to the calling routine.
        Thread t = new Thread(new ParameterizedThreadStart(WriteToLog));
        t.Start((object)msg);
    }

    private void WriteToLog(object msg)
    {
        lock (_LogLock)
        {
            string message = msg as string;
            using (StreamWriter sw = File.AppendText(LogFile))
            {
                sw.Write(message);
                sw.Close();
            }
        }
    }

_LogLock is defined as a class variable:

    private object _LogLock = 0;

Based on my research and the fact that this has been working fine in a production system for a few years now, I don't know what the problem could be. The lock should prevent another thread from attempting to write to the log file.

The changes I've made that need to be tested are a lot more log usage. We're basically adding a debug mode to save much more info to the log than used to be saved.

Thanks for any help!

EDIT:

Thanks for the quick answers! The code for VerifyOrCreateLogFile() does use the _LogLock, so that shouldn't be an issue. It does do some writing to the log before it errors out, so it gets past creating the file just fine.

What seems to be the problem is that previously only one class created an instance of the log class, and now I've added instances to other classes. It makes sense that this would create problems. Changing the _LogLock field to be static fixes the issue.

Thanks again!

Upvotes: 4

Views: 2458

Answers (4)

Mayur Dighe
Mayur Dighe

Reputation: 1

you can do the code executable by simply

removing sw.Close(); from your code ...

do it.... it will work fine.....

Upvotes: 0

Yahia
Yahia

Reputation: 70369

I see 2 problems with the code:

  • Lock must be the same among all "users" of ths Log class, easiest solution is to make either _LogLock or the complete class static
  • VerifyOrCreateLogFile could pose a problem if 2 or more parallel threads call WriteToLog when _LogExists is false...

Upvotes: 2

Reed Copsey
Reed Copsey

Reputation: 564383

The lock should prevent another thread from attempting to write to the log file.

This is only true if you're using a single instance of this class.

If each (or even some) of the log requests use a separate instance, then the lock will not protect you.

You can easily "correct" this by making the _LogLock field static:

private static object _LogLock = 0;

This way, all instances will share the same lock.

Upvotes: 7

jason
jason

Reputation: 241611

One possibility is that the OS isn't releasing the file lock quickly enough before you exit the lock in WriteToLog and another thread that was blocked waiting for the lock tried to open it before the OS finished releasing the file lock. Yes, it can happen. You either need to sleep for a little before trying to open the file, centralize the writing to the log to a dedicated object (so that he and only he has access to this file and you don't have to worry about file lock contentions).

Another possibility is that you need to lock around

if (!_LogExists)  {
    this.VerifyOrCreateLogFile();  // Creates log file if it does not already exist.
}

The third possibility is that you have multiple instances of whatever class is housing these methods. The lock object won't be shared across instances (make it static to solve this).

At the end of the day, unless you're an expert in writing safe multi-threaded code, just let someone else worry about this stuff for you. Use a framework that handles these issues for you (log4net?).

Upvotes: 1

Related Questions