design patterns सार फैक्टरी, फैक्टरी विधि, बिल्डर




design-patterns language-agnostic (6)

ऐसा लगता है कि यह सवाल एक डुप्ली है, लेकिन कृपया मेरे साथ सहन करें - मैं वादा करता हूं कि मैंने संबंधित पोस्ट (और जीओएफ पुस्तक ) पढ़ ली है।

मैंने जो कुछ भी पढ़ा है, उसके बाद भी मुझे यह स्पष्ट नहीं है कि सार फैक्टरी, फैक्ट्री विधि या बिल्डर का उपयोग कब किया जाए। मेरा मानना ​​है कि आखिर में एक समस्या का एक सरल उदाहरण देखने के बाद यह एक बार फिर से डूब जाएगा, जिसका कहना है कि एक निर्माता, और एक स्पष्ट कारखाने का उपयोग करने के लिए स्पष्ट रूप से मूर्खतापूर्ण होगा।

क्या आप एक साधारण उदाहरण प्रदान कर सकते हैं जहां आप स्पष्ट रूप से एक पैटर्न का उपयोग करेंगे, न कि दूसरों को?

मैं समझता हूं कि यह राय के मामले में उबाल सकता है अगर उदाहरण बहुत आसान है, लेकिन मुझे उम्मीद है कि यदि कोई भी कर सकता है, तो वह व्यक्ति SO में है।

धन्यवाद।


  • फैक्टरी विधि पैटर्न - जब आप जटिल वस्तुओं के परिवार का निर्माण करना चाहते हैं।
  • ऑब्जेक्ट बिल्डर पैटर्न - जब आप उपयोगकर्ता को अपने ढांचे में अपने कस्टम कार्यान्वयन को प्लग करने की अनुमति देना चाहते हैं

अधिक जानकारी के लिए कृपया निम्नलिखित यूआरएल पर जाएं।

http://xeon2k.wordpress.com


निर्माता

// Builder encapsulates construction of other object. Building of the object can be done in multiple steps (methods)
public class ConfigurationBuilder
{
  // Each method adds some configuration part to internally created Configuration object
  void AddDbConfiguration(...);
  void AddSmtpConfiguration(...);
  void AddWebServicesConfiguration(...);
  void AddWebServerConfiguration(...);

  // Returns built configuration
  Configuration GetConfiguration();
}

फैक्टरी विधि

// Factory method is declared in base class or interface. Subclass defines what type is created by factory method.
public interface ICacheProvider
{
  ISession CreateCache(); // Don't have to return new instance each time - such decission is part of implementation in derived class.
}

public class InMemoryCacheProvider : ICacheProvider
{ ... }

public class DbStoredCacheProvider : ICacheProvider
{ ... }

// Client code
ICacheProvider provider = new InMemoryCacheProvider
ICache cache = provider.CreateCache(); 

सार फैक्टरी

// Abstract factory defines families of platform classes - you don't need to specify each platform class on the client.
public interface IDbPlatform
{
  // It basically defines many factory methods for related classes
  IDbConnection CreateConnection();
  IDbCommand CreateCommand();
  ...
}

// Abstract factory implementation - single class defines whole platform
public class OraclePlatfrom : IDbPlatform
{ ... }

public class MySqlPlatform : IDbPlatform
{ ... }

// Client code:
IDbPlatform platform = new OraclePlatform();
IConnection connection = platform.CreateConnection(); // Automatically Oracle related
...

सार फैक्ट्री परीक्षण संचालित विकास और युग्मन को कम करने के लिए विशेष रूप से सहायक है।

उदाहरण के लिए, सी # में:

public class Worker
{
    public IConsumerFactory Factory { get; set; }

    private IResource resource;

    public DoWork()
    {
        IConsumer consumer = Factory.CreateConsumer();
        consumer.Consume(resource);
    }
}

public interface IConsumerFactory
{
    IConsumer CreateConsumer();
}

public interface IConsumer
{
    void Consume(IResource resource);
}

public class DefaultConsumerFactory : IConsumerFactory
{
    public IConsumer CreateConsumer()
    {
        return new DefaultConsumer();
    }
}

public class DefaultConsumer : IConsumer
{
    public void Consume(IResource resource)
    {
      ... Do Work ...
    }
}

