भंडार पैटर्न: Lazy लोड करने के लिए कैसे? या, मैं इस सकल विभाजित कर देना चाहिए?

Question

भंडार पैटर्न: Lazy लोड करने के लिए कैसे? या, मैं इस सकल विभाजित कर देना चाहिए?

वोट

66

मैं एक डोमेन मॉडल एक संपादक और एक परियोजना की अवधारणा है कि है।

एक संपादक परियोजनाओं के एक नंबर का मालिक है, और एक परियोजना न केवल एक संपादक मालिक, लेकिन यह भी संपादक के सदस्यों की एक संख्या है। इसलिए, एक संपादक भी में शामिल हो गए परियोजनाओं की एक संख्या है।

मैं इस मॉडलिंग और दृढ़ता के लिए भंडार पद्धति का उपयोग कर के लिए एक DDD दृष्टिकोण ले रहा हूँ। हालांकि, मैं निर्धारित करने के लिए मैं यह कैसे करना चाहिए पैटर्न काफी अच्छी तरह से grok नहीं है अभी तक।

मैं इस धारणा है कि संपादक और परियोजना एक ही कुल में संभावित हैं पर काम कर रहा हूँ, रूट संपादक होने के साथ। इसलिए मैं एक संपादक प्राप्त कर सकते हैं और फिर अपनी परियोजनाओं की गणना, और वहाँ से परियोजनाओं 'सदस्य संपादकों की गणना कर सकता है।

हालांकि, अगर मैं सिर्फ अपने भंडार से संपादकों को पुनः प्राप्त करने की अनुमति है, इसका मतलब मैं रिपोजिटरी से सभी परियोजनाओं लोड करने के लिए जब मैं संपादक है कि उन्हें मालिक मिल की जरूरत नहीं है? और अगर मैं सदस्य संपादकों आलसी लोड करना चाहते हैं, परियोजना के रूप में अच्छी तरह से भंडार के लिए एक संदर्भ की जरूरत है?

वैकल्पिक रूप से, अगर मैं कुल विभाजित है और एक संपादक भंडार और एक परियोजना भंडार है, मैं कैसे इस तरह के जब एक नया प्रोजेक्ट एक संपादक में जोड़ा जाता है के रूप में दो भर में लेन-देन, संभाल चाहिए? उदाहरण के लिए:

Editor e = new Editor(Editor Name);
editorRepository.Add(e);

Project p = e.CreateProject(Project Name);
projectRepository.Add(p);    // These two lines
editorRepository.Save(e);    // should be atomic

मैं भंडार पैटर्न के इरादे बदल रहा हूं?

domain-driven-design repository-pattern lazy-loading aggregate ddd-repositories

19/01/2009 को 15:10
उपयोगकर्ता Giraffe

अन्य भाषाओं में...

4 जवाब

वोट

3

यह आपके आवेदन की जरूरतों पर निर्भर करता है। यदि यह एक दिया संपादक के लिए परियोजनाओं के सभी लोड करने के लिए एक बड़ी समस्या है, तो एक तरह एक आलसी लोड हो रहा है पैटर्न की कोशिश वर्चुअल प्रॉक्सी ।

lazily एक परियोजना के सदस्य संपादकों लोड हो रहा है, यदि आप वर्चुअल प्रॉक्सी का उपयोग के बारे में, मैं एक समस्या EditorRepository साथ प्रॉक्सी इंजेक्शन लगाने के बाद से मैं प्रॉक्सी डोमेन का हिस्सा बनने का विचार नहीं करते नहीं दिख रहा।

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

23/01/2009 को 01:45
का स्रोत उपयोगकर्ता moffdub

वोट

4

कैसे एक EditorOwner और एक EditorMember में जिम्मेदारियों के बंटवारे के बारे में?

आपके डोमेन जानने के बिना, मैं कल्पना करता है कि वे अलग ज़िम्मेदारियाँ हैं - उदाहरण के लिए, EditorOwner काफी समृद्ध हो सकता है (और कुल जड़ हो सकता है), लेकिन परियोजना केवल अपने सदस्यों के बारे में एक सीमित मात्रा में पता करने के लिए आवश्यकता हो सकती है, इसलिए EditorMember वस्तु काफी प्रकाश हो सकता है।

