0

抽象类：

abstract class PersistentList<T>

public static PersistentList<T> GetInstanceOfDerivedClass()
{
    //???
}

派生类：

public class Managers : PersistentList<Manager>

所以，我想：

Managers managers = Managers.GetInstanceOfDerivedClass();

那可能吗？

选择是：

int clientID = 3;

Managers managers = Managers.For("Client", new { ClientID = clientID});

Managers managers = new Managers(new { ClientID = clientID });

Managers managers = new Managers();
managers.ClientID = clientID;
managers.Load("ForClient");
//alternatively:
Database.Load(managers, "ForClient");

//this works, however requires the above code in the constructor.
Managers managers = new Managers(clientID);

//If the static method on the abstract class (Managers.For) could determine
//the type calling, it would eliminate the need for repetitive constructors.

以上都是可以的，只是想决定一个好的技术。

4

4 回答 4

0

你不能用静态方法来做到这一点。我不知道你为什么想要，但你可以这样做

    public abstract class PersistentList<T>
    {
        public PersistentList<T> GetInstanceOfDerivedClass()
        {
            return (PersistentList<T>)Activator.CreateInstance(this.GetType());
        }
    }

用法

Managers managers = (Managers)new Managers().GetInstanceOfDerivedClass();
于 2012-06-24T22:18:58.893 回答
0

如果您需要强类型，我认为这是最简单的（即该方法将返回Managers，而不仅仅是PersistentList<Manager>在请求 a 时Managers）：

static class PersistentList
{
    public static T GetInstanceOfDerivedClass<T, U>() where T : PersistentList<U>
    {
        throw new NotImplementedException();
    }
}

Managers managers = PersistentList.GetInstanceOfDerivedClass<Managers, Manager>();

你也可以这样做：

abstract class PersistentList<T, U> where T : PersistentList<T, U>
{
    public static T GetInstanceOfDerivedClass()
    {
        throw new NotImplementedException();
    }
}
public class Managers : PersistentList<Managers, Manager>
{
}

这使您可以在示例中使用签名，Managers.GetInstanceOfDerivedClass(). 然而，我发现这种设计模式令人困惑，并且不鼓励使用它。

于 2012-06-24T23:15:47.433 回答
0

这似乎是一个奇怪的情况，但假设你以某种方式受限于这种模式，这是我能想到的最接近的事情（仍然不完全是你想要做的）：

abstract class PersistentList<T>
{
    public static T2 GetInstanceOfDerivedClass<T2>() where T2 : PersistentList<T>
    {
        return (T2)Activator.CreateInstance(typeof(T2));
    }
}

class Manager { }

class Managers : PersistentList<Manager> { }

用法：

Managers managers = PersistentList<Manager>.GetInstanceOfDerivedClass<Managers>();
于 2012-06-24T23:33:13.227 回答
0

可以使用您描述的模式，但在某些情况下，让工厂方法成为非泛型静态类中的泛型方法可能很有用，特别是如果该方法将采用任何可用于类型推断的参数。例如，如果一个人有一种方法来创建一个新集合，该方法最初是从 a 填充的T[]，在某些情况下它可能SuperCollection<T> SuperCollection.Create<T>(T InitialValues[])比更方便使用SuperCollection<T> SuperCollection<T>.Create(T InitialValues[])，因为前者可以根据类型自动推断要创建的集合的类型数组参数。

除此之外，我认为在创建的对象类型可能取决于编译时可能不知道的各种因素的情况下，您所描述的模式是一个完全合理的模式。

于 2012-06-25T18:01:51.133 回答