आप यह कैसे बता सकते हैं कि कम्पोजिट पैटर्न या ट्री स्ट्रक्चर का उपयोग करना है या तीसरा कार्यान्वयन?

Question

मेरे पास दो क्लाइंट प्रकार हैं, एक " ऑब्जर्वर "-टाइप और एक " सब्जेक्ट "-टाइप। वे दोनों समूहों के एक पदानुक्रम के साथ जुड़े हुए हैं ।

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

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

हालांकि, जब विषय डेटा बनाता है, तो यह जांचना होगा कि क्या सभी प्रभावित पर्यवेक्षकों के पास कोई डेटा है जो इस से टकराता है , जिसका अर्थ है एक विशाल पुनरावर्ती कार्य, जहां तक ​​मैं समझ सकता हूं।

इसलिए मुझे लगता है कि इस तथ्य को संक्षेप में प्रस्तुत किया जा सकता है कि मुझे एक पदानुक्रम करने में सक्षम होने की आवश्यकता है कि आप ऊपर और नीचे जा सकते हैं , और कुछ स्थान उन्हें संपूर्ण रूप से (पुनरावृत्ति, मूल रूप से) मान सकते हैं।

इसके अलावा, मैं सिर्फ एक समाधान पर काम नहीं कर रहा हूं। मैं एक ऐसा समाधान खोजने की उम्मीद कर रहा हूं जो अपेक्षाकृत कम समझने में आसान हो (आर्किटेक्चर-वार कम से कम) और साथ ही इतना लचीला हो कि भविष्य में आसानी से अतिरिक्त कार्यक्षमता प्राप्त कर सके।

क्या इस समस्या या इसी तरह की पदानुक्रम समस्याओं को हल करने के लिए एक डिज़ाइन पैटर्न, या एक अच्छा अभ्यास है?

संपादित करें :

यहाँ डिजाइन मेरे पास है:

"फीनिक्स" -क्लास को इस तरह नामित किया गया है क्योंकि मैंने अभी तक एक उपयुक्त नाम के बारे में नहीं सोचा था।

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

---

एक छोटे से विषय :

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

Comments

यह एक ग्राफ सिद्धांत समस्या की तरह लगता है। इसलिए हमारे पास समूहों के पदानुक्रम का प्रतिनिधित्व करने वाले कुछ डिग्राफ हैं। प्रत्येक समूह ग्राफ में एक शीर्ष है। क्या गुण सत्य हैं? क्या यह सच है कि हमेशा n0 की डिग्री के साथ एक अद्वितीय शीर्ष मौजूद होता है जबकि हर दूसरे शीर्ष पर कम से कम 1 की डिग्री होती है? क्या हर शिखर से जुड़ा है n? nअद्वितीय के लिए रास्ता है ? यदि आप डेटा संरचना के गुणों को सूचीबद्ध कर सकते हैं और इसके संचालन को एक इंटरफेस में सार कर सकते हैं - विधियों की एक सूची - हम (आई) उक्त डेटा संरचना के कार्यान्वयन के साथ आने में सक्षम हो सकते हैं।

आपकी प्रतिक्रिया के लिए धन्यवाद। पर्यवेक्षकों के अलावा समूहों के कई पदानुक्रम हैं, जो एक-दूसरे से जुड़े नहीं हैं, लेकिन मुझे नहीं लगता कि वे ग्राफ़ ऑब्जेक्ट्स का एक हिस्सा हैं, उनके पास केवल उनके कोने में लिंक है। पदानुक्रम में प्रत्येक समूह में केवल 1 माता-पिता हो सकते हैं, लेकिन 0 .. * बच्चे। आप इसे एक ग्राफ में कैसे लागू करेंगे? और केवल 1 समूह के साथ एक पदानुक्रम में 0. की एक डिग्री होगी। 2-समूह-पदानुक्रम और बड़े के लिए वे सभी में एक समान- और बाहर की डिग्री कम से कम 1. मैं सूची की कोशिश करूँगा यह प्रासंगिक तरीके हैं एक घंटे में, जब मैं काम पर हूँ।

तो क्या समूह C # में सबक्लासिंग की तरह काम करते हैं: आप एक आधार वर्ग को उप-वर्ग कर सकते हैं, इस अपवाद के साथ कि एक जंगल है (अर्थात पेड़ों की कटाई)? यदि आप सभी बिंदुओं / संदर्भों को जोड़ते हैं, तो स्पष्ट रूप से आपके पास एक ग्राफ है, पहले से ही - आपको कुछ और करने की आवश्यकता नहीं है। यद्यपि, यदि आप कुशलतापूर्वक संचालन करना चाहते हैं जैसे "क्या ये दोनों समूह एक ही पदानुक्रम में हैं?" "इन दो समूहों के लिए सामान्य पूर्वज क्या है?" आदि। आपको संरचना के बारे में पहले से ज्ञात सभी चीजों का लाभ उठाने के लिए व्यवस्थित रूप से विश्लेषण की आवश्यकता है।

अब जब मैंने आपका आरेख देखा है, तो आपका प्रश्न क्या है - यदि यह डिज़ाइन दृष्टिकोण के बारे में है, तो मैं वास्तव में इस बिंदु पर आपकी मदद नहीं कर सकता, क्योंकि मैं विभिन्न डिजाइन विधियों में नया हूं, खुद। हालाँकि, यदि आप O(n)एक अच्छी तरह से परिभाषित डेटा संरचना के लिए कुशल एल्गोरिदम की तलाश कर रहे हैं जो मैं उस पर काम कर सकता हूं। मैं देख रहा हूँ कि आपने किसी भी उत्परिवर्तन विधियों Groupऔर पदानुक्रमों की संरचना में नहीं डाला । क्या मैं यह मान सकता हूं कि ये स्थिर होंगे?

