Wörterbuch mit mehrere Schlüssel und mehrere Werte für jeden Schlüssel

Persönlich würde ich wahrscheinlich ein Wörterbuch der Wörterbücher, z.B. IDictionary<int, IDictionary<int, IList<int>>>. Nicht ich bin mir nicht ganz sicher, wie Sie Sie beabsichtigen, um Zugang oder erleichtern diese Daten; das wird haben einen großen Einfluss auf wie effektiv ist mein Vorschlag. Auf der anderen Seite, es würde Ihnen ermöglichen-relativ leicht-Zugangsdaten, wenn, und nur wenn Sie zugreifen, um Sie einzurichten in Ihren Wörterbüchern.

(Am zweiten Gedanken, einfach die Typ-Deklaration selbst ist so hässlich und sinnlos, möchten Sie vielleicht zu überspringen, was ich oben sagte.)

Wenn Sie den Zugriff auf Felder eher zufällig, vielleicht eine einfache denormalisierten ICollection<Tuple<int, int, int>> (oder gleichwertig) haben, den trick zu tun, mit aggregation in anderen teilen der Anwendung bei Bedarf. LINQ können hier helfen, eine Menge, vor allem deren aggregation, Gruppierung und lookup-Funktionen.

Update: Hoffentlich klärt es:

var outerDictionary = new Dictionary<int, Dictionary<int, List<int>>>();

/* fill initial values
 * assuming that you get your data row by row from an ADO.NET data source, EF, or something similar. */
foreach (var row in rows) {
    var employeeId = (int) row["EmpID"];
    var payYear = (int) row["PayYr"];
    var payId = (int) row["PayID"];


    Dictionary<int, int> innerDictionary;
    if (!outerDictionary.TryGet(employeeId, out innerDictionary)) {
        innerDictionary = new Dictionary<int, int>();
        outerDictionary.Add(employeeId, innerDictionary);
    }

    List<int> list;
    if (!innerDictionary.TryGet(payYear)) {
        list = new List<int>();
        innerDictionary.Add(payYear, list);
    }

    list.Add(payId);
}

/* now use it, e.g.: */
var data = outerDictionary[1000][2011]; //returns a list with { 1, 2, 3 }

Nehmen Sie es mit einem Körnchen Salz, wenn; siehe Kommentar.

Wenn der Schlüssel ein Teil der Klasse dann verwenden KeyedCollection.

Es ist ein Wörterbuch, in dem der Schlüssel abgeleitet wird von dem Objekt.

Unter der Decke ist es Wörterbuch. D nicht zu wiederholen, den Schlüssel in den Schlüssel und den Wert.

Warum nehmen Sie eine chance, der Schlüssel ist nicht gleich Schlüssel als Wert. Nicht zu duplizieren Sie die gleichen Informationen im Speicher.

KeyedCollection-Klasse

Indexer-setzen Sie den zusammengesetzten Schlüssel

using System.Collections.ObjectModel;

