C#：从基类静态方法确定派生对象类型

Question

在 C# 程序中，我有一个带有静态“Create”方法的抽象基类。 Create 方法用于创建类的实例并将其存储在本地以供以后使用。 由于基类是抽象的，因此实现对象将始终从它派生。

我希望能够从基类派生一个对象，通过派生类调用静态 Create 方法（在基类中实现一次），并创建派生对象的实例。

C# 语言中是否有任何工具可以让我完成此任务。 我当前的后备位置是将派生类的实例作为参数之一传递给 Create 函数，即：

objDerived.Create(new objDerived(), "Arg1", "Arg2");

Answer 1

尝试使用泛型：

public static BaseClass Create<T>() where T : BaseClass, new()
{
    T newVar = new T();
    // Do something with newVar
    return T;
}

示例使用：

DerivedClass d = BaseClass.Create<DerivedClass>();

Answer 2

摘要

有两个主要选项。 更好、更新的一种是使用泛型，另一种是使用反射。 如果您需要开发一个在 .NET 2.0 之前运行的解决方案，我将提供这两种解决方案。

泛型

abstract class BaseClass
{
  public static BaseClass Create<T>() where T : BaseClass, new()
  {
    return new T();
  }
}

的用法是：

DerivedClass derivedInstance = BaseClass.Create<DerivedClass>();

反射

abstract class BaseClass
{
  public static BaseClass Create(Type derivedType)
  {
    // Cast will throw at runtime if the created class
    // doesn't derive from BaseClass.
    return (BaseClass)Activator.CreateInstance(derivedType);
  }
}

的用法是（为了可读性分为两行）：

DerivedClass derivedClass
    = (DerivedClass)BaseClass.Create(typeof(DerivedClass));

Answer 3

您想在派生的另一个实例中创建一个新的派生实例，使用抽象基类上的静态工厂方法吗？ 如果是这样，我想知道为什么......但是......

 public abstract class MyBase
 {
    public static T GetNewDerived<T>() where T : MyBase, new()
    {
        return new T();
    }    
 }
 public class DerivedA : MyBase
 {
    public static DerivedA GetNewDerived()
    {
        return GetNewDerived<DerivedA>();
    }
 }

 public class DerivedB : MyBase
 {
    public static DerivedB GetNewDerived()
    {
        return GetNewDerived<DerivedB>();
    }
 }     

这是你想要的吗？

Answer 4

听起来您需要使 Create() 方法抽象。 一旦你这样做了，你也可以重命名它并使其成为构造函数。 然后，如果需要，您可以在构造对象后调用不同的 Init() 方法，并且正常的多态性效果将处理这些事情。

Answer 5

没有外部信息你就无法做到这一点； 派生类的类型、派生类的实例或派生类的完全限定名称。 其中任何一个都相当于你已经在做的事情； 据我所知，没有更好的解决方案。 静态方法的本质不允许任何更优雅的方法。

Answer 6

我不确定你的设计目标是什么，但从你的要求来看，听起来它可能最终会产生很多代码味道。 我认为您应该真正研究一下在 Microsoft Unity、Castle Windsor、StructureMap、Ninject、Spring.Net 等众多框架中实现的控制反转 (IoC)/依赖注入 (DI) 设计模式。

我认为，如果您考虑使用 IoC 容器，它将以更清晰和松散耦合的方式解决您的问题。