C# 列为字典键

Question

I have a dictionary which is keyed by a List:

private Dictionary<List<custom_obj>, string> Lookup;

I'm trying to use ContainsKey, but it doesn't seem to be working, and I have no idea why. Here is the debug information from my Visual Studio Immediate Window:

?Lookup.Keys.ElementAt(7)[0]
{custom_obj}
    Direction: Down
    SID: 2540
?Lookup.Keys.ElementAt(7)[1]
{custom_obj}
    Direction: Down
    SID: 2550
searchObject[0]
{custom_obj}
    Direction: Down
    SID: 2540
searchObject[1]
{custom_obj}
    Direction: Down
    SID: 2550
?Lookup.ContainsKey(searchObject)
false

In my common sense, that last ContainsKey should be true. Hopefully I've included enough information here... any ideas?

Thanks!

Answer 1

The List<custom_obj> instance acting as a key is referentially unequal to the instance referred to by searchObject.

If you want the dictionary to use the values in the list instead of referential equality to find matching keys, you must supply an IEqualityComparer in the constructor of the dictionary (since you can't override Equals and GetHashCode in List<T> ).

Answer 2

You have two separate List s that contain the same elements. The correct way to find out if two lists are equal is with the SequenceEqual method.

You cannot by default do what you are trying to do. You can however, write a custom IEqualityComparer and pass it into the Dictionary constructor.

Here is a sample generic IEqualityComparer :

class ListComparer<T> : IEqualityComparer<List<T>>
{
    public bool Equals(List<T> x, List<T> y)
    {
        return x.SequenceEqual(y);
    }

    public int GetHashCode(List<T> obj)
    {
        int hashcode = 0;
        foreach (T t in obj)
        {
            hashcode ^= t.GetHashCode();
        }
        return hashcode;
    }
}

You may want to improve on the GetHashCode implementation, as this was a quick-and-dirty solution.

Answer 3

This will only work if the actual list instance used in the lookup is the same as the instance that was added as a key. It will not compare the list contents. This is the same behavior you will get if you try to compare two List objects directly.

Answer 4

Are you certain that the instance you are using in your lookup method is the same instance that is among your dictionary's keys? That is the only thing I can think of.

Answer 5

I'm aware that it's been such a long time

But I've been facing this problem recently and I didn't like this HashCode solution and the other that appear in Google where HashCode is being recalculated on .Add() .

Both of those solutions were too slow for me and I decided to try some tree-based approach

Basically my solution represents all those lists as a tree and stores pairs of list's elements and NULL or if that was the last element, then the value

For example, for those lists, the tree will look like:

Key: { 1, 2, 10 }; Value: 30
Key: { 1, 2, 3 }; Value: 50
Key: { 1, 2, 3, 3 }; Value: 70
Key: { 1, 2, 3, 3, 5 }; Value: 80
Key: { 1, 2, 3, 1 }; Value: 100

Here you can see visualization of this tree

enter image description here

If you want longer description / whole source code / nuget, then here:

https://trolololo.xyz/dictionary_with_list_as_key

https://github.com/Swiftly1/DictionaryList

Code snapshot (C# 9):

internal class Node<T, U>
{
    public bool IsRoot { get; set; } = false;

    private T _ArrayValue;

    public Node(T arrayValue, ValueWrapper<U>? storedValue)
    {
        ArrayValue = arrayValue;
        StoredValue = storedValue;
    }

    public T ArrayValue
    {
        get
        {
            if (IsRoot)
                throw new Exception("Root does not contain value.");

            return _ArrayValue;
        }
        set { _ArrayValue = value; }
    }

    public ValueWrapper<U>? StoredValue { get; set; }

    public List<Node<T, U>> Children { get; set; } = new List<Node<T, U>>();

    public Node<T, U> Add(T arr, ValueWrapper<U> value)
    {
        var newNode = new Node<T, U>(arr, value.HasValue ? value : null);

        Children.Add(newNode);
        return newNode;
    }
}

---

public class ValueWrapper<T>
{
    public ValueWrapper(bool hasValue, T value)
    {
        HasValue = hasValue;
        Value = value;
    }

    public bool HasValue { get; private set; }

    public T Value { get; private set; }

    public override string ToString()
    {
        return $"{(HasValue ? Value!.ToString() : "NULL")}";
    }
}

---

public class DictionaryList<T, U>
{
    private readonly Node<T, U> Root = new Node<T, U>(default!, null) { IsRoot = true };

    /// <summary>
    /// This parameter indicates whether key contains NULLs e.g [UserA, null, new User()].
    /// Allowing NULLs within keys has some performance - speed and memory penalty, that's why it is disabled by default.
    /// </summary>
    public bool AllowNULLsInKeys { get; set; }

    /// <summary>
    /// 
    /// </summary>
    /// <param name="allow_keys_with_nulls">This parameter indicates whether key contains NULLs e.g [UserA, null, new User()].
    /// Allowing NULLs within keys has some performance - speed and memory penalty, that's why it is disabled by default.</param>
    public DictionaryList(bool allow_keys_with_nulls = false)
    {
        AllowNULLsInKeys = allow_keys_with_nulls;
    }

    public void Add(List<T> data, U value)
    {
        var current = Root;

        for (int i = 0; i < data.Count; i++)
        {
            T item = data[i];

            if (!AllowNULLsInKeys && item == null)
                throw new ArgumentException($"Element at index '{i}' is NULL. It cannot be used as a Key's element. " +
                    $"If you want to use NULLs inside Keys, then either use constructor 'DictionaryList(true)' or set property 'AllowNULLsInKeys' to true.");

            Node<T, U> found = FindNode(current, item);

            var isLast = i == data.Count - 1;

            if (found != null)
            {
                if (isLast)
                {
                    if (found.StoredValue is null)
                    {
                        found.StoredValue = new ValueWrapper<U>(true, value);
                    }
                    else
                    {
                        if (found.StoredValue.HasValue && !found.StoredValue.Value!.Equals(value))
                        {
                            throw new ArgumentException($"Value: '{value}' cannot be saved because there's already value:" +
                                $" {found.StoredValue.Value}. Key: {string.Join(",", data)}");
                        }
                    }
                }

                current = found;
            }
            else
            {
                var wrapper2 = new ValueWrapper<U>(isLast, value);
                current = current.Add(item, wrapper2);
            }
        }
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    private Node<T, U> FindNode(Node<T, U> current, T item)
    {
        if (AllowNULLsInKeys)
        {
            for (int i = 0; i < current.Children.Count; i++)
            {
                if (Equals(current.Children[i].ArrayValue, item))
                    return current.Children[i];
            }
        }
        else
        {
            for (int i = 0; i < current.Children.Count; i++)
            {
                if (current.Children[i].ArrayValue!.Equals(item))
                    return current.Children[i];
            }
        }

        return null;
    }

    public bool TryGet(List<T> data, out U? value)
    {
        var current = Root;

        for (int i = 0; i < data.Count; i++)
        {
            T item = data[i];

            Node<T, U> found = FindNode(current, item);

            var isLast = i == data.Count - 1;

            if (found != null)
            {
                if (isLast)
                {
                    if (found.StoredValue == null || !found.StoredValue.HasValue)
                        goto Fail;

                    value = found.StoredValue.Value;
                    return true;
                }

                current = found;
            }
            else
            {
                goto Fail;
            }
        }

        Fail:
        value = default;
        return false;
    }
}

Usage:

var dict = new DictionaryList<int, int>();

var list1 = new List<int> { 1, 2, 3, 4, 5 };
var list2 = new List<int> { 1, 2, 3, 4, 5, 5, 6 };

dict.Add(list1, 5);
dict.Add(list2, 10);

if (dict.TryGet(list1, out var value1))
    Console.WriteLine(value1);

dict.TryGet(list2, out var value2);
Console.WriteLine(value2);