Can you have more than 2 items in a Dictionary collection or another type of collection?

Question

I doubt this is possible, but I was curious if you could have more than 2 items (key,value) in a dictionary. Maybe a key and 2 values. Is there a collection object that does allow this? What I am actually trying to do is to store a key and a value for the key and another value to hold the count of how many times the key has been found. For example, I may have a for loop that goes through a list of colors and each color has a unique value. As I go through the list, I not only want to store the color, the unique value of the color in a dictionary, but also store how many times red occurred in the list.

I put in the following declaration and now I am tyring to figure out how I can test to see if it contains the value already and if it does not, add it to the list with a count of 1 and if it does, increment the count. After I post the declaration, I will post how I was doing it with just one dictionary.

Dictionary<string, Dictionary<int,int>> colors = 
                          new Dictionary<string, Dictionary<int,int>>();

Here is code of how I was handling it before:

Dictionary<string, int> colors = new Dictionary<string, int>();

 foreach (Color color in ColorList)
        {
            if (colors.ContainsKey(color.ToString()))
                colors[color]++;
            else
                colors.Add(color, 1);
        }

Answer 1

Could you perhaps have a dictionary of a struct that would keep track of the color and the number of times it occurred?

Edit: As suggested elsewhere, this could also be accomplished by building your own small custom class. Would essentially work in the same fashion.

Answer 2

you can use two dictionaries for this or simply create a data class that has both the color and the count and store the intermediate class instances in a dictionary.

Answer 3

You're looking for a MultiMap.

I wrote the following (not fully tested):

 using System.Collections.Generic;

public class MultiMapSet<TKey, TValue>
{
    private readonly Dictionary<TKey, HashSet<TValue>> _ht = new Dictionary<TKey, HashSet<TValue>>();

    public void Add(TKey key, TValue value)
    {
        HashSet<TValue> valueSet;
        if (_ht.TryGetValue(key, out valueSet))
        {
            valueSet.Add(value);
        }
        else
        {
            valueSet = new HashSet<TValue> { value };
            _ht.Add(key, valueSet);
        }
    }

    public bool HasValue(TKey key, TValue value)
    {
        HashSet<TValue> valueSet;
        if (_ht.TryGetValue(key, out valueSet))
        {
            return valueSet.Contains(value);
        }
        return false;
    }

    public HashSet<TValue> GetValues(TKey key)
    {
        HashSet<TValue> valueSet;
        _ht.TryGetValue(key, out valueSet);
        return valueSet;
    }

    public void Remove(TKey key, TValue value)
    {
        HashSet<TValue> valueSet;
        if (!_ht.TryGetValue(key, out valueSet))
        {
            return;
        }

        if (valueSet.Contains(value))
        {
            valueSet.Remove(value);
        }
    }
}

Answer 4

Well, one way would be to have:

Dictionary<key, KeyValuePair<value, int>>

If I'm understanding your question.

---

Edit:

Actually, if the color and value were consistent - meaning that 'red' was always 3 or 19 or whatever you used as the value of red, then the name 'red' and the value, say 19, is really just a compound key and so you could do something like this:

Dictionary<KeyValuePair<string, int>, int> mydict;

and then for updates do something like this:

mydict[key] = mydict[key] + 1;

Answer 5

You could make a simple Tuple class, such as a Triple. It's essentially a generically keyed dictionary but holds an additional object. It's pretty common for this scenario, people have made libraries that extend it out for 4 to 10 objects. Here's an example:

    public struct Triple<X, Y, Z>
    {
        public X First;     
        public Y Second;    
        public Z Third;     

        public Triple(X x, Y y, Z z)
        {
            First = x;
            Second = y;
            Third = z;
        }
    }

And then use it like so:

 var myTriple =  new Triple<string, Color, int>(
                        "key", 
                        myColor, 
                        count
                    )

,

Answer 6

could you do something like

Dictonary<string,string> dh = new dictonary<string,string>();

dh.add("x","Something:0");


foreach keyvaluepair kvp in dh
{

    if kvp.key == x
    {
        string[] hold= kvp.value.split(':');
        //to update it the count it would be something like

        int y = convert.toint(hold[1])+1;
        kvp.value=hold[0]+":"+y.tostring();

     }

}

Answer 7

Most of these answers all say pretty much the same (correct) thing. Just make the value of your 'outer' dictionary some sort of object you find most useful to doing what you need with. Personally without thinking about it I'd have gone with a dictionary of dictionary.

Dictionary<key1, Dictionary<key2, value>>