C# 在没有if语句的情况下，如何在运行时根据继承类推断基类中的类型？

我有个小问题

abstract class MyAbstractBaseClass
{    
   MyHelperClassBase myHelperBaseClass;

   protected method foo()
   {
       //QUESTION....... :  when I am here I want to do this...

       myHelperBaseClass = new MyHelperSubClass(); 

       //OR...

       myHelperBaseClass = new MyOtherHelperSubClass();

       //HOWEVER ITS COMPLETELY CONDITIONAL ON THE BASE CLASS
       //HOW DO I MAKE SURE THE CORRECT TYPE IS INSTANTIATED DEPENDANT ON
       //THE BASE CLASS WITHOUT USING AN 'if' STATEMENT?
   }    
}

class MySubClass : MyAbstractClass {}    
class MyOtherSubClass : MyAbstractClass {}    
/////////////

abstract class MyHelperClassBase {}    

class MyHelperSubClass : MyHelperClassBase, IMyHelper {}    
class MyOtherHelperSubClass : MyHelperClassBase, IMyHelper {}

---

我希望能够有一个基本上被放弃的类型，但不能想到一个巧妙的方法来做到这一点。我应该在基类上粘贴一个抽象属性吗？

您的目标有些不明确。如果目标是将助手类与该类的特定实现相关联，则有两个选项

您可以使用泛型：

abstract class MyAbstractBaseClass<T> where T : MyHelperClassBase, new()
{
     T myHelper;

     protected void Foo()
     {
         myHelper = new T(); // This will be the appropriate subclass
     }
}

// Derived classes become ...
class MySubClass : MyAbstractClass<MyHelperSubClass>
{
}

// Derived classes become ...
class MyOtherSubClass : MyAbstractClass<MyOtherHelperSubClass>
{
}

抽象类MyAbstractBaseClass，其中T:MyHelperClassBase，new（）
{
我的助手；
受保护的void Foo（）
{
myHelper=new T（）；//这将是适当的子类
}
}
//派生类成为。。。
类MySubClass:MyAbstractClass
{
}
//派生类成为。。。
类MyOtherSubClass:MyAbstractClass
{
}

或者，您可以在基类中有一个抽象属性，子类可以实现它：

abstract class MyAbstractBaseClass<T> where T : MyHelperClassBase, new()
{
     MyHelperClassBase myHelper;

     abstract protected Func<MyHelperClassBase> MyHelperClassBaseFactory { get; }

     protected void Foo()
     {
         // Construct as needed...
         myHelper = MyHelperClassBaseFactory();
     }

}

// Derived classes implement...
class MySubClass : MyAbstractClass
{
     protected override Func<MyHelperClassBase> MyHelperClassBaseFactory 
     { 
         get { return () => new MyHelperSubClass(); }
     }
}

抽象类MyAbstractBaseClass，其中T:MyHelperClassBase，new（）
{
MyHelperClassBase myHelper；
抽象保护Func MyHelperClassBaseFactory{get；}
受保护的void Foo（）
{
//根据需要建造。。。
myHelper=MyHelperClassBaseFactory（）；
}
}
//派生类实现。。。
类MySubClass:MyAbstractClass
{
受保护的覆盖函数MyHelperClassBaseFactory
{ 
获取{return（）=>新的MyHelperSubClass（）；}
}
}

解决这个问题的旧OO方法（没有泛型）涉及一个虚拟的或抽象的方法，其基础是派生类必须实现。这在类似您的示例的并行层次结构中非常常见：

abstract class MyAbstractClass{

    MyHelperClassBase myHelper;

    protected void foo() {
        myHelper = createHelper();
    }

    protected abstract MyHelperClassBase createHelper();
}

class MySubClass : MyAbstractClass{
    protected override MyHelperClassBase createHelper(){
        return new MyHelperSubClass();
    }
}

class MyOtherSubClass : MyAbstractClass{
    protected override MyHelperClassBase createHelper(){
        return new MyOtherHelperSubClass();
    }
}

---

泛型非常方便，但有时知道这种方法也很好。

我们真正想做的是什么？很可能需要一个

抽象
方法/属性。你说的“它完全依赖于基类”是什么意思？以什么方式？基类是固定的。你的意思是它是以实例化哪个子类为条件的吗？如果是这样，听起来您需要在基类中使用一个抽象方法，由每个子类实现。现在还不清楚你想做什么…这并不取决于它，我只需要根据继承类中的内容实例化正确的类型。我可以使用if语句，但我不想。嗨，是的，干杯，这是我一直在寻找的。我没有真正得到泛型，但如果有机会，我会尝试稍后实现它……嗨，我如何使泛型类也从另一个类继承？@Pete2k：就像你使用非泛型类一样，ie:
class MyGenericClass:MyBaseClass，其中T:MyConstraint
-请参阅感谢Reed，多年来一直在尝试找出泛型，但最终认为价格下降了。我在我的解决方案之上实现了您的解决方案，以便在早上查看它是否有效！：-）@Pete2k不要放弃——泛型是值得学习的。它们将把您的编程提升到另一个层次，因为通过使用它们，您可以用更少的代码完成更多的工作。