Meilleure mise en œuvre pour la Valeur de la Clé de la Paire de Structure de Données?

Donc j'ai été farfouillé avec C# un peu ces derniers temps, et tous les Génériques des Collections m'ont un peu confus. Dire que j'ai voulu représenter une structure de données où le chef de l'arbre a une valeur de clé de paire, et puis il y a une option de la liste de paires clé-valeur en dessous (mais pas plus de niveaux que ces). Serait-ce adapté?

public class TokenTree
{
    public TokenTree()
    {
        /* I must admit to not fully understanding this,
         * I got it from msdn. As far as I can tell, IDictionary is an
         * interface, and Dictionary is the default implementation of
         * that interface, right?
         */
        SubPairs = new Dictionary<string, string>();
    }

    public string Key;
    public string Value;
    public IDictionary<string, string> SubPairs;
}

Il n'y a vraiment qu'un simple shunt pour la transmission des données.

InformationsquelleAutor Bernard | 2008-08-12

c#collections data-structures

135

Il existe un Type de Données appelé KeyValuePair, comme ce
```
KeyValuePair<string, string> myKeyValuePair = new KeyValuePair<string,string>("defaultkey", "defaultvalue");
```
- Cela fonctionne très bien avec "l'aide" de l'énoncé (similaire à l'ancien typedef) afin de gagner un peu de temps et de rendre le tout plus clair. Si vous avez constamment l'utilisation de e. g. l' (string, string) paire.
- KeyValuePair<string, string> NAME_HERE = new KeyValuePair<string,string>("defaultkey", "valeur par défaut");
- Pour développer sur @AndreasReiff 's commentaire: using NameValuePair = System.Collections.Generic.KeyValuePair<string, string>; près du haut de chaque fichier qui a besoin d'un (string, string) struct. Si je l'ai trouvé plus pratique de créer un class NameValuePair dans mon espace de noms: public class NameValuePair { KeyValuePair<string, string> it; public NameValuePair( string name, string value ) { it = new KeyValuePair<string, string>( name, value ); } public string Name { get { return it.Key; } } public string Value { get { return it.Value; } } }
InformationsquelleAutor Adam Haile
12

Une chose que vous pourriez faire est d'utiliser le Dictionnaire d'objet tout droit sorti de la boîte, et puis il suffit de l'étendre avec vos propres modifications:
```
public class TokenTree : Dictionary<string, string>
{
    public IDictionary<string, string> SubPairs;
}
```
Cela vous donne l'avantage de ne pas avoir à respecter les règles de IDictionary pour votre Clé (par exemple, la clé d'unicité, etc).

Et que vous avez obtenu le concept du constructeur droite 🙂

InformationsquelleAutor Jon Limjap
7

Je pense que ce que vous pourriez être après (comme un littéral de la mise en œuvre de votre question), est:
```
public class TokenTree
{
    public TokenTree()
    {
        tree = new Dictionary<string, IDictionary<string,string>>();
    }

    IDictionary<string, IDictionary<string, string>> tree; 
}
```
Vous avez réellement dire une "liste" des valeurs-clés dans votre question, alors vous pourriez souhaitez changer de l'intérieur IDictionary avec un:
```
IList<KeyValuePair<string, string>>
```
InformationsquelleAutor Shaun Austin
5

Il y a un KeyValuePair type intégré. Comme une question de fait, c'est ce que le IDictionary est de vous donner accès à lorsque vous parcourez en elle.

Aussi, cette structure est à peine un arbre, trouver un plus grand représentant le nom peut être un bon exercice.

InformationsquelleAutor Coincoin
3

Juste une chose à ajouter à ce sujet (bien que je ne pense que vous avez déjà eu la réponse à votre question par d'autres). Dans l'intérêt de l'extensibilité (car nous savons tous qu'il va arriver à un certain point) vous pouvez vérifier le Diagramme Composite C'est idéal pour travailler avec des "Structures arborescentes"..

Comme je l'ai dit, je sais que vous êtes seulement attendais un sous-niveau, mais cela pourrait être vraiment utile pour vous si vous avez besoin plus tard d'étendre ^_^

InformationsquelleAutor Rob Cooper
2

@Jay Mooney: Un Dictionnaire générique classe .NET est en fait une table de hachage, juste avec des types fixes.

Le code que vous avez indiqué ne devrait pas convaincre quiconque de l'utiliser à la table de hachage au lieu de Dictionnaire, puisque les deux morceaux de code peut être utilisé pour les deux types.

Pour table de hachage:
```
foreach(object key in h.keys)
{
     string keyAsString = key.ToString(); //btw, this is unnecessary
     string valAsString = h[key].ToString();

     System.Diagnostics.Debug.WriteLine(keyAsString + " " + valAsString);
}
```
Pour le dictionnaire:
```
foreach(string key in d.keys)
{
     string valAsString = d[key].ToString();

     System.Diagnostics.Debug.WriteLine(key + " " + valAsString);
}
```
Et de la même de l'autre avec KeyValuePair, il suffit d'utiliser la non-générique version de la table de hachage, et la version générique du Dictionnaire.

Il est donc tout aussi facile dans les deux sens, mais la table de hachage utilise l'Objet pour à la fois la clé et la valeur, ce qui signifie que vous recevrez une boîte de tous les types de valeur, et vous n'avez pas de type de sécurité, et le Dictionnaire utilise des types génériques et est donc mieux.

InformationsquelleAutor Lasse Vågsæther Karlsen
1

Dictionnaire De La Classe est exactement ce que vous voulez, de les corriger.

Vous pouvez déclarer le terrain directement en tant que Dictionnaire, au lieu de IDictionary, mais c'est à vous de voir.

InformationsquelleAutor Lasse Vågsæther Karlsen
1

Utiliser quelque chose comme ceci:
```
class Tree < T > : Dictionary < T, IList< Tree < T > > >  
{  
}  
```
C'est moche, mais je pense que ça va vous donner ce que vous voulez. Trop mauvais KeyValuePair est scellé.

InformationsquelleAutor kokos

Vous devez vous connecter pour publier un commentaire.