शब्दकोश दो कुंजी के साथ?

Question

मैं कंसोल में मूल्यों का ट्रैक रख रहा हूं। एक दूसरे के खिलाफ दो लोग "द्वंद्व" और मैं नुकसान के साथ दर्ज नाम रखने के लिए एक शब्दकोश का उपयोग कर रहा था।

var duels = new Dictionary<string, string>(); 
duels.Add("User1", "50"); 
duels.Add("User2","34"); 

मैं एक ही शब्दकोश पंक्ति में दोनों उपयोगकर्ताओं स्टोर करने के लिए कोशिश कर रहा हूँ, इसलिए User 1 के रूप में User2 के खिलाफ dueling है यह सत्यापित किया जा सकता। इस तरह अगर एक और द्वंद्वयुद्ध शुरू हुआ, तो यह User1 या User2 में हस्तक्षेप नहीं करेगा।

duels.Add("KeyUser1","KeyUser2","50","34",.../*Other attributes of the duel*/); 

मुझे दो चाबियाँ चाहिए ताकि मैं जांच सकूं कि उपयोगकर्ता का नुकसान कहां जाएगा। नुकसान हमेशा दूसरी कुंजी पर जाएगा - इसके विपरीत। यह काम करने के लिए मैं क्या कर सकता हूं?

धन्यवाद।

Answer 1

public class Duel 
{ 
    public string User1 {get; protected set;} 
    public string User2 {get; protected set;} 
    public Duel(string user1, string user2) 
    { 
    User1 = user1; 
    User2 = user2; 
    } 

    public HashSet<string> GetUserSet() 
    { 
    HashSet<string> result = new HashSet<string>(); 
    result.Add(this.User1); 
    result.Add(this.User2); 
    return result; 
    } 

    //TODO ... more impl 
} 

चलिए कुछ युगल बनाते हैं। CreateSetComparer शब्दकोश को पर समानता परीक्षण के लिए सेट के मानों का उपयोग करने की अनुमति देता है।

List<Duel> duelSource = GetDuels(); 
Dictionary<HashSet<string>, Duel> duels = 
    new Dictionary<HashSet<string>, Duel>(HashSet<string>.CreateSetComparer()); 

foreach(Duel d in duelSource) 
{ 
    duels.Add(d.GetUserSet(), d); 
} 

और एक द्वंद्वयुद्ध खोजने:

HashSet<string> key = new HashSet<string>(); 
key.Add("User1"); 
key.Add("User2"); 
Duel myDuel = duels[key]; 

Answer 2

आप कुंजी के लिए एक कस्टम डेटा प्रकार बनाने की कोशिश कर सकते:

class DualKey<T> : IEquatable<DualKey<T>> where T : IEquatable<T> 
{ 
    public T Key0 { get; set; } 
    public T Key1 { get; set; } 

    public DualKey(T key0, T key1) 
    { 
     Key0 = key0; 
     Key1 = key1; 
    } 

    public override int GetHashCode() 
    { 
     return Key0.GetHashCode()^Key1.GetHashCode(); 
    } 

    public bool Equals(DualKey<T> obj) 
    { 
     return (this.Key0.Equals(obj.Key0) && this.Key1.Equals(obj.Key1)) 
      || (this.Key0.Equals(obj.Key1) && this.Key0.Equals(obj.Key0)); 
    } 
} 

फिर एक Dictionary<DualKey<string>, string> का उपयोग करें;

Answer 3

कुछ तेज़।

class UserScores { 

    public string Key { get; set; } 

    public int User1Score { get; set; } 
    public int User2Score { get; set; } 

    public UserScores(string username1, string username2) 
    { 
      Key = username1 + ":" + username2; 
    } 
} 

void Main() 
{ 
    var userScore = new UserScores("fooUser", "barUser"); 

    var scores = new Dictionary<string, UserScores>(); 

    scores.Add(userScore.Key, userScore); 

    // Or use a list 

    var list = new List<UserScores>(); 

    list.Add(userScore); 

    list.Single (l => l.Key == userScore.Key); 
} 

हालांकि मेरी राय में एक उचित समाधान उपयोगकर्तास्कोर्स ऑब्जेक्ट को बेहतर विचारों का उपयोग करेगा जो उस विशेष "द्वंद्व" सत्र को ट्रैक करता है।

Answer 4

के बाद से एक भी व्यक्ति एक समय में ज़्यादा से ज़्यादा एक द्वंद्वयुद्ध में शामिल किया जा सकता है, आप एक ही शब्दकोश का उपयोग कर सकते सीधे "अनुक्रमणिका" दोनों अंतिमबिंदुओं को सभी duels में, कुछ इस तरह:

class Duel { 

    public Duel(string user1, string user2) { 
     Debug.Assert(user1 != user2); 
     User1 = user1; 
     User2 = user2; 
    } 

    public readonly string User1; 
    public readonly string User2; 
    public int User1Score; 
    public int User2Score; 

} 

class Program { 

    static void Main(string[] args) { 

     var dict = new Dictionary<string, Duel>(); 

     // Add a new duel. A single duel has two keys in the dictionary, one for each "endpoint". 
     var duel = new Duel("Jon", "Rob"); 
     dict.Add(duel.User1, duel); 
     dict.Add(duel.User2, duel); 

     // Find Jon's score, without knowing in advance whether Jon is User1 or User2: 
     var jons_duel = dict["Jon"]; 
     if (jons_duel.User1 == "Jon") { 
      // Use jons_duel.User1Score. 
     } 
     else { 
      // Use jons_duel.User2Score. 
     } 

     // You can just as easily find Rob's score: 
     var robs_duel = dict["Rob"]; 
     if (robs_duel.User1 == "Rob") { 
      // Use robs_duel.User1Score. 
     } 
     else { 
      // Use robs_duel.User2Score. 
     } 

     // You are unsure whether Nick is currently duelling: 
     if (dict.ContainsKey("Nick")) { 
      // Yup! 
     } 
     else { 
      // Nope. 
     } 

     // If Jon tries to engage in another duel while still duelling Rob: 
     var duel2 = new Duel("Jon", "Nick"); 
     dict.Add(duel2.User1, duel); // Exception! Jon cannot be engaged in more than 1 duel at a time. 
     dict.Add(duel2.User2, duel); // NOTE: If exception happens here instead of above, don't forget remove User1 from the dictionary. 

     // Removing the duel requires removing both endpoints from the dictionary: 
     dict.Remove(jons_duel.User1); 
     dict.Remove(jons_duel.User2); 

     // Etc... 

    } 

} 

यह सिर्फ एक मूल विचार है, आप अपने खुद के वर्ग में इस कार्यक्षमता लपेटकर पर विचार हो सकता ...