How to automatically call a method in a static class on application start up and close down?

Question

I'm writing a static class for logging to be used across my developed solution. There are several components that will use it such as a console application, ASP.NET application, etc...

For the logging to work, it needs to do some initial startup configuration before it can be used, and also some clean up when each application has finished.

Is there a way to do this in .NET without having to expicitly call a StartLog() and FinishLog() method from each application in the solution? Or perhaps a different way of looking at this entirely?

I've been thinking about using locks in each Log() method to check whether the logging class has been initialised, however the potential overhead both in performance and complexity scares me.

Answer 1

You can use a type initializer (e.g. a static constructor) for the startup side of things - that will automatically be called when you first use the class.

Detecting shutdown is harder... there's AppDomain.ProcessExit and AppDomain.DomainUnload which might be enough for you... just subscribe to the events and react accordingly.

Answer 2

Read up on singletons, Jon Skeet has a great article. Using this you can ensure the type is constructed only once. Have a look at the end when he talks about the performance of the locks. Just some food for thought.

Answer 3

A singleton pattern whereby you are not re-instantiating the Log class each time but using a getInstance() method would work

Answer 4

Singleton pattern would probably work best for you. The static _instance variable is initialized in the start so its Log() constructor is called and you can do the initialization here. As it implements IDisposable and overrides Finalize it will have Dispose() method which would be called when the application exits and the static instance variable is disposed.

public class Log : IDisposable {
  private Log() {
    // Initialize logic
  }

  public LogMessage(string wah) {
    // Write
  }

  public void Dispose() {
    // Clean up
  }

  public override void Finalize() {
    Dispose();
  }

  private static Log _instance = new Log();
  public static Log Instance { get { return _instance; } }

  // You can also implement helper methods on static level if you want to keep the usage same.
  public static Message(string wah) {
    _instance.LogMessage(wah);
  }
}