C# Language
क्रिएशनल डिज़ाइन पैटर्न

टिप्पणियों

सिंगलटन पैटर्न

सिंगलटन उदाहरण को एक एकल उदाहरण के लिए एक वर्ग के निर्माण को प्रतिबंधित करने के लिए डिज़ाइन किया गया है।

इस पैटर्न का उपयोग उस परिदृश्य में किया जाता है, जहाँ किसी चीज़ का केवल एक ही अर्थ होता है, जैसे:

• एक एकल वर्ग जो अन्य वस्तुओं के इंटरैक्शन को ऑर्केस्ट्रा करता है, पूर्व। प्रबंधक वर्ग
• या एक वर्ग जो एक अद्वितीय, एकल संसाधन, पूर्व का प्रतिनिधित्व करता है। लॉगिंग घटक

सिंगलटन पैटर्न को लागू करने के सबसे सामान्य तरीकों में से एक एक स्थिर कारखाना विधि के माध्यम से है जैसे कि CreateInstance() या GetInstance() (या C #, Instance में एक स्थिर संपत्ति), जो तब हमेशा उसी उदाहरण को वापस करने के लिए डिज़ाइन किया गया है।

विधि या संपत्ति के लिए पहला कॉल सिंग्लटन उदाहरण बनाता है और देता है। इसके बाद, विधि हमेशा एक ही उदाहरण देता है। इस तरह, सिंगलटन ऑब्जेक्ट का केवल एक ही उदाहरण है।

new निर्माण के माध्यम से उदाहरणों की रचना को रोकने के लिए कक्षा कंस्ट्रक्टर को private. बनाकर पूरा किया जा सकता है private.

यहाँ C # में सिंगलटन पैटर्न को लागू करने के लिए एक विशिष्ट कोड उदाहरण दिया गया है:

class Singleton
{
    // Because the _instance member is made private, the only way to get the single 
    // instance is via the static Instance property below. This can also be similarly 
    // achieved with a GetInstance() method instead of the property.
    private static Singleton _instance = null;

    // Making the constructor private prevents other instances from being 
    // created via something like Singleton s = new Singleton(), protecting
    // against unintentional misuse.
    private Singleton()
    {
    }

    public static Singleton Instance
    {
        get 
        {
            // The first call will create the one and only instance.
            if (_instance == null)
            {
                _instance = new Singleton();
            }

            // Every call afterwards will return the single instance created above.
            return _instance;
        }
    }
}

इस पैटर्न को और स्पष्ट करने के लिए, नीचे दिए गए कोड की जांच की जाती है कि क्या इंस्टेंट प्रॉपर्टी को एक से अधिक बार कॉल किए जाने पर सिंग्लटन का एक समान उदाहरण वापस आ जाता है।

class Program
{
    static void Main(string[] args)
    {
        Singleton s1 = Singleton.Instance;
        Singleton s2 = Singleton.Instance;
        
        // Both Singleton objects above should now reference the same Singleton instance.
        if (Object.ReferenceEquals(s1, s2))
        {
            Console.WriteLine("Singleton is working");
        }
        else
        {
            // Otherwise, the Singleton Instance property is returning something 
            // other than the unique, single instance when called.
            Console.WriteLine("Singleton is broken");
        }
    }
}

नोट: यह कार्यान्वयन थ्रेड सुरक्षित नहीं है।

इस थ्रेड को सुरक्षित बनाने के तरीके सहित, और अधिक उदाहरण देखने के लिए, देखें: सिंगलटन कार्यान्वयन

सिंगलेट्स वैचारिक रूप से एक वैश्विक मूल्य के समान हैं, और समान डिजाइन दोषों और चिंताओं का कारण बनते हैं। इस वजह से, सिंगलटन पैटर्न को व्यापक रूप से एक विरोधी पैटर्न माना जाता है।

"सिंगलटन के बारे में इतना बुरा क्या है?" समस्याओं के बारे में अधिक जानकारी के लिए जो उनके उपयोग के साथ उत्पन्न होती हैं।

C # में, आपके पास एक क्लास static बनाने की क्षमता है, जो सभी सदस्यों को स्टैटिक बनाता है, और क्लास को तत्काल नहीं बनाया जा सकता है। इसे देखते हुए, सिंगलटन पैटर्न के स्थान पर उपयोग किए जाने वाले स्थिर वर्गों को देखना आम है।

दोनों के बीच महत्वपूर्ण अंतर के लिए, सी # सिंगलटन पैटर्न वर्सस स्टेटिक क्लास पर जाएं ।

फैक्टरी विधि पैटर्न

फैक्टरी विधि रचनात्मक डिजाइन पैटर्न में से एक है। इसका उपयोग सटीक परिणाम प्रकार निर्दिष्ट किए बिना ऑब्जेक्ट बनाने की समस्या से निपटने के लिए किया जाता है। यह दस्तावेज आपको सिखाएगा कि फैक्ट्री मेथड डीपी का उपयोग कैसे करें।

मुझे इसका उदाहरण एक सरल उदाहरण पर समझाता हूं। कल्पना कीजिए कि आप एक ऐसे कारखाने में काम कर रहे हैं जो तीन प्रकार के उपकरणों का उत्पादन करता है - एमीटर, वोल्टमीटर और प्रतिरोध मीटर। आप एक केंद्रीय कंप्यूटर के लिए एक प्रोग्राम लिख रहे हैं जो चयनित डिवाइस बनाएगा, लेकिन आपको अपने बॉस के अंतिम निर्णय का पता नहीं है कि क्या उत्पादन करना है।

आइए कुछ सामान्य कार्यों के साथ एक इंटरफ़ेस IDevice बनाएं जो सभी उपकरणों में है:

public interface IDevice
{
    int Measure();
    void TurnOff();
    void TurnOn();
}

अब, हम ऐसी कक्षाएं बना सकते हैं जो हमारे उपकरणों का प्रतिनिधित्व करती हैं। उन वर्गों को IDevice इंटरफ़ेस लागू करना होगा:

public class AmMeter : IDevice
{
    private Random r = null;
    public AmMeter()
    {
        r = new Random();
    }
    public int Measure() { return r.Next(-25, 60); }
    public void TurnOff() { Console.WriteLine("AmMeter flashes lights saying good bye!"); }
    public void TurnOn() { Console.WriteLine("AmMeter turns on..."); }
}
public class OhmMeter : IDevice
{
    private Random r = null;
    public OhmMeter()
    {
        r = new Random();
    }
    public int Measure() { return r.Next(0, 1000000); }
    public void TurnOff() { Console.WriteLine("OhmMeter flashes lights saying good bye!"); }
    public void TurnOn() { Console.WriteLine("OhmMeter turns on..."); }
}
public class VoltMeter : IDevice
{
    private Random r = null;
    public VoltMeter()
    {
        r = new Random();
    }
    public int Measure() { return r.Next(-230, 230); }
    public void TurnOff() { Console.WriteLine("VoltMeter flashes lights saying good bye!"); }
    public void TurnOn() { Console.WriteLine("VoltMeter turns on..."); }
}

अब हमें फैक्ट्री विधि को परिभाषित करना होगा। आइए अंदर स्थिर विधि के साथ DeviceFactory वर्ग बनाएं:

public enum Device
{
    AM,
    VOLT,
    OHM
}
public class DeviceFactory
{
    public static IDevice CreateDevice(Device d)
    {
        switch(d)
        {
            case Device.AM: return new AmMeter();
            case Device.VOLT: return new VoltMeter();
            case Device.OHM: return new OhmMeter();
            default: return new AmMeter();
        }
    }
}

महान! चलो हमारे कोड का परीक्षण करें:

public class Program
{
    static void Main(string[] args)
    {
        IDevice device = DeviceFactory.CreateDevice(Device.AM);
        device.TurnOn();
        Console.WriteLine(device.Measure());
        Console.WriteLine(device.Measure());
        Console.WriteLine(device.Measure());
        Console.WriteLine(device.Measure());
        Console.WriteLine(device.Measure());
        device.TurnOff();
        Console.WriteLine();

        device = DeviceFactory.CreateDevice(Device.VOLT);
        device.TurnOn();
        Console.WriteLine(device.Measure());
        Console.WriteLine(device.Measure());
        Console.WriteLine(device.Measure());
        Console.WriteLine(device.Measure());
        Console.WriteLine(device.Measure());
        device.TurnOff();
        Console.WriteLine();

        device = DeviceFactory.CreateDevice(Device.OHM);
        device.TurnOn();
        Console.WriteLine(device.Measure());
        Console.WriteLine(device.Measure());
        Console.WriteLine(device.Measure());
        Console.WriteLine(device.Measure());
        Console.WriteLine(device.Measure());
        device.TurnOff();
        Console.WriteLine();
    }
}

यह उदाहरण आउटपुट है जिसे आप इस कोड को चलाने के बाद देख सकते हैं:

AmMeter चालू ...

36

6

33

43

24

AmMeter रोशनी को अलविदा कहते हुए चमकता है!

VoltMeter चालू ...

102

-61

85

138

36

वॉल्टमीटर चमकती रोशनी को अलविदा कह रही है!

ओह्ममीटर चालू ...

723,828

368,536

685,412

800,266

578,595

ओम्ममीटर चमकती रोशनी को अलविदा कहते हुए!

बिल्डर पैटर्न

अपने प्रतिनिधित्व से एक जटिल वस्तु के निर्माण को अलग करें ताकि एक ही निर्माण प्रक्रिया अलग-अलग प्रतिनिधित्व बना सके और वस्तुओं की विधानसभा पर उच्च स्तर का नियंत्रण प्रदान कर सके।

इस उदाहरण में बिल्डर पैटर्न का प्रदर्शन किया गया है जिसमें विभिन्न वाहन चरण-दर-चरण फैशन में इकट्ठे होते हैं। दुकान क्रमबद्ध चरणों की एक श्रृंखला में विभिन्न प्रकार के वाहनों के निर्माण के लिए व्हीकलबिल्डर्स का उपयोग करती है।

using System;
using System.Collections.Generic;
 
namespace GangOfFour.Builder
{
  /// <summary>
  /// MainApp startup class for Real-World 
  /// Builder Design Pattern.
  /// </summary>
  public class MainApp
  {
    /// <summary>
    /// Entry point into console application.
    /// </summary>
    public static void Main()
    {
      VehicleBuilder builder;
 
      // Create shop with vehicle builders
      Shop shop = new Shop();
 
      // Construct and display vehicles
      builder = new ScooterBuilder();
      shop.Construct(builder);
      builder.Vehicle.Show();
 
      builder = new CarBuilder();
      shop.Construct(builder);
      builder.Vehicle.Show();
 
      builder = new MotorCycleBuilder();
      shop.Construct(builder);
      builder.Vehicle.Show();
 
      // Wait for user
      Console.ReadKey();
    }
  }
 
  /// <summary>
  /// The 'Director' class
  /// </summary>
  class Shop
  {
    // Builder uses a complex series of steps
    public void Construct(VehicleBuilder vehicleBuilder)
    {
      vehicleBuilder.BuildFrame();
      vehicleBuilder.BuildEngine();
      vehicleBuilder.BuildWheels();
      vehicleBuilder.BuildDoors();
    }
  }
 
  /// <summary>
  /// The 'Builder' abstract class
  /// </summary>
  abstract class VehicleBuilder
  {
    protected Vehicle vehicle;
 
    // Gets vehicle instance
    public Vehicle Vehicle
    {
      get { return vehicle; }
    }
 
    // Abstract build methods
    public abstract void BuildFrame();
    public abstract void BuildEngine();
    public abstract void BuildWheels();
    public abstract void BuildDoors();
  }
 
  /// <summary>
  /// The 'ConcreteBuilder1' class
  /// </summary>
  class MotorCycleBuilder : VehicleBuilder
  {
    public MotorCycleBuilder()
    {
      vehicle = new Vehicle("MotorCycle");
    }
 
    public override void BuildFrame()
    {
      vehicle["frame"] = "MotorCycle Frame";
    }
 
    public override void BuildEngine()
    {
      vehicle["engine"] = "500 cc";
    }
 
    public override void BuildWheels()
    {
      vehicle["wheels"] = "2";
    }
 
    public override void BuildDoors()
    {
      vehicle["doors"] = "0";
    }
  }
 
 
  /// <summary>
  /// The 'ConcreteBuilder2' class
  /// </summary>
  class CarBuilder : VehicleBuilder
  {
    public CarBuilder()
    {
      vehicle = new Vehicle("Car");
    }
 
    public override void BuildFrame()
    {
      vehicle["frame"] = "Car Frame";
    }
 
    public override void BuildEngine()
    {
      vehicle["engine"] = "2500 cc";
    }
 
    public override void BuildWheels()
    {
      vehicle["wheels"] = "4";
    }
 
    public override void BuildDoors()
    {
      vehicle["doors"] = "4";
    }
  }
 
  /// <summary>
  /// The 'ConcreteBuilder3' class
  /// </summary>
  class ScooterBuilder : VehicleBuilder
  {
    public ScooterBuilder()
    {
      vehicle = new Vehicle("Scooter");
    }
 
    public override void BuildFrame()
    {
      vehicle["frame"] = "Scooter Frame";
    }
 
    public override void BuildEngine()
    {
      vehicle["engine"] = "50 cc";
    }
 
    public override void BuildWheels()
    {
      vehicle["wheels"] = "2";
    }
 
    public override void BuildDoors()
    {
      vehicle["doors"] = "0";
    }
  }
 
  /// <summary>
  /// The 'Product' class
  /// </summary>
  class Vehicle
  {
    private string _vehicleType;
    private Dictionary<string,string> _parts = 
      new Dictionary<string,string>();
 
    // Constructor
    public Vehicle(string vehicleType)
    {
      this._vehicleType = vehicleType;
    }
 
    // Indexer
    public string this[string key]
    {
      get { return _parts[key]; }
      set { _parts[key] = value; }
    }
 
    public void Show()
    {
      Console.WriteLine("\n---------------------------");
      Console.WriteLine("Vehicle Type: {0}", _vehicleType);
      Console.WriteLine(" Frame : {0}", _parts["frame"]);
      Console.WriteLine(" Engine : {0}", _parts["engine"]);
      Console.WriteLine(" #Wheels: {0}", _parts["wheels"]);
      Console.WriteLine(" #Doors : {0}", _parts["doors"]);
    }
  }
}

उत्पादन

---

वाहन का प्रकार: स्कूटर फ़्रेम: स्कूटर फ़्रेम
इंजन: कोई नहीं
# व्हेल: 2
# डोर: 0

---

वाहन के प्रकार: कार
फ़्रेम: कार फ़्रेम
इंजन: 2500 cc
# व्हेल: 4
# डोर: 4

---

वाहन का प्रकार: मोटर साइकिल
फ्रेम: मोटर साइकिल फ्रेम
इंजन: 500 cc
# व्हेल: 2
# डोर: 0

प्रोटोटाइप पैटर्न

एक प्रोटोटाइप उदाहरण का उपयोग करने के लिए ऑब्जेक्ट की तरह निर्दिष्ट करें, और इस प्रोटोटाइप की प्रतिलिपि बनाकर नई ऑब्जेक्ट बनाएं।

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

using System;
using System.Collections.Generic;
 
namespace GangOfFour.Prototype
{
  /// <summary>
  /// MainApp startup class for Real-World 
  /// Prototype Design Pattern.
  /// </summary>
  class MainApp
  {
    /// <summary>
    /// Entry point into console application.
    /// </summary>
    static void Main()
    {
      ColorManager colormanager = new ColorManager();
 
      // Initialize with standard colors
      colormanager["red"] = new Color(255, 0, 0);
      colormanager["green"] = new Color(0, 255, 0);
      colormanager["blue"] = new Color(0, 0, 255);
 
      // User adds personalized colors
      colormanager["angry"] = new Color(255, 54, 0);
      colormanager["peace"] = new Color(128, 211, 128);
      colormanager["flame"] = new Color(211, 34, 20);
 
      // User clones selected colors
      Color color1 = colormanager["red"].Clone() as Color;
      Color color2 = colormanager["peace"].Clone() as Color;
      Color color3 = colormanager["flame"].Clone() as Color;
 
      // Wait for user
      Console.ReadKey();
    }
  }
 
  /// <summary>
  /// The 'Prototype' abstract class
  /// </summary>
  abstract class ColorPrototype
  {
    public abstract ColorPrototype Clone();
  }
 
  /// <summary>
  /// The 'ConcretePrototype' class
  /// </summary>
  class Color : ColorPrototype
  {
    private int _red;
    private int _green;
    private int _blue;
 
    // Constructor
    public Color(int red, int green, int blue)
    {
      this._red = red;
      this._green = green;
      this._blue = blue;
    }
 
    // Create a shallow copy
    public override ColorPrototype Clone()
    {
      Console.WriteLine(
        "Cloning color RGB: {0,3},{1,3},{2,3}",
        _red, _green, _blue);
 
      return this.MemberwiseClone() as ColorPrototype;
    }
  }
 
  /// <summary>
  /// Prototype manager
  /// </summary>
  class ColorManager
  {
    private Dictionary<string, ColorPrototype> _colors =
      new Dictionary<string, ColorPrototype>();
 
    // Indexer
    public ColorPrototype this[string key]
    {
      get { return _colors[key]; }
      set { _colors.Add(key, value); }
    }
  }
}

आउटपुट:

क्लोनिंग रंग RGB: 255, 0, 0

क्लोनिंग रंग RGB: 128,211,128

क्लोनिंग रंग RGB: 211, 34, 20

सार फैक्टरी पैटर्न

संबंधित या आश्रित वस्तुओं के परिवारों को उनके ठोस वर्गों को निर्दिष्ट किए बिना बनाने के लिए एक इंटरफ़ेस प्रदान करें।

इस उदाहरण में विभिन्न कारखानों का उपयोग करके कंप्यूटर गेम के लिए विभिन्न जानवरों की दुनिया के निर्माण को प्रदर्शित किया गया है। हालाँकि कॉन्टिनेंट फैक्ट्रियों द्वारा बनाए गए जानवर अलग-अलग होते हैं, फिर भी जानवरों के बीच बातचीत समान रहती है।

using System;
 
namespace GangOfFour.AbstractFactory
{
  /// <summary>
  /// MainApp startup class for Real-World
  /// Abstract Factory Design Pattern.
  /// </summary>
  class MainApp
  {
    /// <summary>
    /// Entry point into console application.
    /// </summary>
    public static void Main()
    {
      // Create and run the African animal world
      ContinentFactory africa = new AfricaFactory();
      AnimalWorld world = new AnimalWorld(africa);
      world.RunFoodChain();
 
      // Create and run the American animal world
      ContinentFactory america = new AmericaFactory();
      world = new AnimalWorld(america);
      world.RunFoodChain();
 
      // Wait for user input
      Console.ReadKey();
    }
  }
 
 
  /// <summary>
  /// The 'AbstractFactory' abstract class
  /// </summary>
  abstract class ContinentFactory
  {
    public abstract Herbivore CreateHerbivore();
    public abstract Carnivore CreateCarnivore();
  }
 
  /// <summary>
  /// The 'ConcreteFactory1' class
  /// </summary>
  class AfricaFactory : ContinentFactory
  {
    public override Herbivore CreateHerbivore()
    {
      return new Wildebeest();
    }
    public override Carnivore CreateCarnivore()
    {
      return new Lion();
    }
  }
 
  /// <summary>
  /// The 'ConcreteFactory2' class
  /// </summary>
  class AmericaFactory : ContinentFactory
  {
    public override Herbivore CreateHerbivore()
    {
      return new Bison();
    }
    public override Carnivore CreateCarnivore()
    {
      return new Wolf();
    }
  }
 
  /// <summary>
  /// The 'AbstractProductA' abstract class
  /// </summary>
  abstract class Herbivore
  {
  }
 
  /// <summary>
  /// The 'AbstractProductB' abstract class
  /// </summary>
  abstract class Carnivore
  {
    public abstract void Eat(Herbivore h);
  }
 
  /// <summary>
  /// The 'ProductA1' class
  /// </summary>
  class Wildebeest : Herbivore
  {
  }
 
  /// <summary>
  /// The 'ProductB1' class
  /// </summary>
  class Lion : Carnivore
  {
    public override void Eat(Herbivore h)
    {
      // Eat Wildebeest
      Console.WriteLine(this.GetType().Name +
        " eats " + h.GetType().Name);
    }
  }
 
  /// <summary>
  /// The 'ProductA2' class
  /// </summary>
  class Bison : Herbivore
  {
  }
 
  /// <summary>
  /// The 'ProductB2' class
  /// </summary>
  class Wolf : Carnivore
  {
    public override void Eat(Herbivore h)
    {
      // Eat Bison
      Console.WriteLine(this.GetType().Name +
        " eats " + h.GetType().Name);
    }
  }
 
  /// <summary>
  /// The 'Client' class 
  /// </summary>
  class AnimalWorld
  {
    private Herbivore _herbivore;
    private Carnivore _carnivore;
 
    // Constructor
    public AnimalWorld(ContinentFactory factory)
    {
      _carnivore = factory.CreateCarnivore();
      _herbivore = factory.CreateHerbivore();
    }
 
    public void RunFoodChain()
    {
      _carnivore.Eat(_herbivore);
    }
  }
}

आउटपुट:

शेर वाइल्डबेस्ट खाता है

भेड़िया बाइसन खाता है