調用抽象類類型C＃的子實現

Question

我想在具有抽象類類型的對象上調用子類實現。 但是，這不符合我的預期。 有沒有辦法做到這一點，不需要我在第二個開關空間中在類型之間進行切換？ 還是C＃不允許這種行為？

被稱為的代碼：

AbstractParentType wfp;

//Switch on diagram type and select processor
switch (qi.DIAGRAMTYPE)
{
    case 1:
        wfp = new T1(notifications);
        break;
    case 2:
        wfp = new T2(notifications);
        break;
    case 3:
        wfp = new T3(notifications);
        break;
    default:
        throw new Exception("Diagramtype not implemented");
}

bool result = false;
//Switch on action type
switch (qi.Type)
{
    case (int)WorkflowActionType.BelItem:
        //Do some case specific stuff here
        ...
        //Call method
        result = wfp.Meth1();
        break;
    ... (a bunch of cases) ...
    case (int)WorkflowActionType.WordDocument:
        //Do some case specific stuff here
        ...
        //Call method
        result = wfp.Meth10();
        break;
}

然后，我們有了類的實現：

abstract class AbstractClassType {
     public bool Meth1() { ... }
     ...
     public bool Meth10() { ... }
     ...
     public abstract MethX();
     public abstract MethY();
}

class T1 : AbstractClassType  {
     public new Meth1() { ... }
     ...
     public new Meth10() { ... } 
     ...
     public override MethX() { ... }
     public override MethY() { ... }
}

實際的方法確實具有參數，我確實想要某些方法（但不是全部）的基本實現。 目的是允許繼承的類“擴展”方法的行為。

Answer 1

嘗試使用virtual關鍵字

使用虛擬時，可以為基類中的方法提供“默認”實現。 像這樣：

abstract class AbstractClassType {
    public virtual void MethX(){
        //default implementation here.            
    }
    public virtual void MethY(){
        //another default implementation here!
    }
}

class T1 : AbstractClassType {
    public override void MethX(){
        //base.MethX() would call the logic in the base class. 
    }
    public override void MethY(){ 
        //base.MethY() would call the logic in the base class. 
    }
}

virtual和abstract之間的區別在於，基本上， abstract方法不能具有基本實現，而必須被覆蓋。

virtual方法可以具有基本實現，並且不需要被覆蓋。

您不需要調用base.MethX/Y() 。 如果願意，您甚至可以給該方法一個全新的含義。

Answer 2

首先，您不能創建抽象類的對象，因為它實際上不是完整的實體。 您將始終需要實例化擴展抽象類的類的對象。

以下代碼顯示了使用抽象類時可以使用的各種（不是全部）選項。

    public abstract class AbstractClass
    {
        public void OnlyInAbstract() {
            Console.WriteLine("You are stuck with OnlyInAbstract in abstract class unless you use new keyword.");
        }

        public virtual void OnlyInAbstractForNow()
        {
            Console.WriteLine("You have reached abstract class for now. However, override me for changed behaviour.");
        }

        public abstract void MustImplement();
    }

    public class FirstChild : AbstractClass
    {
        public override void MustImplement()
        {
            Console.WriteLine("You called MustImplement in FirstChild. Nothing else to see here.");
        }

        public override void OnlyInAbstractForNow()
        {
            base.OnlyInAbstractForNow();
            Console.WriteLine("I see you changed my behaviour in FirstChild to extend it after abstract class was done with.");
        }

        public new void OnlyInAbstract()
        {
            Console.WriteLine("Looks like we are making an all new OnlyInAbstract method in child class.");
        }
    }

    static void Main(string[] args)
    {
        AbstractClass abstractClass = new FirstChild();

        abstractClass.MustImplement();

        abstractClass.OnlyInAbstract();

        (abstractClass as FirstChild).OnlyInAbstract();

        abstractClass.OnlyInAbstractForNow();

        Console.Read();
    }