Question

我有一个类，定义为：

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

我想在其他地方定义那些通用单例的数组。像

这样的东西

public MonoSingleton[] singletons;

如何检索该泛型的正确类型（似乎是递归的，如您所见）？我该怎么写出来？

Answer 1

您是否正在尝试执行'奇怪的递归模板模式'，就像这样？

class CuriouslyRecursiveBase<T>
{

}

class CuriouslyRecursiveDervied<T> : CuriouslyRecursiveBase<T>
{

}

class MyClass : CuriouslyRecursiveBase<MyClass>
{

}

要实例化从基础派生的派生，只需使用：

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

由于T实际上是派生类型（MyClass），并且奇怪地也是类型（CuriouslyRecursive<MyClass>）。

专门适用于您的问题：

// 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();
}

更多信息：

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

Answer 2

使用设计时代码，您将能够通过使用typeof运算符并为泛型参数提供一些参数来获取类型：

typeof(Singleton<SomeImplementationOfBaseObject>)

或

typeof(Singleton<>)

但还有另一种选择：反思。

Type singletonType = Type.GetType("NamespaceA.NamespaceN.Singleton`1");

1部分是通用参数的数量。如果你有类似Class<T, S>的东西，它就会是2，依此类推。

请注意，使用反射您不需要提供通用参数。无论如何，您可以使用泛型参数获取类型。为了给出泛型参数，你可以这样做：

Type genericType = singletonType.MakeGenericType(typeof(SomeImplementationOfBaseObject));

或者如果你想直接获得它，你会这样做：

Type singletonType = Type.GetType("NamespaceA.NamespaceN.Singleton`1[[NamespaceA.NamespaceN.SomeImplementationOfBaseObject]]");

[[ ]]内的字符串是作为泛型参数传递的类型的全名。请注意，如果泛型类型与执行类型不同，则需要提供程序集限定名称（例如，，“NamespaceA.MyClass，MyAssembly”）。

更新

OP在一些评论中表示：

如果我使用：公共Singleton<BaseObject>[]单身人士;它会警告我 with：'错误CS0309：类型BaseObject'必须可转换为 Singleton'以便将其用作参数'T' 泛型类型或方法'Singleton'

这是另一个问题：你不能在课堂上做协方差。要做这样的事情，你需要一个这样的界面：

public interface ISingleton<out TBaseObject> where TBaseObject : .........

让Singleton<T>类实现它。

因此，您可以这样创建这样的数组：

public ISingleton<BaseObject>[] singletons;

协方差允许您转发通用参数，它仅限于接口和委托。

在此处了解详情：

http://msdn.microsoft.com/en-us/library/ee207183.aspx

获取“递归泛型”的类型？

2 个答案:

更新