Question

I do have a class, which is defined as:

public abstract class Singleton <T> : BaseObject
    where T : Singleton <T>
{
}

I want to define an array of those generic singletons somewhere else. Something like

public MonoSingleton[] singletons;

How can I retrieve the proper type of that generic (that seems to be recursive, as you may see)? How can I write this out?

Answer 1

Are you trying to do the ‘curiously recursive template pattern’, like this?

class CuriouslyRecursiveBase<T>
{

}

class CuriouslyRecursiveDervied<T> : CuriouslyRecursiveBase<T>
{

}

class MyClass : CuriouslyRecursiveBase<MyClass>
{

}

To instantiate the derived from the base, you just use:

class CuriouslyRecursiveBase<T>
{
    public static void InstantiateDerived()
    {
        T instance = (T)Activator.CreateInstance(typeof(T));
    }
}

Since T is actually the derived type (MyClass) and curiously is also type (CuriouslyRecursive<MyClass>).

Specifically applied to your problem:

// Create a common interface that all singletons use. This allows 
// us to add them all to a list.
interface ISingleton { }

class Singleton<T> : ISingleton
{
    // Store our list of ISingletons
    static List<ISingleton> instances = new List<ISingleton>();
    static T instance;

    protected Singleton() { }

    public static T GetInstance()
    {
        // Either return the existing instnace, or create a new one
        if (Singleton<T>.instance == null)
        {
            Singleton<T>.instance = (T)Activator.CreateInstance(typeof(T));

            // Use a common interface so they can all be stored together.
            // Avoids the previously mentioned co-variance problem.
            // Also, compiler isn't built to follow curious recursiveness,
            // so use a dynamic statement to force runtime re-evaluation of 
            // the type hierarchy. Try to avoid dynamic statements in general
            // but in this case its useful.
            instances.Add((dynamic)Singleton<T>.instance);
        }

        return Singleton<T>.instance;
    }
}

class MyClass : Singleton<MyClass>
{

}

public static void Main()
{
    MyClass my = MyClass.GetInstance();
}

More info:

http://en.wikipedia.org/wiki/Curiously_recurring_template_pattern