इन डोमेन वस्तुओं भी उपयोगकर्ता से संबंधित हो सकती है, लेकिन है कि एक और संदर्भ में किया जाएगा।

कि चीजें मदद करता है, या बस इसे और अधिक जटिल बना?

23/01/2009 को 03:55
का स्रोत उपयोगकर्ता Michael Hart

वोट

0

यहाँ आप 2 अलग रिश्ते, स्वामित्व के लिए एक और सदस्यता के लिए एक है।

स्वामित्व के संबंध में कई के लिए एक सरल एक (प्रत्येक परियोजना के लिए एक मालिक) है। सदस्यता संबंध में कई (परियोजना द्वारा कई संपादकों, संपादक द्वारा कई परियोजनाओं) के लिए कई है।

आप परियोजना वर्ग पर एक मालिक संपत्ति प्रदान करते हैं और एक विशिष्ट संपादक के स्वामित्व वाले सभी परियोजनाओं को पाने के लिए ProjectRepository पर एक विधि प्रदान कर सकता है।

कई रिश्ते के लिए, परियोजना वर्ग पर एक सदस्य संपत्ति प्रदान करते हैं और ProjectRepository पर एक विधि सदस्य के रूप में निर्दिष्ट संपादक युक्त सभी परियोजनाओं को पाने के लिए।

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

11/02/2009 को 12:01
का स्रोत उपयोगकर्ता thinkbeforecoding

ifatree · Accepted Answer · 2009-05-14 03:40

मैं भंडार पैटर्न के इरादे बदल रहा हूं?

मैं कहना है "हाँ" है, लेकिन पता है कि मुझे और हर व्यक्ति मैं के साथ एक ही कारण के लिए एक ही बात कहा है कि काम किया है ... जा रहा हूँ "आप 4 आयामी सोच नहीं कर रहे हैं, मार्टी"।

यह एक छोटे से सरल और निर्माताओं के बजाय पहले तरीकों बनाएं साथ छड़ी करते हैं:

Editor e = new Editor("Editor Name");
e = editorRepository.Add(e);

Project p = new Project("Project Name", e);
p = projectRepository.Add(p);

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

और अगर मैं सदस्य संपादकों आलसी लोड करना चाहते हैं, परियोजना के रूप में अच्छी तरह से भंडार के लिए एक संदर्भ की जरूरत है?

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

IEnumerable<Project> list = projectRepository.GetAllProjects()
                                .Where(x => x.editorId == e.Id);

लेकिन यह जहां डाल करने के लिए? नहीं परियोजना, या संपादक के अंदर, तुम सही हो, या वे खजाने तक पहुँच प्राप्त करना होगा और है कि कोई अच्छा है। ऊपर टुकड़ा शिथिल युग्मित है, लेकिन अपने आप ही पुन: प्रयोज्य नहीं है। तुम बस भंडार पैटर्न की सीमा पहुँच गए हैं।

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

public static class Aggregators
{
    // one to one, easy
    public static Editor GetOwner(this Project p)
    {
        return StaticServiceWrapper.editorRep.GetEditorById(p.editorId);
    }

    // one to many, medium
    public static IEnumerable<Project> GetProjects(this Editor e) 
    { 
        return StaticServiceWrapper.projectRep.GetAllProjects()
                .Where(x => x.editorId == e.Id);
    }

    // many to many, harder
    public static IEnumerable<Editor> GetMembers(this Project p)
    {
        var list = StaticServiceWrapper.projectMemberMap.GetAllMemberMaps()
                        .Where(x => x.projectId == p.projectId);

        foreach ( var item in list )
            yield return StaticServiceWrapper.editorRep.GetEditorById(item.editorId);
    }
}

मूल रूप से, एक बार अपने GetAll, GetById, जोड़ें, अपडेट, निकालें वस्तु भंडार से किया जाता है, तो आप संघों अकेला छोड़ने के लिए मिल गया है और ऊपर एडेप्टर और कैश और व्यापार तर्क (जैसे मज़ा भागों में वस्तु / परत पदानुक्रम पर ले जाने के "ओह , मेरे! " )।