सभी उप-वर्गों के निर्माण के बाद मैं सुपरक्लास में कुछ कोड कैसे निष्पादित करूं?

Question

क्या सी # में ऐसा करने का कोई तरीका है? मुझे पता है कि सबक्लास अपने स्वयं के कन्स्ट्रक्टर को कॉल करने से पहले सुपरक्लस कन्स्ट्रक्टर को कॉल करेगा, लेकिन अगर मेरे पास सुपरक्लास पर कुछ कोड है जो केवल सभी उपclass रचनाकारों के नाम पर निष्पादित किया जाना चाहिए?

Answer 1

एक तरह से इस लक्ष्य को हासिल करने के लिए एक 2 चरण निर्माण के लिए जाने के लिए और प्रारंभ करने में किया जाएगा। तो तुम उदाहरणों का निर्माण और फिर एक इनिशियलाइज़ विधि है जो उचित आदेश

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. सी :: ctor()
2. बी :: ctor()
3. एक :: ctor()
4. बी :: DoSomething ()

Answer 3

मुझे यकीन नहीं है कि आपका क्या मतलब है - क्या आप हमारे अंतिम उपclass con के अंत में सुपर क्लास में कोड को कॉल नहीं कर सकते 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(); 
    } 
} 

संपादित

नीचे टेरेंस की टिप्पणी में सुझाव दिया गया है, यह एक जोखिम भरा तरीका है क्योंकि Initialize() से पहले Child के निर्माता निष्पादित किया जाता है निष्पादित किया जाएगा है। यदि 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

आप यह कर देता है कि सी # भाषा में निर्मित कुछ भी नहीं है। हालांकि, एक सृजन पैटर्न का उपयोग कर इसका समर्थन कर सकता है। उदाहरण के लिए, Abstract Factory पैटर्न यहां सहायक हो सकता है। बेस फैक्ट्री यह सुनिश्चित करेगी कि कंक्रीट बच्चे के प्रकार के रूप में इसे तुरंत शुरू करने के बाद नव निर्मित बेस क्लास पर एक विधि कहा जाता है।