इस तरह, आप उत्पादन कोड के लिए डिफ़ॉल्ट कार्यान्वयन को इंजेक्ट करने के लिए निर्भरता इंजेक्शन का उपयोग कर सकते हैं, और फिर आप फैक्ट्री और ऑब्जेक्ट्स को आसानी से नकल कर सकते हैं।


मैंने फ़ैक्टरी विधि पैटर्न और बिल्डर पैटर्न की तुलना करने के लक्ष्य के साथ दूसरे दिन एक लेख लिखा था। आप इसे यहां पा सकते हैं: http://www.shenghua.co.uk/factory-method-vs-builder/ । उम्मीद है कि यह कुछ भी मदद कर सकता है।

अपने अनुभव से, मैंने पाया कि हेड फर्स्ट डिज़ाइन पैटर्न बुक डिज़ाइन पैटर्न के बारे में बात करने वाली एक बहुत अच्छी किताब भी है। एरिच गामा द्वारा लिखे गए एक से अलग, यह डिज़ाइन पैटर्न का उपयोग नहीं होने के कारण किसी समस्या को पेश करके प्रत्येक डिज़ाइन पैटर्न से संपर्क किया और फिर उस समस्या को हल करने के लिए एक डिज़ाइन पैटर्न कैसे हल हो सकता है। यह मेरे लिए एक बहुत ही सुखद पढ़ने वाला था। इसने इसे पढ़ने के बाद एरिच गामा द्वारा लिखे गए एक को भी समझना आसान बना दिया।


सार फैक्टरी पैटर्न अन्य वस्तुओं (गैर कारखानों) का उत्पादन करने के लिए उपclassing (कारखानों) का उपयोग करता है। सार फैक्ट्री यह भी बताती है कि उत्पादित वस्तुओं समानांतर पदानुक्रमों से संबंधित हैं (उदाहरण के लिए प्लेटफ़ॉर्म स्वतंत्रता को संभालने के लिए, प्रत्येक प्लेटफ़ॉर्म के लिए एक पदानुक्रम)।

बिल्डर पैटर्न "आउटपुट" उत्पन्न करने के लिए उप-वर्गीकरण का उपयोग करता है - जो आवश्यक रूप से ऑब्जेक्ट्स नहीं है । जीओएफ उदाहरण में बिल्डर का टेक्स्ट आउटपुट (मार्कअप या अन्यथा) उत्पादन होता है।

अन्य दो के विपरीत फैक्टरी विधि पैटर्न, "निर्माता" को एक अमूर्त और ठोस कार्यान्वयन में विभाजित करता है (इस प्रकार फ्रेमवर्क कार्यान्वयन से संबंधित इस पर जोर देता है)। सार फैक्ट्री की तरह, यह वास्तविक वस्तुओं को बनाने से संबंधित है।

सभी तीन बहुत समान हैं, क्योंकि वे सब subclassing का उपयोग करें। यह उप-वर्ग है जो उन सभी की उत्कृष्ट गुणवत्ता है, जो सूक्ष्म मतभेदों (ऊपर उल्लिखित) को छुपाता है और इस प्रकार कई लोगों को मतभेदों को देखने में कठिनाई होती है।


एक निर्माता आपको जटिल वस्तु बनाने में मदद करता है। एक उदाहरण स्ट्रिंगबिल्डर वर्ग ( Java , C# ) है, जो टुकड़े द्वारा अंतिम स्ट्रिंग टुकड़ा बनाता है। स्प्रिंग में UriComponentsBuilder का एक बेहतर उदाहरण है, जो आपको यूआरआई बनाने में मदद करता है।

एक फैक्ट्री विधि आपको एक शॉट में एक पूर्ण वस्तु देता है (जैसा कि निर्माता के विपरीत)। एक बेस क्लास एक सार तत्व विधि को परिभाषित करता है जो एक इंटरफ़ेस (या सुपर क्लास) संदर्भ देता है, और वस्तु के ठोस निर्माण को उप-वर्गों में रोक देता है।

एक अमूर्त कारखाना कई अलग-अलग संबंधित वस्तुओं को बनाने के लिए एक इंटरफेस (या अमूर्त वर्ग) है। एक अच्छा उदाहरण (.NET में) DbProviderFactory क्लास है, जो इसके ठोस कार्यान्वयन के आधार पर किसी दिए गए डेटाबेस प्रदाता (ऑरैक, एसक्यूएल सर्वर, ...) को संबंधित ऑब्जेक्ट्स (कनेक्शन, कमांड, ...) बनाने में काम करता है।





factory-method