सी # फैक्टरी - एक उथल-पुथल है?

Question

क्या सी # फैक्टरी पैटर्न को अपस्टास्ट की आवश्यकता है?

मैं कक्षा पुस्तकालय में ईश्वर चाहता हूं जी कक्षा पुस्तकालय में एडम बनाने के लिए ए पर निर्भर करता है ए। ई पर निर्भर करता है ई भगवान कक्षा पुस्तकालय ई में ईव द्वारा खपत के लिए एडम्स का उत्पादन करता है, और यह हव्वा को एडम पर जानना और निर्भर होना ठीक है। (संपादित करें - इस नमूने को बेहतर और बेहतर होता जाता है :)

समाधान मैं के ए में एक AdamFactory इस तरह AdamFactory एडम जानता है और आसानी से बस एडम निर्माता बुला) द्वारा यह बना सकते हैं (संभवतः रहा है सोच सकता है। भगवान को एडम फैक्ट्री प्राप्त होती है और इसे एडैम बनाने के लिए ऑर्डर कर सकती है।

अब, क्योंकि भगवान को एडम को जानने की अनुमति नहीं है, एडमफैकोटरी के CreateAdam को एक वस्तु वापस करनी होगी, और इसके लिए हव्वा को एडम को आर्टफैक्टरी द्वारा लौटाई गई ऑब्जेक्ट को अप-कलाकार करने की आवश्यकता है।

यह काम करेगा, मुझे लगता है। हालांकि, मैं अप-कास्टिंग के बारे में असहज महसूस करता हूं क्योंकि यह नो-नो है। क्या यह वास्तव में एक जरूरी है?

पीएस - कोई निंदा करने का इरादा नहीं है, और अगर किसी की भावनाओं को चोट पहुंची तो मैं क्षमा चाहता हूं। यह सृष्टिकर्ता के बजाय भगवान और आदम का उपयोग करना बेहतर लग रहा था और बनाया गया क्योंकि दो बाद वाले शब्द एक-दूसरे के समान हैं।

संपादित करें: पुन: इंटरफेस सुझाव। आइए मान लें कि एडम के दो तरीके हैं: ProvideLove, ProvideFood और ProvideProtection (हम इस नमूना को सुरक्षित रखते हैं :)। हव्वा इन दो उद्देश्यों के लिए आदम का उपयोग करता है, लेकिन निश्चित रूप से भगवान नहीं करता है। तो भगवान को ज्ञान के साथ क्यों प्रदान करें कि एडमफैक्टर कुछ ऐसा करता है जो आईएडएम लागू करता है न केवल एक वस्तु? मुझे यह नहीं मिला!

संपादित करें: काम कर कोड (समान पुस्तकालय में हर कोई है, जो मेरा लक्ष्य विभिन्न पुस्तकालयों के लिए अलग करने के लिए है के साथ) इस तरह दिखता है:

Adam God.LoadAdam(AdamID theAdamID) 
     var adam = new Adam(theAdamId, this) 

Adam.Adam(AdamID theAdamID, God theGod) 
     _god = theGod 
     _mind = theGod.LoadMind(theAdamId, this) 

Mind God.LoadMind (AdamID theAdamID, Adam theAdam) 
     var mind = new Mind (theAdam) 
     var mindId = new minId(theAdamId) 
     mind.DeserializeFromFile(minId) 

Mind.Mind (Adam theAdam) 
     _adam = theAdam 

Answer 1

मुझे यकीन है कि नहीं मैं पूरी तरह से आवश्यकताओं को समझते हैं लेकिन यहाँ हूँ एक सुझाव है

//Somewhere in assembly E 
Adam adam = new God().Create(new AdamFactory()); 

Answer 2

क्या इंटरफेस का उपयोग कर तो भगवान IAdam, या कुछ जानता है के बारे में IHuman की तरह?

Answer 3

मुझे लगता है कि आप निर्भरता इंजेक्शन का उपयोग कर सकते हैं। एक उलटा नियंत्रण (आईओसी) कंटेनर जैसे Unity 2, StructureMap, या Castle of Windsor के साथ प्रयास करें।

Answer 4

आप abstract factory pattern का वर्णन कर रहे हैं, हालांकि "बच्चे" कारखानों (जैसे एडमफैक्टरी) में आम तौर पर कुछ सामान्य होता है, इसलिए आप उम्मीद करते हैं कि वे किसी ऑब्जेक्ट की बजाय एक सामान्य इंटरफ़ेस की तरह कुछ और उत्पादन करें (डेविड के उत्तर देखें)

आप ऊपर डाली बारे में चिंता करने के बाद से है कि आदम के कार्यान्वयन जो एक कारखाने के प्रयोजन धरा (जब तक आप वास्तव में एक बिल्डर के रूप में यह प्रयोग कर रहे हैं) के लिए पूर्व संध्या टाई होगा सही हो।

प्रश्न क्यों तुम सब पर भगवान वर्ग की क्या ज़रूरत है, है?

//in assembly G 
public abstract class HumanFactory<T> 
{ 
    public abstract T CreateHuman(); 
} 

//in assembly A 
public class Adam { } 
//in assembly A 
public class AdamFactory : HumanFactory<Adam> 
{ 
    public override Adam CreateHuman() 
    { 
     return new Adam(); 
    } 
} 

//in assembly G 
public class God 
{ 
    public T Create<T>(HumanFactory<T> factory) 
    { 
     return factory.CreateHuman(); 
    } 
} 

और उपयोग:

Answer 5

ठीक है, अगर भगवान एक हठ वर्ग पुस्तकालय के रूप में आप में उल्लेख किया है टिप्पणी, तो यह शेष प्रणाली के वर्ग डिजाइन को प्रभावित नहीं करना चाहिए।

तो, मैं अनावश्यक इंटरफेस नहीं जोड़ना होगा। बाद में deserializer और डाउनकास्ट से एक वस्तु वापस करने के लिए ठीक है (उदा।बाइनरीफॉर्मेटर, एक्सएमएलएसरियललाइज़र)।

बेहतर तरीका आपके deserializer जेनेरिक बनाना होगा।

Answer 6

ठीक है, यहां कुछ जेनेरिकों में छिड़कने के बारे में क्या है? एक सार वर्ग

interface IFactory { 
    Type CreatedType { get; } 
    object Create(); 
} 

इस लागू करने के लिए कुछ ऐसा दिखाई देगा:

के भगवान किसी भी प्रकार के टी के कारखानों जो निम्न इंटरफ़ेस का पालन स्वीकार कर सकते हैं मान लीजिए

abstract class AbstractFactory<T> : IFactory { 
    public Type CreatedType { get { return typeof(T); } 
    public virtual object Create() { 
    return innerCreate(); 
    } 
    protected abstract override T innerCreate(); 
} 

अब, आप कर सकते हैं भगवान के साथ कारखानों को पंजीकृत करें:

God.RegisterFactory(new AdamFactory()); 

एडमफ़ैक्टरीसे विरासत में विरासत

God.Create<Adam>(); 

भगवान अपने कारखानों में लग रहा है, वहाँ देखता है:

भगवान एक शब्दकोश में अपनी कारखानों जहां कुंजी प्रकार IFactory इंटरफ़ेस

बनाएं विधि कि अब की तरह लग रहा द्वारा दिया है संग्रहीत करता है जेनेरिक विधि के टाइपऑफ (टी) के लिए एक है, कारखाने को पुनर्प्राप्त करता है, टी

पर आपको बनाने और डाउनकास्ट कॉल करता है। आपको क्या लगता है?