C＃“缓存调试日志”

Question

I'd like to ask the C# experts here for an advice. I have an issue with my debug log. I have a simple class that just opens a file, writes the provided string down and closes the file again. However, sometimes I need to use this debug log while I'm using the multithreading. Thereby the troubles come. I can't have the file opened more than once, so I recieve an exception because I simply try to open the locked file again. For this purpose I'd like to have something like a "cached debug log" which would prevent this exception. Is there any easy way to implement this? Thanks a lot in advance.

Answer 1

C# 4.0 provides thread-safe collections like System.Collections.Concurrent.ConcurrentQueue<T> . You could modify your logging class such that it runs in its own thread, and calls to log methods just add the message to such a queue. That way, your logging thread can just read items out of the queue safely, and write to the file without interruption.

EDIT

Of course, the most expedient thing to do is to start using a pre-existing logging framework that already has this stuff taken care of. I'd recommend NLog, though log4net is a worthy contender as well.

Answer 2

This is generally done by having a singleton logger that you call from all parts of your code; the logger is the only thing that accesses the file directly. There are a number of frameworks already in existence (nlog, log4net, enterprise library) that do this for you.

Answer 3

You might want to check out .NET Tracing. I prefer just using the built in TraceSource classes vs using a 3rd party logging framework like nlog. I used to go down the road of even writing a facade around nlog, but then it seems rather silly to have so many dependencies and so many layers of abstraction, just to write a log message.

You can see an overview of TraceSource here: http://msdn.microsoft.com/en-us/library/system.diagnostics.tracesource.aspx

The idea is that you separate out the tracing from listening. Throughout your code, you can add trace calls, each with different log levels (Error, Verbose, Debug) and different sources. In your application configuration, you then configure different listeners.

<system.diagnostics>
    <sources>
      <source name="Source1" switchName="verboseSwitch">
        <listeners>
          <add name="console" />
        </listeners>
      </source>
      <source name="Source2" switchName="warningSwitch">
        <listeners>
          <add name="console" />
        </listeners>
      </source>
    </sources>
    <switches>
      <add name="verboseSwitch" value="Verbose" />
      <add name="warningSwitch" value="Information" />
    </switches>
    <sharedListeners>
      <add name="console" type="System.Diagnostics.ConsoleTraceListener" initializeData="false"/>
    </sharedListeners>
    <trace autoflush="true" indentsize="4">
      <listeners>
        <add name="console" />
      </listeners>
    </trace>
  </system.diagnostics>


public void MethodOne()
{
     TraceSource ts = new TraceSource("Source1");

     ts.TraceEvent(TraceEventType.Verbose, 0, "Called MethodOne");

     // do something that causes an error
     ts.TraceEvent(TraceEventType.Error, 0, "MethodOne threw an error");
}

Here, MethodOne is set up to use the source "Source1". Source1 is currently configured above to listen to anything Verbose and higher. So this means that

Called MethodOne
MethodOne threw an error 

will both be written to the console

public void MethodTwo()
{
     TraceSource ts = new TraceSource("Source2");

     ts.TraceEvent(TraceEventType.Verbose, 0, "Called MethodTwo");

     // do something that causes a error
     ts.TraceEvent(TraceEventType.Error, 0, "MethodTwo threw an error");
}

Here though, MethodTwo is configured to use Source2, which is only set up to listen to Warning and above.

So, when the code runs, the output will be

MethodTwo threw an error

What this allows you to do is control how much information you want to see for different parts of your program. Perhaps if one day you start seeing errors in some library, you can turn the trace source for that library to verbose, and now see all your debugging information, without being overwhelmed with data from other parts of the program.

I use different listeners like this to control the flow of critical errors. I have listeners for certain sources and certain error levels that will email me the moment an error gets written to the log. I don't care about 404 errors, but I do care about anything that happens in the registration code, for example.

You have the ConsoleTraceListener for writing to the console/debug window The FileLogTraceListener for writing to files Even the EventLogTraceListener

You can see the full list of built in listeners here

Then there are third party listeners for sending emails on log events, storing in the database, writing to Azure table storage, etc.

You can of course accomplish all of this with a framework like NLog. The .NET Trace methods are high performance and used all over the .NET Framework. You can't go wrong choosing it IMHO.