11

I'm writing a WCF service in C#. Initially my implementation had a static constructor to do some one-time initialization, but some of the initialization that is being done might (temporarily) fail.

It appears that static constructors are only called once, even if the first (failed) attempt threw an exception? Any subsequent attempts to instantiate my class will immediately fail with a TypeInitializationException without the code actually being executed.

The C# language specification states that a static constructor is called at most once, but basically this makes an exception in there an error that you cannot ever recover from, even if you catch it?

Am I missing something here? I suppose I should move anything remotely dangerous to the service's instance constructor and manually check whether or not the class initialization was already succesfully completed earlier?

3 Answers 3

4

So you could wrap the critical parts in try/ catch and at least that means the type won't fail to initialize, but surely if the initialization code is that critical, then this behavior is actually good - the type is not usable in this uninitialized state.

The other option is to do it as a singleton - each time you try and get the Instance you can create the type correctly, until you are successful, even if it fails the first time.

You would still need some error handling on the caller in case Instance returns you null the first (or second etc.) time.

Edit: And if you don't want a singleton, then just have your instance constructor initialize the static parts

e.g.

private object _lock = new object()
private bool _initialized;

public T()
{
   lock(_lock)
   {
      if(!_initialized)
      {
         try
         {
           //Do static stuff here
         }
         catch(Exception ex_)
         {
           //Handle exception
         }
      } 
   }
}
Sign up to request clarification or add additional context in comments.

1 Comment

That's actually what I have now, except I use some double checked locking and my _initialized bool is volatile (should not be necessary without double checked locking)
4

The lesson here is pretty simple: don't do anything in a static constructor that could reasonably fail.

2 Comments

MSDN mentions the type will remain uninitialized, but I didn't immediately take this to mean that it would be impossible to ever create an instance. I would have expected a more explicit warning about this really. Not a huge deal to work around, but it does make static constructors a lot less useful :(
@Thorarin - only for the life time of AppDomain. type will remain uninitialized for the lifetime of the application domain in which your program is running from MSDN msdn.microsoft.com/en-us/library/k9x6w0hc.aspx
1

The workaround I used in the past is creating a Singleton. Make a static constructor fail if and only if the failure means the whole application can't run.

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.