Dictionnaire avec plusieurs clés et de multiples valeurs pour chaque touche

Personnellement, je serais probablement utiliser un Dictionnaire de Dictionnaires, par exemple IDictionary<int, IDictionary<int, IList<int>>>. Non je ne suis pas entièrement sûr de savoir comment vous avez l'intention d'accès ou de faciliter ces données; que sera avoir un impact important sur l'efficacité de ma suggestion. Sur le plan positif, il vous permettra d' -- relativement facilement -- l'accès des données, si et seulement si vous avez accès, dans l'ordre que vous avez configuré votre dictionnaires.

(À la réflexion, tout simplement le type de la déclaration elle-même est si laid et vide de sens, vous pouvez sauter ce que j'ai dit ci-dessus.)

Si vous êtes d'accéder à des champs plutôt au hasard, peut-être un simple dénormalisée ICollection<Tuple<int, int, int>> (ou l'équivalent) devra faire l'affaire, avec l'agrégation dans d'autres parties de votre application selon vos besoins. LINQ peut aider ici beaucoup, surtout son agrégation, de regroupement et de recherche de fonctionnalités.

Mise à jour: j'espère que cela clarifie:

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 }

Le prendre avec un grain de sel; voir le commentaire.

OriginalL'auteur Manny

Si la clé est une partie de la classe alors utiliser KeyedCollection.

C'est un Dictionnaire dont la clé est dérivée à partir de l'objet.

Sous les couvertures, il est Dictionnaire. D Ne pas avoir à répéter la clé dans la Clé et la Valeur.

Pourquoi prendre une chance que la clé n'est pas la même dans la Clé comme la Valeur. Ne pas répéter les mêmes informations dans la mémoire.

KeyedCollection Classe

Indexeur pour exposer la clé composite

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;
}
}
}
}

OriginalL'auteur paparazzo

Je ne suis pas sûr à 100% de la exacte données que vous souhaitez utiliser comme une clé. Je pense que 2? 2 valeurs entières? C'est ce que je vais assumer ci-dessous, mais si vous voulez trois ou le type est différent, il suffit d'ajuster en conséquence. Je suggère ce qui suit (étape 1, l'étape 2 est facultatif, mais je le ferais)

Étape 1 de la Création de votre propre clé struct, pour être utilisée comme clé dans un dictionnaire standard. Donner 2 propriétés (ou trois, peu importe) pour vos valeurs qui servira de clé et/ou un Constructeur prenant/réglage de ces valeurs.

Spécifier une méthode GetHashCode. Quelque chose comme:

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

Remarque: Oui, vous pourrait utiliser un Tuple. Des n-uplets . . . ne sont pas aussi cool que le premier semble. Vos noms de propriété sera Élément1, etc. Pas très clair. Et vous finissent souvent voulu le remplacement et ajouter des choses assez vite. Juste commencer à partir de zéro.

Comme ceci:
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;
}
}

}

Remarque: Si l'un de vos multiples valeurs que vous souhaitez utiliser dans votre combiné clés sont des types référence, vous devriez probablement créer une classe au lieu d'une struct. Si oui, vous aurez également besoin de remplacer Equals pour qu'il fonctionne correctement en tant que clé de dictionnaire.

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

(Et ajouter des propriétés publiques pour vos valeurs de clé si vous ne l'avez pas déjà.)

Ou, si vous créez le dictionnaire personnalisé comme je le mentionne ci-dessous, il serait commode d'utiliser un IEqualityComparer. (En gros, si vous utilisez une classe de votre clé, vous devez assurez-vous que le dictionnaire est voir deux identiques PayKey l'objet comme "égaux". Par défaut, même avec des valeurs égales, ce sont des références à des objets différents, de sorte que le cadre tiendra compte de leur ne sont pas égaux)

Étape 2 Créer une classe qui hérite de Dictionnaire. Deux méthodes supplémentaires:

• Une méthode add qui prend deux paramètres clés ainsi que la valeur que vous souhaitez ajouter. L'intérieur, vous allez construire un de vos clés et des structs appeler sa de la base de la méthode add, avec l'objet clé comme clé et de la valeur du cours de la valeur.
• une surcharge pour l'article ou le nom que vous souhaitez. Cette méthode prendra comme paramètres les 2 nombres entiers de votre clé, et de retourner l'article. À l'intérieur de cette méthode, vous allez construire un de votre clé struct, et d'appeler l'élément de base de la méthode avec la clé struct pour récupérer l'objet.
• En outre, pour votre éventuelle de commodité, vous voudrez probablement ajouter d'autres surcharges de votre dictionnaire, où vous pouvez spécifier votre valeurs de clé, plutôt que d'avoir à construire votre propre clé struct chaque fois. Par exemple, la première chose que je ferais probablement d'ajouter un KeyExists propriété qui a pris mes deux valeurs clés.

OriginalL'auteur Patrick Karcher