Multi-variable complicated singletons

Question

I have a pair of static fields with a complicated one-time initialization. I want this initialization to happen lazily, a la the standard singleton pattern.

However, the initialization procedure involves both fields, so I can't separate it into two different singletons.

What's the best way to handle this?

Answer 1

Create a wrapper class that contains the references to both your 'singletons' and make that class the singleton?

Addendum:
If you really want to avoid the second level of indirection with this approach, you can always do it in two stages:

• create a new singleton that encapsulates the individual singletons (original point)
• create a singleton for each of the original singletons (with separate backing fields) that is initialised from the combined singleton to guarantee that all singletons are initialised atomically

Answer 2

I'm currently doing it like this:

class OuterType {
    //...

    static class FieldInitializer {
        public static readonly SomeType field1, field2;

        static FieldInitializer() {
            //Complicated code that sets both fields together
        }
    }

    //...
}

Does anyone have any other ideas?

Answer 3

public class MyClass { private static MyClass _instance; private object _field1; private object _field2;

public object Field1
{
 get
 {
   lock(_instance)
   {
    if (_instance._field1 == null || _instance._field2 == null)
    _instance.Init();
   }
   return _instance.field1;
 }
}

public object Field2
{
 get
 {
   lock(_instance)
   {
    if (_instance._field1 == null || _instance._field2 == null)
    _instance.Init();
   }
   return _instance.field2;
 }
}

public static MyClass Instance
{
 get
 {
   if (_instance == null)
   _instance = new MyClass();
   return _instace;
 }
}

public void Init()
{/*Do Init Here*/}

}