在構建完所有子類之後，如何在超類中執行一些代碼？

Question

有沒有辦法在C＃中做到這一點？我知道子類將在調用它自己的構造函數之前調用超類的構造函數，但是如果我在超類上有一些代碼，只有在所有的子類構造函數被調用後纔會執行它。

Answer 1

的一種方式。所以，你構建的實例，然後調用它調用基類初始化以適當的順序

class MyBase 
{ 
    // Only if need to do some core initialization 
    public MyBase() 
    { 
    } 

    public virtual Initialize() 
    { 
    // do some initialization stuff here 
    } 
} 

class MyDerived : MyBase 
{ 
    // Only if need to do some core initialization 
    public MyDerived() 
    { 
    } 

    public override Initialize() 
    { 
    // do some initialization stuff here 

    // Call the base class initialization function 
    base.Initialize(); 
    } 
} 

Answer 2

class A : B 
{ 
    public A() : base() 
    { 
     base.doSomething(); 
    } 
} 

class B : C 
{ 
    public B() : base() 
    { 

    } 

    public void doSomething() { /* ... */ } 
} 

class C 
{ 
    public C() { /* ... */ } 
} 

執行順序應爲：

1. Ç::構造函數（）
2. B ::構造函數（）
3. A ::構造函數（）
4. B :: doSomething的（ ）

Answer 3

我不確定你是什麼意思 - 你不能只是在我們最後一個子類的結尾調用超類的代碼structor？或者，您可以在實例化後直接調用它。

class Program 
    { 
     static void Main(string[] args) 
     { 
      SubSub obj = new SubSub();     
      //obj.DoStuff(); 
      Console.ReadLine(); 
     } 
    } 

    class Super 
    { 
     public Super() 
     { 
      Console.WriteLine("Constructing Super"); 
     } 
     public void DoStuff() 
     { 
      Console.WriteLine("Doin' stuff"); 
     } 
    } 

    class Sub : Super 
    { 
     public Sub() 
     { 
      Console.WriteLine("Constructing Sub"); 
     } 
    } 

    class SubSub : Sub 
    { 
     public SubSub() 
     { 
      Console.WriteLine("Constructing SubSub"); 
      DoStuff(); 
     } 
    } 

這將輸出：實現，這將是去一個兩階段的構造和初始化

Constructing Super 
Constructing Sub 
Constructing SubSub 
Doin' stuff 

Answer 4

你可以做以下的初始化方法，但它是有風險的（見下面我的編輯）：

public class Parent 
{ 
    public Parent() 
    { 
     Initialize(); 
    } 

    protected virtual void Initialize() 
    { 
     // do stuff 
    } 
} 

public class Child : Parent 
{ 
    protected override void Initialize() 
    { 
     // do child stuff 
     base.Initialize(); 
    } 
} 

編輯

正如下面泰倫斯的評論認爲，這是一個危險的做法，因爲在執行Child的構造函數之前Initialize()將被執行。如果在Child的構造函數中有任何字段被初始化，如果它們被Initialize()使用，則它們將不會準備好。這可能會導致令人困惑的錯誤。

一個簡單的解決方案是放棄父母撥打Initialize()，而是讓子類別撥打Initialize()。正如其他人所建議的，另一種選擇是使用抽象工廠模式。

下面是一個使用靜態工廠方法的簡單的解決方案：

class Program 
{ 
    static void Main() 
    { 
     Child.Create(() => new Child(5)); 
     Console.ReadKey(); 
    } 
} 

public abstract class Parent 
{ 
    protected virtual void Initialize() 
    { 
     Console.Write(" is the number."); 
    } 

    public static TChild Create<TChild>(Func<TChild> childGetter) 
     where TChild : Parent 
    { 
     var child = childGetter(); 
     child.Initialize(); 
     return child; 
    } 
} 

public class Child : Parent 
{ 
    private int _number; 

    public Child(int number) 
    { 
     _number = number; 
    } 

    protected override void Initialize() 
    { 
     Console.Write(_number.ToString()); 
     base.Initialize(); 
    } 
} 

Answer 5

沒有什麼內置到C＃語言，可以讓你做到這一點。但是，使用創建模式可以支持它。例如，Abstract Factory模式可能會對您有所幫助。基礎工廠將確保在新創建的基類被實例化爲具體的子類型後調用方法。