स्थैतिक विधि वंशानुक्रम का सही विकल्प क्या है?

Question 1

मैं समझता हूं कि स्थैतिक विधि विरासत C # में समर्थित नहीं है। मैंने कई चर्चाएँ भी पढ़ी हैं (यहाँ सहित) जिसमें डेवलपर्स इस कार्यक्षमता की आवश्यकता का दावा करते हैं, जिस पर विशिष्ट प्रतिक्रिया है "यदि आपको स्थैतिक सदस्य विरासत की आवश्यकता है, तो आपके डिज़ाइन में दोष है"।

ठीक है, यह देखते हुए कि ओओपी मुझे स्थिर विरासत के बारे में सोचना भी नहीं चाहता है, मुझे यह निष्कर्ष निकालना चाहिए कि इसके लिए मेरी स्पष्ट आवश्यकता मेरे डिजाइन में त्रुटि की ओर इशारा करती है। लेकिन, मैं फंस गया हूं। मैं वास्तव में इसे हल करने में कुछ मदद की सराहना करूंगा। यहां है चुनौती ...

मैं एक सार आधार वर्ग बनाना चाहता हूं (इसे एक फल कहते हैं) जो कुछ जटिल आरंभीकरण कोड को कूटबद्ध करता है। इस कोड को कंस्ट्रक्टर में नहीं रखा जा सकता है, क्योंकि यह कुछ वर्चुअल विधि कॉल पर निर्भर करेगा।

फलों को अन्य ठोस वर्गों (ऐप्पल, ऑरेंज) द्वारा विरासत में प्राप्त किया जाएगा, जिनमें से प्रत्येक को एक मानक कारखाना विधि CreateInstance () को एक उदाहरण बनाने और आरंभ करने के लिए उजागर करना होगा।

यदि स्थिर सदस्य उत्तराधिकार संभव था, तो मैं कारखाने की विधि को आधार वर्ग में रखूंगा और उस प्रकार को प्राप्त करने के लिए व्युत्पन्न वर्ग के लिए एक आभासी विधि कॉल का उपयोग करूंगा जिसमें से एक ठोस उदाहरण को आरंभीकृत किया जाना चाहिए। क्लाइंट कोड Apple.CreateInstance () को पूरी तरह से प्रारंभिक Apple उदाहरण प्राप्त करने के लिए सरल करेगा।

लेकिन स्पष्ट रूप से यह संभव नहीं है, इसलिए कोई यह बता सकता है कि उसी कार्यक्षमता को समायोजित करने के लिए मेरे डिजाइन को कैसे बदलना होगा।

Question 2

एक विचार:

public abstract class Fruit<T>
    where T : Fruit<T>, new()
{
    public static T CreateInstance()
    {
        T newFruit = new T();
        newFruit.Initialize();  // Calls Apple.Initialize
        return newFruit;
    }

    protected abstract void Initialize();
}

public class Apple : Fruit<Apple>
{
    protected override void Initialize() { ... }
}

और ऐसे कॉल करें:

Apple myAppleVar = Fruit<Apple>.CreateInstance();

कोई अतिरिक्त कारखाना वर्गों की जरूरत नहीं है।

Question 3

कारखाने की विधि को प्रकार से बाहर ले जाएं, और इसे अपने कारखाने वर्ग में रखें।

public abstract class Fruit
{
    protected Fruit() {}

    public abstract string Define();

}

public class Apple : Fruit
{
    public Apple() {}

    public override string Define()
    {
         return "Apple";
    }
}

public class Orange : Fruit
{
    public Orange() {}

    public override string Define()
    {
         return "Orange";
    }
}

public static class FruitFactory<T> 
{
     public static T CreateFruit<T>() where T : Fruit, new()
     {
         return new T();
     }
}

लेकिन, जैसा कि मैं यह देख रहा हूं, बनाएँ विधि को अपने स्वयं के फ़ैक्टरी वर्ग में स्थानांतरित करने की कोई आवश्यकता नहीं है (हालांकि मुझे लगता है कि यह बेहतर है-चिंताओं का -अपराध-), आप इसे फ्रूट क्लास में रख सकते हैं:

public abstract class Fruit
{

   public abstract string Define();

   public static T CreateFruit<T>() where T : Fruit, new()
   {
        return new T();
   }

}

और, यह देखने के लिए कि क्या यह काम करता है:

    class Program
    {
        static void Main( string[] args )
        {
            Console.WriteLine (Fruit.CreateFruit<Apple> ().Define ());
            Console.WriteLine (Fruit.CreateFruit<Orange> ().Define ());

            Console.ReadLine ();
        }        
    }

Question 4

क्यों नहीं एक बनाने की विधि के साथ एक कारखाने वर्ग (templated) बनाते हैं?

FruitFactory<Banana>.Create();

Question 5

मैं ऐसा कुछ करूंगा

 public abstract class Fruit() {
      public abstract void Initialize();
 }

 public class Apple() : Fruit {
     public override void Initialize() {

     }
 }

 public class FruitFactory<T> where T : Fruit, new {
      public static <T> CreateInstance<T>() {
          T fruit = new T();
          fruit.Initialize();
          return fruit;  
      }
 } 


