Từ điển có hai phím?

Question

Tôi đang theo dõi các giá trị trong bảng điều khiển. Hai người "đấu tay đôi" với nhau và tôi đang sử dụng một cuốn từ điển để giữ những cái tên được ghi lại cùng với những thiệt hại đã làm.

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

Tôi đang cố gắng lưu trữ cả hai người dùng trong cùng một hàng từ điển, do đó có thể xác minh được khi User1 đang đấu với User2. Bằng cách này, nếu một trận đấu khác bắt đầu, nó sẽ không ảnh hưởng đến User1 hoặc User2.

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

Tôi cần hai khóa để tôi có thể kiểm tra xem thiệt hại của người dùng sẽ đi đến đâu. Thiệt hại sẽ luôn đi đến chìa khóa khác - ngược lại. Tôi có thể làm gì để thực hiện công việc này?

Cảm ơn bạn.

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 
} 

Hãy thực hiện một số cuộc đấu tay đôi. CreateSetComparer cho phép từ điển sử dụng giá trị của tập hợp để kiểm tra bình đẳng.

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); 
} 

Và việc tìm kiếm một trận đấu:

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

Answer 2

Bạn có thể thử thực hiện một kiểu dữ liệu tùy chỉnh cho phím:

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)); 
    } 
} 

Sau đó sử dụng một Dictionary<DualKey<string>, string>;

Answer 3

Thứ gì đó nhanh chóng.

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); 
} 

Mặc dù giải pháp phù hợp theo ý kiến ​​của tôi sẽ sử dụng tốt hơn đối tượng UserScores theo dõi phiên "đấu tay đôi" cụ thể đó.

Answer 4

Từ một người duy nhất có thể được tham gia vào nhiều nhất là một trận đấu tại một thời điểm, bạn có thể sử dụng một từ điển duy nhất để trực tiếp "chỉ số" cả các điểm cuối trong tất cả các tranh chấp tay đôi, một cái gì đó như thế này:

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... 

    } 

} 

Đây chỉ là một ý tưởng cơ bản, bạn có thể xem xét gói chức năng này trong lớp học của riêng bạn ...