Key exists, but giving KeyNotFound exception

Question

I've made a class that creates a dictionary using custom classes as the keys and values, and stores it via xml serialization. Then clicking "load" de-serializes the xml file and loads the data.

The problem is with the following code. I keep getting a KeyNotFound exception here after de-serializing and trying to load the dictionary:

foreach (Perk p in perksTier1[skill])
{
    string s = p.Name.ToString();
    if (!lboxTier1.Items.Contains(s))
        lboxTier1.Items.Add(s);
}

However, when I step through the code and examine the dictionary, it looks just as it should, with the Skill key clearly present.

Here's the really weird part: Using ContainsKey returns null, but using GetKeys GIVES ME THE KEY

Wut. Please help.

Answer 1

You mention ContainsKey but you are using Contains. They are not the same. Contains is checking for the value in the dictonary. ContainsKey Method returns true or false. IF you are getting NULL, you are using the incorrect method.

Answer 2

Huzzah! Found it. See this post for the long details: GetHashCode and Equals implementation in Dictionary C#

To fix the imported dictionary, I had to override the Equals and GetHashCode() methods in my Skill class:

    public override bool Equals(object obj)   
    {
        Skill newskill;
        newskill = (Skill)obj;
        return (obj.GetHashCode() == newskill.GetHashCode());

    }
    public override int GetHashCode()    
    {
        int temp = name.GetHashCode();
        return temp;
    }

(Thank you to Mike and Preston for pointing me in the right direction)

Answer 3

Your key is a custom object. By default, the dictionary is going to use an object reference comparison to determine if the given instance of a key is present in the Keys collection of the dictionary. Since it's using a reference comparison, the references are not the same as they will point to different references (even though they may "look" the same because they have the same values).

You need to tell the dictionary how it should test for equality. This is typically done in the object being used as the key, in this case your Skill object, by providing a custom Equals method or by implementing an EqualityComparer<Skill> object that defines the "rules" for determining if two instances are equal.

Answer 4

Based on your explanation you are using custom class as your key.

When using reference types as key you need to make sure that you use a reference to the same object that is being referenced by the dictionary key.

For example if you have this type

public class Skill
    {
        public string SkillName
        {
            get;
            set;
        }
    }

Then you use it this way

Dictionary<Skill, object> dic = new Dictionary<Skill, object>();
            for (int i = 0; i < 5; i++)
            {
                dic.Add(new Skill() { SkillName = i.ToString() }, new object());
            }

            Skill lookup = new Skill() { SkillName = "0"};

            Console.WriteLine(dic.ContainsKey(lookup));

This will return false because lookup reference is pointing to an object which is different from the object that has been created in the loop, notice that the SkillName has the same value ("0" in this case).

If you change the code to the following

Dictionary<Skill, object> dic = new Dictionary<Skill, object>();
            for (int i = 0; i < 5; i++)
            {
                dic.Add(new Skill() { SkillName = i.ToString() }, new object());
            }

            Skill lookup = dic.Keys.FirstOrDefault(sk => sk.SkillName == "0");

            Console.WriteLine(dic.ContainsKey(lookup));

You will notice that the console line is printing true now. This is because the lookup reference is pointing to the same object that the dictionary has.

How does this related to your question? Its the serialization and de-serialization. If you create an object of type Skill like this

Skill skill1 = new Skill(){SkillName = "C#"};

Then serialize it using a serializer of your choice

Serializer.Serialize(skill1,streem);

Then you de-serialize it like this

Skill skill2 = Serializer.Deserialize(stream);

And print skill1 == skill2 you will find that it will return false, this is because what the serializer did when de-serializing the object is that it created new object and populated it with the same values that the first object had.

The rule is very simple reference equality is based on pointing to the same object, not on two different objects having the same property values.

Wish I have hit the spot given that you didn't provide enough information