@ मलाईची मुझे कोई उत्तर नहीं मिला। दुर्भाग्य से मेरे पास पूरी तरह से इसकी जांच करने का समय नहीं था और मुझे कुछ और करना पड़ा। मेरे पास अब इस पर ध्यान देने का समय नहीं है, लेकिन मैं हर बार एक बार में मेरी सूचनाओं की जाँच करना सुनिश्चित करूँगा - और यदि कोई अच्छा व्यवहार्य उत्तर देता है, तो मैं इसे स्वीकार करूँगा।

— एसके

Answer 1

यहां एक सरल "समूह" कार्यान्वयन है जो आपको रूट पर नेविगेट करने और संग्रह के रूप में उस रूट के पेड़ को नेविगेट करने की अनुमति देता है।

public class Group
{
  public Group Parent
  public List<Group> Children

  public IEnumerable<Group> Parents()
  {
    Group result = this;
    while (result.Parent != null)
    {
      result = result.Parent;
      yield return result;
    }
  }
  public Group Root()
  {
    return Parents.LastOrDefault() ?? this;
  }


  public IEnumerable<Group> WalkTreeBreadthFirst(
  {
    //http://en.wikipedia.org/wiki/Breadth-first_search
    HashSet<Group> seenIt = new HashSet<Group>()
    Queue<Group> toVisit = new Queue<Group>();
    toVisit.Enqueue(this);

    while (toVisit.Any())
    {
      Group item = toVisit.Dequeue();
      if (!seenIt.Contains(item))
      {
        seenIt.Add(item);
        foreach (Group child in item.Children)
        {
          toVisit.Enqueue(child);
        }
        yield return item;
      }
    }
  }

  public static IEnumerable<Group> WalkTreeDepthFirst()
  {
    // http://en.wikipedia.org/wiki/Depth-first_search
    HashSet<Group> seenIt = new HashSet<Group>();
    Stack<Group> toVisit = new Stack<Group>();

    toVisit.Push(this);

    while (toVisit.Any())
    {
      Group item = toVisit.Pop();
      if (!seenIt.Contains(item))
      {
        seenIt.Add(item);
        foreach (Group child in item.Children.Reverse())
        {
          toVisit.Push(child);
        }
        yield return item;
      }
    }
  }
}

तो - एक समूह दिया गया है, आप उस समूह के पेड़ पर चल सकते हैं:

Group myGroup = GetGroup();
Group root = myGroup.Root;
foreach(Group inTree in root.WalkTreeBreadthFirst())
{
  //do something with inTree Group.
}

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

Answer 2

सीमित दृश्य के साथ हमारे पास आपके सिस्टम के उपयोग या कार्यान्वयन आवश्यकताओं के लिए बहुत विशिष्ट होना मुश्किल है। उदाहरण के लिए, जो चीजें ध्यान में आएंगी वे हो सकती हैं:

• क्या सिस्टम अत्यधिक समवर्ती (बहुत सारे उपयोगकर्ता) है?
• डेटा एक्सेस का रीड / राइट रेशियो क्या है? (उच्च पढ़ें, कम लिखना आम है)

पैटर्न आदि के रूप में, मुझे इस बात की कम चिंता होगी कि आपके समाधान में कौन से पैटर्न सही हैं, और वास्तविक समाधान के डिजाइन के बारे में अधिक। मुझे लगता है कि डिज़ाइन पैटर्न का ज्ञान उपयोगी है, लेकिन सभी का नहीं और अंत का: सभी एक लेखक सादृश्य का उपयोग करने के लिए, डिज़ाइन पैटर्न आमतौर पर देखे जाने वाले वाक्यांशों के शब्दकोश की तरह अधिक होते हैं, वाक्यों के शब्दकोश के बजाय आपको एक पूरी किताब लिखनी चाहिए। से।

आपका चित्र आम तौर पर मुझे ठीक लगता है।

वहाँ एक तंत्र है जिसका आपने उल्लेख नहीं किया है और जो आपके पदानुक्रम में किसी प्रकार का कैश है। जाहिर है कि आपको इसे बहुत सावधानी से लागू करना चाहिए, लेकिन यह आपके सिस्टम के प्रदर्शन में काफी सुधार कर सकता है। यहाँ इस पर एक सरल ले (कैवेट एम्प्टर) है:

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

मुझे नहीं पता कि यह आपके सिस्टम में कितना उचित है, लेकिन विचार करने लायक हो सकता है।

इसके अलावा, SO पर यह प्रश्न प्रासंगिक हो सकता है:

/programming/1567935/how-to-do-inheritance-modeling-in-relational-databases

Answer 3

मुझे पता है कि यह एक प्रकार की बात है, लेकिन मैं इसे वैसे भी कहने जा रहा हूं, मुझे लगता है Observer Pattern कि आपको इस बात का उल्लेख करना चाहिए कि आपके पास एक ऑब्जर्वर टाइप है और आपने मुझे किस तरह का ऑब्जर्वर पैटर्न पसंद किया है।

लिंक की जोड़ी:

DoFactory

oodesign

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