var fruit = FruitFactory<Apple>.CreateInstance()

Question 6

WebRequestवर्ग और .NET बीसीएल में अपनी व्युत्पन्न प्रकार कैसे डिजाइन इस तरह की अपेक्षाकृत अच्छी तरह से लागू किया जा सकता का एक अच्छा उदाहरण प्रस्तुत करती हैं।

WebRequestवर्ग सहित कई उप-वर्गों, है HttpWebRequestऔर FtpWebReuest। अब, यह WebRequestआधार वर्ग भी एक कारखाना प्रकार है, और एक स्थिर Createविधि को उजागर करता है (उदाहरण के निर्माता छिपे हुए हैं, जैसा कि कारखाना पैटर्न द्वारा आवश्यक है)।

public static WebRequest Create(string requestUriString)
public static WebRequest Create(Uri requestUri)

यह Createविधि WebRequestकक्षा का एक विशिष्ट कार्यान्वयन लौटाती है , और ऑब्जेक्ट के प्रकार को बनाने और वापस करने के लिए URI (या URI स्ट्रिंग) का उपयोग करती है।

यह निम्नलिखित उपयोग पैटर्न का अंतिम परिणाम है:

var httpRequest = (HttpWebRequest)WebRequest.Create("http://stackoverflow.com/");
// or equivalently
var httpRequest = (HttpWebRequest)HttpWebWebRequest.Create("http://stackoverflow.com/");

var ftpRequest = (FtpWebRequest)WebRequest.Create("ftp://stackoverflow.com/");
// or equivalently
var ftpRequest = (FtpWebRequest)FtpWebWebRequest.Create("ftp://stackoverflow.com/");

मुझे व्यक्तिगत रूप से लगता है कि यह मुद्दे पर पहुंचने का एक अच्छा तरीका है, और यह वास्तव में .NET फ्रेमवर्क रचनाकारों की पूर्वनिर्मित विधि प्रतीत होती है।

Question 7

सबसे पहले, स्टैटिक इनिशियलाइज़र जो वर्चुअल हो सकते हैं उनका मतलब यह नहीं है कि आपके पास "मानक" सदस्य विधियाँ नहीं हो सकती हैं, जो ओवरलोड हो सकती हैं। सभी में से, आप अपने वर्चुअल तरीकों को कंस्ट्रक्टर्स से कॉल कर सकते हैं, और वे उम्मीद के मुताबिक काम करेंगे, इसलिए यहां कोई समस्या नहीं है। तीसरा, आप सामान्य-सुरक्षित कारखाने के लिए जेनरिक का उपयोग कर सकते हैं।
यहां कुछ कोड दिए गए हैं, जो निर्माता + सदस्य प्रारंभिक () विधि का उपयोग करता है जिसे निर्माता द्वारा कहा जाता है (और यह संरक्षित है, इसलिए आपको चिंता करने की ज़रूरत नहीं है, कि कोई व्यक्ति ऑब्जेक्ट बनाने के बाद इसे फिर से कॉल करेगा):


abstract class Fruit
{
    public Fruit()
    {
        Initialize();
    }

    protected virtual void Initialize()
    {
        Console.WriteLine("Fruit.Initialize");
    }
}

class Apple : Fruit
{
    public Apple()
        : base()
    { }

    protected override void Initialize()
    {
        base.Initialize();
        Console.WriteLine("Apple.Initialize");
    }

    public override string ToString()
    {
        return "Apple";
    }
}

class Orange : Fruit
{
    public Orange()
        : base()
    { }

    protected override void Initialize()
    {
        base.Initialize();
        Console.WriteLine("Orange.Initialize");
    }

    public override string ToString()
    {
        return "Orange";
    }
}

class FruitFactory
{
    public static T CreateFruit<T>() where T : Fruit, new()
    {
        return new T();
    }
}

public class Program
{

    static void Main()
    {
        Apple apple = FruitFactory.CreateFruit<Apple>();
        Console.WriteLine(apple.ToString());

        Orange orange = new Orange();
        Console.WriteLine(orange.ToString());

        Fruit appleFruit = FruitFactory.CreateFruit<Apple>();
        Console.WriteLine(appleFruit.ToString());
    }
}

Question 8

मैं सबसे अच्छी बात यह कहूंगा कि फलों के वर्ग पर एक वर्चुअल / एब्सट्रैक्ट इनिशियलाइज़ विधि बनाना है जिसे कॉल किया जाना चाहिए और फिर इंस्टेंस बनाने के लिए एक बाहरी 'फ्रूट फैक्ट्री' क्लास बनाना होगा:


public class Fruit
{
    //other members...
    public abstract void Initialise();
}

public class FruitFactory()
{
    public Fruit CreateInstance()
    {
        Fruit f = //decide which fruit to create
        f.Initialise();

        return f;
    }
}