namespace IntIntKeyedCollection
{
    class Program
    {
        static void Main(string[] args)
        {
            UInt16UInt16O Emp1 = new UInt16UInt16O(34, 1990);
            Emp1.PayIDs.Add(1);
            Emp1.PayIDs.Add(2);
            UInt16UInt16O Emp2 = new UInt16UInt16O(34, 1990, new List<byte>{3,4});
            if (Emp1 == Emp2) Console.WriteLine("same");
            if (Emp1.Equals(Emp2)) Console.WriteLine("Equals");
            Console.WriteLine("Emp1.GetHashCode " + Emp1.GetHashCode().ToString());

            UInt16UInt16OCollection Employees = new UInt16UInt16OCollection();
            Employees.Add(Emp1);
            //this would fail
            //Employees.Add(Emp2);
            Employees.Add(new UInt16UInt16O(35, 1991, new List<byte> { 1 } ));
            Employees.Add(new UInt16UInt16O(35, 1992, new List<byte> { 1, 2 } ));
            Employees.Add(new UInt16UInt16O(36, 1992));

            Console.WriteLine(Employees.Count.ToString());
            //reference by ordinal postion (note the is not the long key)
            Console.WriteLine(Employees[0].GetHashCode().ToString());
            //reference by Int32 Int32
            Console.WriteLine(Employees[35, 1991].GetHashCode().ToString());
            Console.WriteLine("foreach");
            foreach (UInt16UInt16O emp in Employees)
            {
                Console.WriteLine(string.Format("HashCode {0} EmpID {1} Year {2} NumCodes {3}", emp.GetHashCode(), emp.EmpID, emp.Year, emp.PayIDs.Count.ToString()));
            }
            Console.WriteLine("sorted");
            foreach (UInt16UInt16O emp in Employees.OrderBy(e => e.EmpID).ThenBy(e => e.Year))
            {
                Console.WriteLine(string.Format("HashCode {0} EmpID {1} Year {2} NumCodes {3}", emp.GetHashCode(), emp.EmpID, emp.Year, emp.PayIDs.Count.ToString()));
            }  
        }
        public class UInt16UInt16OCollection : KeyedCollection<UInt16UInt16S, UInt16UInt16O>
        {
            //This parameterless constructor calls the base class constructor 
            //that specifies a dictionary threshold of 0, so that the internal 
            //dictionary is created as soon as an item is added to the  
            //collection. 
            //
            public UInt16UInt16OCollection() : base(null, 0) { }

            //This is the only method that absolutely must be overridden, 
            //because without it the KeyedCollection cannot extract the 
            //keys from the items.  
            //
            protected override UInt16UInt16S GetKeyForItem(UInt16UInt16O item)
            {
                //In this example, the key is the part number. 
                return item.UInt16UInt16S;
            }

            // indexer 
            public UInt16UInt16O this[UInt16 EmpID, UInt16 Year]
            {
                get { return this[new UInt16UInt16S(EmpID, Year)]; }
            }
        }

        public struct UInt16UInt16S
        {   //required as KeyCollection Key must be a single item
            //but you don't reaaly need to interact with Int32Int32s
            public  readonly UInt16 EmpID, Year;
            public UInt16UInt16S(UInt16 empID, UInt16 year) { this.EmpID = empID; this.Year = year; }
        }
        public class UInt16UInt16O : Object
        {
            //implement you properties
            public UInt16UInt16S UInt16UInt16S { get; private set; }
            public UInt16 EmpID { get { return UInt16UInt16S.EmpID; } }
            public UInt16 Year { get { return UInt16UInt16S.Year; } }
            public List<byte> PayIDs { get; set; }
            public override bool Equals(Object obj)
            {
                //Check for null and compare run-time types.
                if (obj == null || !(obj is UInt16UInt16O)) return false;
                UInt16UInt16O item = (UInt16UInt16O)obj;
                return (this.EmpID == item.EmpID && this.Year == item.Year);
            }
            public override int GetHashCode() { return ((UInt32)EmpID << 16 | Year).GetHashCode() ; }
            public UInt16UInt16O(UInt16 EmpID, UInt16 Year)
            {
                UInt16UInt16S uInt16UInt16S = new UInt16UInt16S(EmpID, Year);
                this.UInt16UInt16S = uInt16UInt16S;
                PayIDs = new List<byte>();
            }
            public UInt16UInt16O(UInt16 EmpID, UInt16 Year, List<byte> PayIDs)
            {
                UInt16UInt16S uInt16UInt16S = new UInt16UInt16S(EmpID, Year);
                this.UInt16UInt16S = uInt16UInt16S;
                this.PayIDs = PayIDs;
            }
        }
    }
}

Bin ich mir nicht 100% sicher, dass der genaue Daten, die Sie verwenden möchten, wie einen Schlüssel. Ich denke 2? 2 Integer Werte? Das ist, was nehme ich an, dass unten, aber wenn Sie wollen, drei oder der Typ ist anders, so passen Sie diese entsprechend an. Ich schlage vor, die folgenden (Schritt 1 ist notwendig, Schritt 2 ist optional, aber ich würde es tun)

