Khóa trùng lặp trong từ điển .NET?

Có bất kỳ lớp từ điển nào trong thư viện lớp cơ sở .NET cho phép sử dụng các khóa trùng lặp không? Giải pháp duy nhất tôi tìm thấy là tạo ra, ví dụ, một lớp như:

Dictionary<string, List<object>>

Nhưng điều này là khá khó chịu để thực sự sử dụng. Trong Java, tôi tin rằng MultiMap thực hiện điều này, nhưng không thể tìm thấy một tương tự trong .NET.

Nếu bạn đang sử dụng .NET 3.5, hãy sử dụng Lookuplớp.

EDIT: Bạn thường tạo ra Lookupbằng cách sử dụng Enumerable.ToLookup. Điều này không cho rằng bạn không cần thay đổi nó sau đó - nhưng tôi thường thấy điều đó đủ tốt.

Nếu điều đó không phù hợp với bạn, tôi không nghĩ có gì trong khung sẽ giúp ích - và sử dụng từ điển cũng tốt như vậy :(

Lớp List thực sự hoạt động khá tốt đối với các bộ sưu tập khóa / giá trị có chứa các bản sao mà bạn muốn lặp lại trên bộ sưu tập. Thí dụ:

List<KeyValuePair<string, string>> list = new List<KeyValuePair<string, string>>();

// add some values to the collection here

for (int i = 0;  i < list.Count;  i++)
{
    Print(list[i].Key, list[i].Value);
}

Đây là một cách để làm điều này với Danh sách <KeyValuePair <chuỗi, chuỗi >>

public class ListWithDuplicates : List<KeyValuePair<string, string>>
{
    public void Add(string key, string value)
    {
        var element = new KeyValuePair<string, string>(key, value);
        this.Add(element);
    }
}

var list = new ListWithDuplicates();
list.Add("k1", "v1");
list.Add("k1", "v2");
list.Add("k1", "v3");

foreach(var item in list)
{
    string x = string.format("{0}={1}, ", item.Key, item.Value);
}

Đầu ra k1 = v1, k1 = v2, k1 = v3

Nếu bạn đang sử dụng các chuỗi làm cả khóa và giá trị, bạn có thể sử dụng System.Collections.ecialized.NameValueCollection , sẽ trả về một mảng các giá trị chuỗi thông qua phương thức GetValues ​​(khóa chuỗi).

Tôi vừa đi qua thư viện PowerCollections , trong đó có một lớp gọi là MultiDipedia. Điều này gọn gàng kết thúc loại chức năng này.

Lưu ý rất quan trọng liên quan đến việc sử dụng Tra cứu:

Bạn có thể tạo một thể hiện của một Lookup(TKey, TElement)bằng cách gọi ToLookupmột đối tượng thực hiệnIEnumerable(T)

Không có nhà xây dựng nào để tạo một thể hiện mới của a Lookup(TKey, TElement). Ngoài ra, Lookup(TKey, TElement)các đối tượng là bất biến, nghĩa là, bạn không thể thêm hoặc xóa các thành phần hoặc khóa khỏi một Lookup(TKey, TElement)đối tượng sau khi nó được tạo.

(từ MSDN)

Tôi nghĩ rằng đây sẽ là một điểm dừng chương trình cho hầu hết các mục đích sử dụng.

Tôi nghĩ rằng một cái gì đó như List<KeyValuePair<object, object>>sẽ làm công việc.

Nếu bạn đang sử dụng> = .NET 4 thì bạn có thể sử dụng TupleClass:

// declaration
var list = new List<Tuple<string, List<object>>>();

// to add an item to the list
var item = Tuple<string, List<object>>("key", new List<object>);
list.Add(item);

// to iterate
foreach(var i in list)
{
    Console.WriteLine(i.Item1.ToString());
}

Thật dễ dàng để "cuộn" phiên bản từ điển của riêng bạn cho phép các mục nhập "khóa trùng lặp". Đây là một thực hiện đơn giản thô. Bạn có thể muốn xem xét thêm hỗ trợ cho hầu hết (nếu không phải tất cả) trên IDictionary<T>.

public class MultiMap<TKey,TValue>
{
    private readonly Dictionary<TKey,IList<TValue>> storage;

    public MultiMap()
    {
        storage = new Dictionary<TKey,IList<TValue>>();
    }

    public void Add(TKey key, TValue value)
    {
        if (!storage.ContainsKey(key)) storage.Add(key, new List<TValue>());
        storage[key].Add(value);
    }

    public IEnumerable<TKey> Keys
    {
        get { return storage.Keys; }
    }

    public bool ContainsKey(TKey key)
    {
        return storage.ContainsKey(key);
    }

    public IList<TValue> this[TKey key]
    {
        get
        {
            if (!storage.ContainsKey(key))
                throw new KeyNotFoundException(
                    string.Format(
                        "The given key {0} was not found in the collection.", key));
            return storage[key];
        }
    }
}

Một ví dụ nhanh về cách sử dụng nó:

const string key = "supported_encodings";
var map = new MultiMap<string,Encoding>();
map.Add(key, Encoding.ASCII);
map.Add(key, Encoding.UTF8);
map.Add(key, Encoding.Unicode);

foreach (var existingKey in map.Keys)
{
    var values = map[existingKey];
    Console.WriteLine(string.Join(",", values));
}

Trả lời cho câu hỏi ban đầu. Một cái gì đó giống như Dictionary<string, List<object>>được thực hiện trong một lớp được gọi là MultiMaptrongCode Project .

Bạn có thể tìm thêm thông tin vào liên kết dưới đây: http://www.codeproject.com/KB/cs/MultiKeyDipedia.aspx

NameValueCollection hỗ trợ nhiều giá trị chuỗi dưới một khóa (cũng là một chuỗi), nhưng đó là ví dụ duy nhất tôi biết.

Tôi có xu hướng tạo các cấu trúc tương tự như trong ví dụ của bạn khi tôi gặp phải tình huống tôi cần loại chức năng đó.

Khi sử dụng List<KeyValuePair<string, object>>tùy chọn, bạn có thể sử dụng LINQ để thực hiện tìm kiếm:

List<KeyValuePair<string, object>> myList = new List<KeyValuePair<string, object>>();
//fill it here
var q = from a in myList Where a.Key.Equals("somevalue") Select a.Value
if(q.Count() > 0){ //you've got your value }

Vì C # mới (tôi tin là từ 7.0), bạn cũng có thể làm một cái gì đó như thế này:

var duplicatedDictionaryExample = new List<(string Key, string Value)> { ("", "") ... }

và bạn đang sử dụng nó làm Danh sách tiêu chuẩn, nhưng với hai giá trị được đặt tên theo bất cứ điều gì bạn muốn

foreach(var entry in duplicatedDictionaryExample)
{ 
    // do something with the values
    entry.Key;
    entry.Value;
}

Bạn có nghĩa là đồng dạng và không phải là một bản sao thực tế? Nếu không, một hashtable sẽ không thể làm việc.

Đồng dạng có nghĩa là hai khóa riêng biệt có thể băm với giá trị tương đương, nhưng các khóa không bằng nhau.

Ví dụ: giả sử hàm băm của hashtable của bạn chỉ là hashval = key mod 3. Cả 1 và 4 ánh xạ thành 1, nhưng là các giá trị khác nhau. Đây là nơi mà ý tưởng của bạn về một danh sách phát huy tác dụng.

Khi bạn cần tra cứu 1, giá trị đó được băm thành 1, danh sách được duyệt qua cho đến khi tìm thấy Khóa = 1.

Nếu bạn cho phép chèn các khóa trùng lặp, bạn sẽ không thể phân biệt khóa nào ánh xạ tới giá trị nào.

Cách tôi sử dụng chỉ là một

Dictionary<string, List<string>>

Bằng cách này, bạn có một phím duy nhất chứa một danh sách các chuỗi.

Thí dụ:

List<string> value = new List<string>();
if (dictionary.Contains(key)) {
     value = dictionary[key];
}
value.Add(newValue);

Tôi tình cờ tìm thấy bài đăng này để tìm kiếm cùng một câu trả lời, và không tìm thấy, vì vậy tôi đã tìm ra một giải pháp ví dụ đơn giản bằng cách sử dụng danh sách từ điển, ghi đè toán tử [] để thêm từ điển mới vào danh sách khi tất cả những người khác có khóa đã cho (bộ) và trả về danh sách các giá trị (get).
Nó xấu và không hiệu quả, nó CHỈ lấy / đặt theo khóa và nó luôn trả về một danh sách, nhưng nó hoạt động:

 class DKD {
        List<Dictionary<string, string>> dictionaries;
        public DKD(){
            dictionaries = new List<Dictionary<string, string>>();}
        public object this[string key]{
             get{
                string temp;
                List<string> valueList = new List<string>();
                for (int i = 0; i < dictionaries.Count; i++){
                    dictionaries[i].TryGetValue(key, out temp);
                    if (temp == key){
                        valueList.Add(temp);}}
                return valueList;}
            set{
                for (int i = 0; i < dictionaries.Count; i++){
                    if (dictionaries[i].ContainsKey(key)){
                        continue;}
                    else{
                        dictionaries[i].Add(key,(string) value);
                        return;}}
                dictionaries.Add(new Dictionary<string, string>());
                dictionaries.Last()[key] =(string)value;
            }
        }
    }

Tôi đã thay đổi câu trả lời của @Hector Correa thành một phần mở rộng với các loại chung chung và cũng đã thêm một TryGetValue tùy chỉnh cho nó.

  public static class ListWithDuplicateExtensions
  {
    public static void Add<TKey, TValue>(this List<KeyValuePair<TKey, TValue>> collection, TKey key, TValue value)
    {
      var element = new KeyValuePair<TKey, TValue>(key, value);
      collection.Add(element);
    }

    public static int TryGetValue<TKey, TValue>(this List<KeyValuePair<TKey, TValue>> collection, TKey key, out IEnumerable<TValue> values)
    {
      values = collection.Where(pair => pair.Key.Equals(key)).Select(pair => pair.Value);
      return values.Count();
    }
  }

Đây là một cách kéo theo từ điển đồng thời Tôi nghĩ rằng điều này sẽ giúp bạn:

public class HashMapDictionary<T1, T2> : System.Collections.IEnumerable
{
    private System.Collections.Concurrent.ConcurrentDictionary<T1, List<T2>> _keyValue = new System.Collections.Concurrent.ConcurrentDictionary<T1, List<T2>>();
    private System.Collections.Concurrent.ConcurrentDictionary<T2, List<T1>> _valueKey = new System.Collections.Concurrent.ConcurrentDictionary<T2, List<T1>>();

    public ICollection<T1> Keys
    {
        get
        {
            return _keyValue.Keys;
        }
    }

    public ICollection<T2> Values
    {
        get
        {
            return _valueKey.Keys;
        }
    }

    public int Count
    {
        get
        {
            return _keyValue.Count;
        }
    }

    public bool IsReadOnly
    {
        get
        {
            return false;
        }
    }

    public List<T2> this[T1 index]
    {
        get { return _keyValue[index]; }
        set { _keyValue[index] = value; }
    }

    public List<T1> this[T2 index]
    {
        get { return _valueKey[index]; }
        set { _valueKey[index] = value; }
    }

    public void Add(T1 key, T2 value)
    {
        lock (this)
        {
            if (!_keyValue.TryGetValue(key, out List<T2> result))
                _keyValue.TryAdd(key, new List<T2>() { value });
            else if (!result.Contains(value))
                result.Add(value);

            if (!_valueKey.TryGetValue(value, out List<T1> result2))
                _valueKey.TryAdd(value, new List<T1>() { key });
            else if (!result2.Contains(key))
                result2.Add(key);
        }
    }

    public bool TryGetValues(T1 key, out List<T2> value)
    {
        return _keyValue.TryGetValue(key, out value);
    }

    public bool TryGetKeys(T2 value, out List<T1> key)
    {
        return _valueKey.TryGetValue(value, out key);
    }

    public bool ContainsKey(T1 key)
    {
        return _keyValue.ContainsKey(key);
    }

    public bool ContainsValue(T2 value)
    {
        return _valueKey.ContainsKey(value);
    }

    public void Remove(T1 key)
    {
        lock (this)
        {
            if (_keyValue.TryRemove(key, out List<T2> values))
            {
                foreach (var item in values)
                {
                    var remove2 = _valueKey.TryRemove(item, out List<T1> keys);
                }
            }
        }
    }

    public void Remove(T2 value)
    {
        lock (this)
        {
            if (_valueKey.TryRemove(value, out List<T1> keys))
            {
                foreach (var item in keys)
                {
                    var remove2 = _keyValue.TryRemove(item, out List<T2> values);
                }
            }
        }
    }

    public void Clear()
    {
        _keyValue.Clear();
        _valueKey.Clear();
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return _keyValue.GetEnumerator();
    }
}

ví dụ:

public class TestA
{
    public int MyProperty { get; set; }
}

public class TestB
{
    public int MyProperty { get; set; }
}

            HashMapDictionary<TestA, TestB> hashMapDictionary = new HashMapDictionary<TestA, TestB>();

            var a = new TestA() { MyProperty = 9999 };
            var b = new TestB() { MyProperty = 60 };
            var b2 = new TestB() { MyProperty = 5 };
            hashMapDictionary.Add(a, b);
            hashMapDictionary.Add(a, b2);
            hashMapDictionary.TryGetValues(a, out List<TestB> result);
            foreach (var item in result)
            {
                //do something
            }

tôi sử dụng lớp đơn giản này:

public class ListMap<T,V> : List<KeyValuePair<T, V>>
{
    public void Add(T key, V value) {
        Add(new KeyValuePair<T, V>(key, value));
    }

    public List<V> Get(T key) {
        return FindAll(p => p.Key.Equals(key)).ConvertAll(p=> p.Value);
    }
}

sử dụng:

var fruits = new ListMap<int, string>();
fruits.Add(1, "apple");
fruits.Add(1, "orange");
var c = fruits.Get(1).Count; //c = 2;

Bạn có thể tạo trình bao bọc từ điển của riêng mình, một cái gì đó giống như cái này, như một phần thưởng, nó hỗ trợ giá trị null dưới dạng khóa:

/// <summary>
/// Dictionary which supports duplicates and null entries
/// </summary>
/// <typeparam name="TKey">Type of key</typeparam>
/// <typeparam name="TValue">Type of items</typeparam>
public class OpenDictionary<TKey, TValue>
{
    private readonly Lazy<List<TValue>> _nullStorage = new Lazy<List<TValue>>(
        () => new List<TValue>());

    private readonly Dictionary<TKey, List<TValue>> _innerDictionary =
        new Dictionary<TKey, List<TValue>>();

    /// <summary>
    /// Get all entries
    /// </summary>
    public IEnumerable<TValue> Values =>
        _innerDictionary.Values
            .SelectMany(x => x)
            .Concat(_nullStorage.Value);

    /// <summary>
    /// Add an item
    /// </summary>
    public OpenDictionary<TKey, TValue> Add(TKey key, TValue item)
    {
        if (ReferenceEquals(key, null))
            _nullStorage.Value.Add(item);
        else
        {
            if (!_innerDictionary.ContainsKey(key))
                _innerDictionary.Add(key, new List<TValue>());

            _innerDictionary[key].Add(item);
        }

        return this;
    }

    /// <summary>
    /// Remove an entry by key
    /// </summary>
    public OpenDictionary<TKey, TValue> RemoveEntryByKey(TKey key, TValue entry)
    {
        if (ReferenceEquals(key, null))
        {
            int targetIdx = _nullStorage.Value.FindIndex(x => x.Equals(entry));
            if (targetIdx < 0)
                return this;

            _nullStorage.Value.RemoveAt(targetIdx);
        }
        else
        {
            if (!_innerDictionary.ContainsKey(key))
                return this;

            List<TValue> targetChain = _innerDictionary[key];
            if (targetChain.Count == 0)
                return this;

            int targetIdx = targetChain.FindIndex(x => x.Equals(entry));
            if (targetIdx < 0)
                return this;

            targetChain.RemoveAt(targetIdx);
        }

        return this;
    }

    /// <summary>
    /// Remove all entries by key
    /// </summary>
    public OpenDictionary<TKey, TValue> RemoveAllEntriesByKey(TKey key)
    {
        if (ReferenceEquals(key, null))
        {
            if (_nullStorage.IsValueCreated)
                _nullStorage.Value.Clear();
        }       
        else
        {
            if (_innerDictionary.ContainsKey(key))
                _innerDictionary[key].Clear();
        }

        return this;
    }

    /// <summary>
    /// Try get entries by key
    /// </summary>
    public bool TryGetEntries(TKey key, out IReadOnlyList<TValue> entries)
    {
        entries = null;

        if (ReferenceEquals(key, null))
        {
            if (_nullStorage.IsValueCreated)
            {
                entries = _nullStorage.Value;
                return true;
            }
            else return false;
        }
        else
        {
            if (_innerDictionary.ContainsKey(key))
            {
                entries = _innerDictionary[key];
                return true;
            }
            else return false;
        }
    }
}

Mẫu sử dụng:

var dictionary = new OpenDictionary<string, int>();
dictionary.Add("1", 1); 
// The next line won't throw an exception; 
dictionary.Add("1", 2);

dictionary.TryGetEntries("1", out List<int> result); 
// result is { 1, 2 }

dictionary.Add(null, 42);
dictionary.Add(null, 24);
dictionary.TryGetEntries(null, out List<int> result); 
// result is { 42, 24 }

Bạn có thể định nghĩa một phương thức để xây dựng khóa chuỗi Compound mỗi khi bạn muốn sử dụng từ điển u phải sử dụng phương thức này để xây dựng khóa của bạn chẳng hạn:

private string keyBuilder(int key1, int key2)
{
    return string.Format("{0}/{1}", key1, key2);
}

cho việc sử dụng:

myDict.ContainsKey(keyBuilder(key1, key2))

Các khóa trùng lặp phá vỡ toàn bộ hợp đồng của Từ điển. Trong từ điển, mỗi khóa là duy nhất và được ánh xạ tới một giá trị duy nhất. Nếu bạn muốn liên kết một đối tượng với một số lượng đối tượng bổ sung tùy ý, đặt cược tốt nhất có thể là một cái gì đó tương tự như một Bộ dữ liệu (theo cách nói chung là một bảng). Đặt các khóa của bạn trong một cột và các giá trị của bạn trong cột khác. Điều này chậm hơn đáng kể so với từ điển, nhưng đó là sự đánh đổi của bạn vì mất khả năng băm các đối tượng chính.

Ngoài ra điều này là có thể:

Dictionary<string, string[]> previousAnswers = null;

Bằng cách này, chúng ta có thể có các phím duy nhất. Hy vọng điều này làm việc cho bạn.

Bạn có thể thêm các khóa giống nhau với trường hợp khác nhau như:

key1
Key1
KEY1
KeY1
kEy1
keY1

Tôi biết là câu trả lời giả, nhưng làm việc cho tôi.