抽象類的構造函數的繼承對象

Question

讓我們說，我有一個抽象類A.在那裏，我得到了一些內部類喜歡這裏：

public abstract class A 
{ 
     public InnerOne x; 
     public InnerTwo y; 
     public A(){ 
      this.x = new InnerOne(); 
      this.y = new InnerTwo(); 
     } 
     public class InnerOne 
     { 
      public virtual double value(){ 
       return 0; 
      } 
     } 
     public class InnerTwo 
     { 
      public virtual double value(){ 
       return 0; 
      } 
     } 
} 

然後我得到了它的兒童像這樣的：

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

      } 
      public class InnerOne: A.InnerOne 
      { 
       public override virtual double value(){ 
        return 100; 
       } 
      } 
      public class InnerTwo: A.InnerTwo 
      { 
       public override virtual double value(){ 
        return 100; 
       } 
      } 
    } 

所以我認爲當我打電話B這樣的構造函數時，我會通過創建它的內部類實例來初始化x和y。但實際上並不是這樣的。當我打電話給vaule函數時，它返回零。

A newobject = new B(); 
var bv1 = B.x.value(); 
var bv2 = B.y.value(); 

有沒有辦法迫使B類來初始化它的x和y領域由它的內部類對象（不與父抽象類對象），而無需重新編寫它的構造？

Answer 1

即使你已經定義了A或B中的類，他們仍然是大衆，他們在外面A或B.它的訪問從A或B之外definied一類沒什麼兩樣

想象中的一樣代碼定義在A類和B類之外的InnerOne和InnerTwo。它將具有上述相同的行爲。你的困惑根源在於誤解了內部類的用法。

爲了得到100，在B裏面，你需要用一個覆蓋這些值的實例顯式替換X和Y變量的實例。除非你做這些，你不會得到100

public class B: A 
    { 
      public B():base(){ 
      X = new OverridenInnerOne(); 
      Y = new OverridenInnerTwo(); 
      } 
      public class OverridenInnerOne: A.InnerOne 
      { 
       public override virtual double value(){ 
        return 100; 
       } 
      } 
      public class OverridenInnerTwo: A.InnerTwo 
      { 
       public override virtual double value(){ 
        return 100; 
       } 
      } 
    } 

Answer 2

的「內部類」方面（嵌入式類定義）只在這裏分心，沒有發揮任何作用。

並回答這個問題：不，你不能有'虛擬構造函數'這樣工作。

當然有很多方法可以獲得100而不是0作爲返回值，但是這個問題太過於人爲地提出了一個問題。

Answer 3

B.x和B.y是A.InnerOne和A.InnerTwo實例，所以你看到的返回值0，因爲這些都無關B.InnerOne或B.InnerTwo。

以下B構造函數分配x和y，其將返回100

public B(){ 
    this.x = new InnerOne(); 
    this.y = new InnerTwo(); 
} 

如果你想在A你期望的方式工作的B.InnerOne和B.InnerTwo情況下，你需要通過您需要從B構造函數中創建內部類型，並在A構造函數中創建它們的實例，如下所示：

public B():base(typeof(InnerOne),typeof(InnerTwo)) { ... } 

使用Activator.CreateInstance可讓您在A的構造函數中創建這些類型。

如果您始終希望A以這種方式使用，Enigmativity的通用解決方案會更好，或者，這種方式允許您爲A擁有多個構造函數，以便您可以選擇傳遞不同的類型。

Answer 4

你可以做到這一點，但你必須改變類A的定義 - 它會變得超級毛茸茸。

這裏的A：

public abstract class A<I1, I2> 
    where I1 : A<I1, I2>.InnerOne, new() 
    where I2 : A<I1, I2>.InnerTwo, new() 
{ 
    public InnerOne x; 
    public InnerTwo y; 
    public A() 
    { 
     this.x = new I1(); 
     this.y = new I2(); 
    } 
    public class InnerOne 
    { 
     public virtual double value() 
     { 
      return 0; 
     } 
    } 
    public class InnerTwo 
    { 
     public virtual double value() 
     { 
      return 0; 
     } 
    } 
} 

而這裏的B：

public class B: A<B.InnerOne, B.InnerTwo> 
{ 
    public B():base(){ } 
    public class InnerOne: A<InnerOne, InnerTwo>.InnerOne 
    { 
     public override double value() 
     { 
      return 100; 
     } 
    } 
    public class InnerTwo: A<InnerOne, InnerTwo>.InnerTwo 
    { 
     public override double value() 
     { 
      return 100; 
     } 
    } 
}