C# Multi Value Dictionary

		public V this[L subKey]
{
	get
	{
		V item;
		if (TryGetValue(subKey, out item))
			return item;

		throw new KeyNotFoundException("sub key not found: " + subKey.ToString());
	}
}

public [COLOR="Red"]new[/COLOR] V this[K primaryKey]
{
	get
	{
		V item;
		if (TryGetValue(primaryKey, out item))
			return item;

		throw new KeyNotFoundException("primary key not found: " + primaryKey.ToString());
	}
}

public class Values<TVal1,TVal2>
{
    public TVal1 Value1{get;set;}
    public TVal2 Value2{get;set;}

    public Values()
    {
    }

    public Values(TVal1 value1, TVal2 value2)
    {
        this.Value1 = value1;
        this.Value2 = value2;   
    }  
}

public class DoubleValueDictionary<TKey, TValue1, TValue2> : Dictionary<TKey, Tuple<TValue1, TValue2>>
{
    #region Private Fields

    int m_sizeLimit;

    #endregion

    #region Properties

    /// <summary>
    /// The maximum number of entries in the dictionary. 0 means no limitation.
    /// </summary>
    public int SizeLimit
    {
        get { return m_sizeLimit; }
        set
        {
            if (value < 0)
                throw new ArgumentOutOfRangeException("The size limit must be equal to or higher than 0");

            if ((value != 0) && (value < this.Count))
                throw new ArgumentOutOfRangeException("The size limit must be 0 or equal to or higher than the current dictionary count.");

            m_sizeLimit = value;
        }
    }

    #endregion

    #region Public Methods

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

    public new void Add(TKey key, Tuple<TValue1, TValue2> values)
    {
        if ((m_sizeLimit != 0) && (this.Count >= m_sizeLimit))
            throw new InvalidOperationException("The dictionary count may not be higher than the size limit.");

        base.Add(key, values);
    }

    #endregion
}

public new void Add(TKey, Tuple<TValue1, TValue2>){}

public delegate void EntryChanged();

public event EntryChanged Changed;

public event EventHandler Changed;

protected virtual void OnChanged(EventArgs e)
{
    EventHandler handler = this.Changed;
    if (handler != null)
    {
        handler(this, e);
    }
}

OnChanged(EventArgs.Empty)

public class DictionaryUsage
{
    private DeinDictionary<DeinTyp> dict = new DeinDictionary<DeinTyp>();

    public DictionaryUsage()
    {
        this.dict.Changed += new EventHandler(this.DictChanged);
    }

    private void DictChanged(object sender, EventArgs e)
    {
        // Tu was
    }
}

namespace MyDict
{
    public delegate void EntryChanged(Object sender, DictionaryChanged e);

    public class ExtDictionary<TKey, TValue> : Dictionary<TKey, TValue>
    {
        /// <summary>
        /// Die zuletzt benutzter Key und Value
        /// </summary>
        private KeyValuePair<TKey, TValue> LastUsed;

        /// <summary>
        /// Legt die Maximal länge des Dictionaries fest.
        /// Länge von 0 bedeutet dass es keine Längeneinschränkung gibt. 
        /// </summary>
        private uint MaxLen
        {
            get;
            set;
        }

        /// <summary>
        /// [COLOR="Red"]Eventhandler, der beim ändern der Werte[/COLOR] 
        /// [COLOR="Red"]in der Dictionary eine Benachrichtung aussenden kann.[/COLOR]
        /// </summary>
        public event EntryChanged Changed;

        /// <summary>
        /// Überprüft ob die Value exisiert. Gibt diese auch als out zurück.
        /// </summary>
        /// <param name="key">Der gesuchter schlüssel</param>
        /// <param name="val">Wertparameter der einen Schlüssel zugewiesen wurde</param>
        /// <returns>True wenn es den Key gibt.</returns>
        public new Boolean TryGetValue(TKey key, out TValue val)
        {
            val = default(TValue);

            try
            {
                if (base.TryGetValue(key, out val))
                    return true;
            }
            catch
            { }

            return false;
        }

        /// <summary>
        /// Ruft den Wert ab der dem angegebenen Schlüssel ist oder legt diesem fest.
        /// </summary>
        /// <param name="key">Der Schlüssel des abrufenden oder festlegenden Wertes.</param>
        /// <returns>Wert der den Schlüssel zugewiesen wurde.</returns>
        public new TValue this[TKey key]
        {
            get
            {
                TValue val;
                if (TryGetValue(key, out val))
                    return val;

                throw new KeyNotFoundException("Offenbar existiert der Schlüssel " + key.ToString() + " nicht.");
            }
            set
            {
                try
                {
                    this.Add(key, value);
                }
                catch
                {
                    throw new ArgumentException("Es konnte kein Eintrag in der ExtDictionary erstellt werden.");
                }
            }
        }

        /// <summary>
        /// Überschriebene Methode zur einfügung des Parameters.
        /// Hierbei muss man beachten dass es ein Indexer für das Schreiben
        /// der Werte eingesetzt wird und nicht die "base.Add" Methode.
        /// </summary>
        /// <param name="key">Schlüssel der Dictionary.</param>
        /// <param name="val">Wert</param>
        public new void Add(TKey key, TValue val)
        {
            if (MaxLen != 0 && (base.Count + 1) > MaxLen)
                throw new ArgumentOutOfRangeException("ExtDictionary", "Maximale Länge des Dictionary wurde erreicht.\r\nKein neuer Wert zum einfügen möglich.");

            base[key] = val;
            LastUsed = new KeyValuePair<TKey, TValue>(key, val);
            [COLOR="Red"]OnChanged();[/COLOR]

            ///Reset Key und Value Werte
            LastUsed = new KeyValuePair<TKey, TValue>();
        }

        /// <summary>
        /// Löst ein Eventhandler aus.
        /// </summary>
        [COLOR="Red"]public virtual void OnChanged()[/COLOR]
        {
            ///Eigene Klasse für diesen Event dass vom EventArgs erbt.
            DictionaryChanged e = new DictionaryChanged();
            e.Key = LastUsed.Key;
            e.Value = LastUsed.Value;

            if(Changed != null)
               [COLOR="Red"] Changed(this, e);[/COLOR] //<-- Hier Löse ich ereignis aus!
        }

        /// <summary>
        /// Erweiterter Dictionary dass auch einen Eventhandler 
        /// hat der die benachrichtigung übernimmt, falls es ein 
        /// Wert hinzugefügt/geändert wurde.
        /// </summary>
        /// <param name="len">Maximal erlaubte Länge des Dictionary.</param>
        public ExtDictionary(uint max)
        {
            this.MaxLen = max;
        }

        /// <summary>
        /// Erweiterter Dictionary dass auch einen Eventhandler 
        /// hat der die benachrichtigung übernimmt, falls es ein 
        /// Wert hinzugefügt/geändert wurde.
        /// </summary>
        public ExtDictionary()
        {
            this.MaxLen = 0;
        }
    }
}