Schritt 1 Erstellen Sie Ihre eigenen Tastenkombinationen für struct, werden als Schlüssel verwendet, die in einem standard-Wörterbuch. Geben Sie 2 Eigenschaften (oder drei, was auch immer) für Ihre Werte als Schlüssel und/oder ein Konstruktor nehmen/Einstellung dieser Werte.

Geben Sie eine Methode GetHashCode. So etwas wie:

public override int GetHashCode()
{
  unchecked
  {
    return (_empId * 397) ^ _payYr;
  }
}

Hinweis: ja, Sie könnte Verwendung eines Tupels. Tupeln . . . nicht so cool wie die ersten zu sein scheinen. Ihre Immobilie-Namen Item1, etc. Nicht sehr klar. Und man oft am Ende, wollte zu überschreiben und hinzufügen, Dinge schnell genug. Einfach von vorne anfangen.

Wie diese:
public struct PayKey {

  private int _empId
  private int _payYr;

  public PayKey (int empId, int payYr) {
    _empId = empId;
    _payYr = payYr;
}

public override int GetHashCode()
{
  {
    return (_empId * 83) ^ _payYr;
  }
}

}

Hinweis: Wenn Ihre mehrere Werte, die Sie verwenden möchten, in Ihrem kombinierten Schlüssel sind Referenz-Typen, sollten Sie wahrscheinlich erstellen Sie eine Klasse statt einer Struktur. Wenn dem so ist, müssen Sie auch überschreiben Equals um richtig funktionieren, als dictionary-Schlüssel.

public override bool Equals( object pkMaybe ){
    if( pkMaybe is PayKey ) {
        PayKey pk = (PayKey) pkMaybe ;
        return _empId = pk.EmpId && _payYr = pk.PayYr;
    }
    else {
        return false;
    }
}

(Und fügen Sie öffentliche Eigenschaften für Ihre wichtigsten Werte, wenn Sie nicht bereits haben.)

Oder, wenn Sie, erstellen Sie das benutzerdefinierte Wörterbuch, wie ich unten erwähnen, es würde bequem sein, verwenden Sie eine IEqualityComparer. (Im Grunde, wenn Sie eine Klasse verwenden, wie Ihren Schlüssel, Sie müssen sicherstellen, dass das Wörterbuch wird in zwei identische PayKey Objekt als "gleich". Standardmäßig, sogar mit gleichen Werten, Sie sind Referenzen auf unterschiedliche Objekte, so wird der Rahmen betrachten Sie Sie nicht gleich)

Schritt 2 eine Klasse Erstellen, erbt von Dictionary. Geben es zwei weitere Methoden:

• Eine add-Methode, der Ihre zwei wichtigsten Parameter sowie der Wert, den Sie hinzufügen möchten. Innen, Sie werden konstruieren einer Ihrer wichtigsten Strukturen und rufen die Basis-Methode "add", mit dem key-Objekt als Schlüssel und Ihrem Wert natürlich als Wert.
• eine überlastung für ein Element oder eine benannte, wie Sie es wünschen. Dieser Methode werden als Parameter die 2 Ganzzahlen von deinem key, und den Artikel zurücksenden. Innerhalb dieser Methode werden Sie bauen eine der wichtigsten Strukturen, und rufen Sie das Basis-Element-Methode mit dem Schlüssel struct, um das Objekt abzurufen.
• Darüber hinaus für die eventuelle Bequemlichkeit, die Sie wahrscheinlich wollen, um weitere überlastungen zu Ihrem Wörterbuch, in dem Sie angeben können Ihre Schlüssel-Werte, anstatt Sie zu bauen Ihre eigenen Schlüssel struct jeder Zeit. Zum Beispiel, das erste, was würde ich wohl tun, ist, eine KeyExists Eigenschaft, nahm meine zwei wichtigsten Werte.