Skip to main content
Email Password   helpLost your password?

Introduction

The Dictionary<TKey, TValue> object is a very powerful collection in the .NET framework. It's a type-safe implementation of the Hashtable that was prevalent in .NET 1.1. Recently, I needed something extra - instead of returning a single value for a given key, I needed two values. I found the solution - instead of a Dictionary, I created a Trictionary.

Background

A Dictionary is pretty straight-forward to use. For this example, we have a Dictionary with a key of type int and a value of type string. There are two ways to add keys and values:

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

// Option 1:
dict.Add(1, "A");

// Option 2:
dict[2] = "B";

The two options are slightly different, but generally produce the same results. Option 1 will throw an exception if the key already exists in the dictionary. Option 2 will not throw an exception in this scenario, but will simply overwrite the value found.

Retrieving values is pretty straightforward as well:

string s = dict[1]; // returns "A"

If the Dictionary doesn't contain the key 1, then a KeyNotFoundException will be thrown. To avoid this, you can call the ContainsKey method first to ensure that the key exists.

Now, suppose you need the dictionary to return two objects instead of just one. For example, suppose you want your key to be an int, and you want to return a string and decimal. There are two simple ways of accomplishing this:

// Option 1: Create a container class
class Container {
    public string S { get; set; }
    public decimal D { get; set; }
}
Dictionary<int, Container> dict;

// Option 2: Use a KeyValuePair<TKey, TValue> as the value
Dictionary<int, KeyValuePair<string, decimal>> dict;

With option 1, you'd need to define a container for each type you need this functionality in. With option 2, the code tends to get kind of messy. I wanted a better solution.

Using the code

I decided to build the Trictionary class as a wrapper around the Dictionary, to utilize the features that make the Dictionary so powerful. The value of the dictionary is actually a type called DualObjectContainer<TValue1, TValue2>. It's a pretty simple class, with just two values. I overrode ToString() to show the values, and implemented IEquatable so two containers can be compared.

public class DualObjectContainer<TValue1, TValue2> 
    : IEquatable<DualObjectContainer<TValue1, TValue2>>
{
    public DualObjectContainer(TValue1 value1, TValue2 value2) {
        Value1 = value1;
        Value2 = value2;
    }

    public TValue1 Value1 { get; set; }
    public TValue2 Value2 { get; set; }

    public bool Equals(DualObjectContainer<TValue1, TValue2> other) {
        return ((EqualityComparer<TValue1>.Default.Equals(Value1, other.Value1)) 
            && (EqualityComparer<TValue2>.Default.Equals(Value2, other.Value2)));
    }

    public override string ToString() {
        return string.Format("[{0}, {1}]", Value1, Value2);
    }
}

The Trictionary class contains a private Dictionary, and many of the methods and properties are simply wrappers around this Dictionary.

public class Trictionary<TKey, TValue1, TValue2> 
    : ITrictionarylt;TKey, TValue1, TValue2>, ITrictionary, 
      ISerializable, IDeserializationCallback
{
    private readonly Dictionary<TKey, DualObjectContainer<TValue1, TValue2>> _dictionary;

    public void Clear()
    {
        _dictionary.Clear();
    }

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

    public int Count
    {
        get { return _dictionary.Count; }
    }
    // etc.
}

In order to add and retrieve values from the Trictionary, I had to do something a little different. Just like the Dictionary, there are two ways to add keys/values. First, you can use the Add method, passing in the key and both values. You can also use the indexer, but to do that, you need to pass in a DualObjectContainer with the two values. There are also two ways to retrieve values - the Get method and the indexer.

public void Add(TKey key, TValue1 value1, TValue2 value2) {
       _dictionary.Add(key, new DualObjectContainer<TValue1, TValue2>(value1, value2));
}

public void Get(TKey key, out TValue1 value1, out TValue2 value2) {
    DualObjectContainer<TValue1, TValue2> container = _dictionary[key];
    value1 = container.Value1;
    value2 = container.Value2;
}

public DualObjectContainer<TValue1, TValue2> this[TKey key] {
    get { return _dictionary[key]; }
    set { _dictionary[key] = value; }
}

