ओओपी

Question

में कई से अधिक रिश्ते कई से अधिक रिश्तों को मॉडल करने का सबसे अच्छा तरीका क्या है?

की सुविधा देता है कहते हैं कि हम एक दो वर्गों, टीम और खिलाड़ी है

• किसी भी खिलाड़ी कई टीम रों
• किसी भी टीम में हो सकता है के रूप में कई हो सकता है प्लेयर एस जैसे वे

मैं

• playerX.getTeamList() तरह के तरीकों कॉल करने के लिए
• teamY.getPlayerList() में सभी टीम रों वह/वह है की सूची प्राप्त करने टीम में सभी प्लेयर रों की सूची प्राप्त करने की तरह है

(या यह प्रभावी रूप से करने के लिए किसी अन्य तरीके से किया है)

मैं tw के बारे में सोच सकते हैं ओ ऐसा करने के तरीके, लेकिन वे सिर्फ अच्छे ओप पैटेंस की तरह महसूस नहीं करते हैं। क्या आप किसी भी अच्छे तरीके, शायद एक डिजाइन पैटन के बारे में सोच सकते हैं?

Answer 1

यह ठीक है, PlayerTeam और Team का संग्रह है Player का संग्रह है। क्योंकि वे "परमाणु"

Answer 2

public class Player 
{ 
    public Team[] Teams {get;set;} 
} 

public class Team 
{ 
    public Player[] Players {get;set;} 
} 

पूरी तरह से उचित नहीं हैं आप,/जोड़ने में ईमानदारी के बारे में सावधान रहना संचालन को दूर करने की जरूरत है।

Answer 3

एपीआई वास्तविक कार्यान्वयन से महसूस करने के लायक है।

हालांकि दोनों वर्गों के लिए इस तरह के संग्रह (जैसे * सूची *) प्राप्त करने के लिए यह समझ में आता है, उन्हें संग्रह के उदाहरण को पकड़ने की आवश्यकता नहीं है।

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

Answer 4

आईएमएचओ जो आप वर्णन करते हैं वह ओओ के लिए "प्राकृतिक" तरीका है। आपका XXX.getXXXList() आपकी कक्षाओं का इंटरफ़ेस है। और कक्षाओं की एक सीमा संख्या के लिए जो सही तरीका होगा।

विचार करें कि 1000 कक्षाएं हैं जो "अंतःस्थापित" हो सकती हैं। किसी ऑब्जेक्ट में ड्रॉप करने के लिए कुछ ManyToManyManager होना दिलचस्प हो सकता है, किसी ऑब्जेक्ट की संबंधित ऑब्जेक्ट्स में एक और ऑब्जेक्ट जोड़ें और किसी अन्य को रिलीज़ की गई सभी ऑब्जेक्ट्स की सूची पुनर्प्राप्त करें। यह कुछ प्रकार के प्रतिनिधिमंडल बनाम कार्यान्वयन होगा।

अगर आप अपने कई से कई लोगों को दूसरे उदाहरण में प्रतिनिधि देते हैं तो शोर करें कि आपका ऑब्जेक्ट मॉडल अब कई से अधिक रिलेशनशिप को प्रतिबिंबित नहीं करता है।

Answer 5

विल से उत्तर सही है। हालांकि, समन्वयन से निपटने के लिए, शायद मैं ObservableCollection से शुरू करूंगा। रिश्ते का एक पक्ष "मास्टर" होना चाहिए जो दूसरी ओर जोड़/हटा देता है और सिंक्रनाइज़ेशन के साथ सौदों को ट्रैक करता है।

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

Answer 6

खिलाड़ियों और टीमों के बीच संबंध Bipartite Graph के बीच संबंध। टिप्पणियों की अपेक्षा (और डाउनवॉट्स?)! मैं ओओडी नोब हूँ।

class MyPlayer 
    { 
     public string Name { get; set; } 

     public MyPlayer(string n) 
     { 
      Name = n; 
     } 
    } 

    class MyTeam 
    { 
     public string Name { get; set; } 

     public MyTeam(string n) 
     { 
      Name = n; 
     } 
    } 

    class PlayerTeamPair 
    { 
     public MyPlayer Player { get; set; } 
     public MyTeam Team { get; set; } 

     public PlayerTeamPair(MyPlayer p,MyTeam t) 
     { 
      Player = p; 
      Team = t; 
     } 
    } 

    class PlayerTeamBipartiteGraph 
    { 
     public List<PlayerTeamPair> Edges { get; set; } 

     public PlayerTeamBipartiteGraph() 
     { 
      Edges = new List<PlayerTeamPair>(); 
     } 

     public void AddPlayerAndTeam(MyPlayer p, MyTeam t) 
     { 
      Edges.Add(new PlayerTeamPair(p, t)); 
     } 

     public List<MyTeam> GetTeamList(MyPlayer p) 
     { 
      var teams = from e in Edges where e.Player == p select e.Team; 
      return teams.ToList<MyTeam>(); 
     } 

     public List<MyPlayer> GetPlayerList(MyTeam t) 
     { 
      var players = from e in Edges where e.Team == t select e.Player; 
      return players.ToList<MyPlayer>(); 
     } 

    } 


    class Program 
    { 
     static void Main(string[] args) 
     { 
      var G = new PlayerTeamBipartiteGraph(); 

      MyPlayer a = new MyPlayer("A"); 
      MyPlayer b = new MyPlayer("B"); 
      MyPlayer c = new MyPlayer("C"); 
      MyPlayer d = new MyPlayer("D"); 

      MyTeam t1 = new MyTeam("T1"); 
      MyTeam t2 = new MyTeam("T2"); 

      G.AddPlayerAndTeam(a, t1); 
      G.AddPlayerAndTeam(b, t1); 
      G.AddPlayerAndTeam(c, t1); 
      G.AddPlayerAndTeam(b, t2); 
      G.AddPlayerAndTeam(d, t2); 

      G.GetTeamList(b).ForEach(t => Console.Write(" {0} ",t.Name)); 
      Console.WriteLine(); 
      G.GetPlayerList(t2).ForEach(p => Console.Write(" {0} ",p.Name)); 
      Console.WriteLine(); 
     } 
    } 

Answer 7

कई से कई रिश्ते को दो-से-कई में विभाजित करें। सब कुछ बहुत आसान बनाता है।