Here is how you call the code:

Trictionary<int, string, double> trict = new Trictionary<int, string, double>();

// ADDING:
// Option 1:
trict.Add(1, "A", 1.1);

// Option 2:
trict[2] = new DualObjectContainer<string,double>("B", 2.2);

// RETRIEVING:
// Option 1:
string s;
double d;
trict.Get(2, out s, out d);

// Option 2:
DualObjectContainer<string, double> container = trict[1];

The Trictionary is more than just a simple wrapper. In order to expose the same features as a Dictionary, I had to define the ITrictionary interfaces, both generic and non-generic, which required a significant amount of additional code. This code really isn't important to this presentation, but it is there to make the Trictionary more useful. For example, you can access the keys and values, and all of the different constructors that are available in the Dictionary.

Conclusion

This class can provide a useful benefit in some circumstances. One scenario where I found it useful was with a data object: the ID was the key, the object itself was Value1, and Value2 represented additional information about the object. I hope you find a situation where the download will be of some value as well. Please feel free to leave a comment letting me know if you've found this technique helpful in your projects.

The attached ZIP file contains a Visual Studio 2008 solution, with projects designed to compile under the .NET 3.5 Framework. It contains a Trictionary project, which contains all of the necessary code files, and a Trictionary.TestFixture project, which contains various Unit Tests designed to run in NUnit.

You must Sign In to use this message board.
 
 
Per page   
 FirstPrevNext
Generalin 4.0, I guess its just Dictionary<tk,tuple><t1,t2>> Pin
Jay R. Wren		9:14 17 Mar '09  
GeneralRe: in 4.0, I guess its just Dictionary<tk,tuple><t1,t2>> Pin
Jay R. Wren		9:27 17 Mar '09  
GeneralRe: in 4.0, I guess its just Dictionary<tk,tuple><t1,t2>> Pin
Joe Enos		10:58 17 Mar '09  
GeneralMy vote of 5 Pin
Nishant Sivakumar		17:16 11 Mar '09  
GeneralRe: My vote of 5 Pin
Joe Enos		17:58 11 Mar '09  
GeneralJust An Idea Pin
salinger		11:57 11 Mar '09  
GeneralRe: Just An Idea Pin
Joe Enos		12:18 11 Mar '09  
GeneralRe: Just An Idea Pin
Joe Enos		12:25 11 Mar '09  
GeneralRe: Just An Idea Pin
salinger		12:38 11 Mar '09  
GeneralRe: Just An Idea Pin
Joe Enos		12:51 11 Mar '09  
GeneralAnother way to do this Pin
Aron Weiler		10:23 11 Mar '09  
GeneralRe: Another way to do this Pin
Joe Enos		10:56 11 Mar '09  
GeneralMy vote of 5 Pin
BigTuna		5:51 11 Mar '09  
GeneralRe: My vote of 5 Pin
Joe Enos		5:58 11 Mar '09  
GeneralA better implmentation is MultiDictionary Pin
binarycheese		4:17 11 Mar '09  
GeneralRe: A better implmentation is MultiDictionary Pin
Joe Enos		5:13 11 Mar '09  
GeneralI say "good job" Pin
Marc Clifton		4:17 11 Mar '09  
GeneralRe: I say "good job" Pin
Joe Enos		5:32 11 Mar '09  
GeneralMy vote of 1 Pin
thehawk_2200		4:07 11 Mar '09  
GeneralRe: My vote of 1 Pin
Joe Enos		5:19 11 Mar '09  
GeneralMy vote of 1 Pin
Michael B. Hansen		3:18 11 Mar '09  
GeneralRe: My vote of 1 Pin
Joe Enos		5:17 11 Mar '09  
GeneralStruct? Pin
bombdrop		3:06 11 Mar '09  
GeneralRe: Struct? Pin
Joe Enos		5:15 11 Mar '09  
Last Visit: 20:00 20 Nov '09     Last Update: 20:00 20 Nov '09 1


Last Updated 11 Mar 2009 | Advertise | Privacy | Terms of Use | Copyright © CodeProject, 1999-2009