construction d'une liste de listes, etc.

**Othana** · 20/10/2010, 12h00

Salut, les gens.

j'arrive pas à pondre un algo de construction de liste, si quelqu'un peut m'aider.

bon, j'énonce les faits :

on prend une liste "cmdlist", celle qu'on va construire.
pour la méthode, on récupère une liste "param" contenant un nombre variable d'éléments.
pour chaque élément de param, je vais chercher une instruction qui lui correspond (accompagnée de ses arguments, donc surement dans une liste ou un dictionnaire, via la méthode d'une classe externe).
enfin, j'ajoute l'instruction à cmdlist UNIQUEMENT si elle n'y est pas déjà présente.
au final, c'est pour concaténer une string "commande" qui reprend l'instruction et ses arguments (si il y a plusieurs instructions différentes, on aura plusieurs chaines).
voilà.
si, au passage, vous avez plus simple, n'hésitez pas. Merci de l'aide éventuelle.

**zouuc** · 20/10/2010, 12h15

Bonjour,

Tu veux ajouter toutes les commandes dans ta liste cmdlist de tous les paramètres de ta liste param mais sans doublon ?

EDIT:
Si j'ai bien compris :

C'est ça ??

/EDIT:

Et donc quel est le problème ?

**Othana** · 20/10/2010, 13h41

plutôt :
cmdlist
|
|-> commandX(param1)
|
|
|-> commandY(param2)
|
|
|-> commandZ(param3)

et si un param4 ramène une commandY, pas besoin de l'ajouter à cmdlist.

La méthode qui va construire la chaine string commandYtext, re-récupèrera param2, param4 et tout ce qui est encore nécessaire.

Le problème est que j'arrive pas à pondre l'algo, le pseudo-code qui va bien ou trouver encore plus simple.

**zouuc** · 20/10/2010, 14h13

mmhh je vois mieux maintenant.

Dans la logique,

-> tu crées ta liste cmdlist,
-> tu parcours tous param(là tu fais une boucle pour ça :for, while ou autre selon tes désirs et tes contraintes, moi j'opterais pour le for

)
-> sur chaque param, tu regardes ses commandes.
-> tu parcours ta cmdlist à la recherche de la commande.
-> Non elle n'existe pas : tu l'ajoutes à la fin de cmdlist avec le param qui va avec.
-> Oui elle existe : tu ajoutes le nouveau param sur cette commande après le dernier.
-> et ainsi de suite pour chaque commande

Tu voyais ça comment toi ? Pour savoir si tu avais une ébauche de travail dedans ? on peut repartir de ce que tu pensais faire autrement.

PS : tu peux poster ton code après (les parties concernées seulement) pour qu'on en discute si tu as un souci. En attendant, bonne chance

**Othana** · 20/10/2010, 14h35

peut être ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
List <Dictionary> cmdlist;
Dictionary<string,string> cmd;
 
public void Createcmdlist (List <string> param)
{
   foreach (argument in param)
   {
      cmd=Driver.RechInstruction(argument);
      if(!Exist(cmd))
         cmdlist.Add(cmd);
   }
}
 
public bool Exist(Dictionary <string,string> cmd)
{
   bool exist=false;
   foreach (elem in cmdlist)
   {
      if (elem.instruction=cmd.instruction)
         exist=true;
   }
}

**zouuc** · 20/10/2010, 14h51

OK

A partir de là tu peux ajouter les commandes dans ta cmdlist si je comprend bien. Seulement, admettons que la commande existe déjà tu n'ajoutes pas le paramètre dans cmdlist.cmd(tes_paramètres) ?

Il te reste ça à faire et c'est OK non ?

**Othana** · 20/10/2010, 14h54

voilà. si une instr existe déjà dans cmdlist, on n'ajoute pas cmd en cours de lecture (dans la boucle).

mais jusque là, j'y arrivais pas.

Par contre, tu peux me compléter les parenthèse de mes foreach ? ça m'est un peu compliqué, à mon niveau, l'utilisation des listes typées et des dictionnaires.

**zouuc** · 20/10/2010, 15h02

Logiquement l'ajout du param se ferait dans un else tel que :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
public void Createcmdlist (List <string> param)
{
   foreach (argument in param)
   {
      cmd=Driver.RechInstruction(argument);
      if(!Exist(cmd))
         cmdlist.Add(cmd);
      else
         // ajout de ton paramètre dans cmdlist.cmd
   }
}

Mais le fait est que cmd n'est pas une liste. Je ne vois pas comment fonctionne ton Dictionary (je vais me renseigner là dessus, mais si tu peux m'en apprendre dessus c'est encore mieux !).

Mais si tu avais une List à la place tu pourrais faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

cmdlist.cmd.Add(param)

encore que ça changerait le reste du code. Mieux vaut rester avec le dictionary je pense.

**Othana** · 20/10/2010, 15h05

un Dictionary a deux arguments <Key, Value>, tous les deux typés. un mot, une définition, d'où son nom.

Donc, on peut faire Dictionary<string,string> cmd
avec ("Instruction","RESET")

**zouuc** · 20/10/2010, 15h11

OK merci,

en complément avec ton explication : http://msdn.microsoft.com/fr-fr/library/xfhwa508.aspx

Donc, prenons ton exemple,

("Instruction","RESET")

Instruction est la Key et RESET est le paramètre si je comprend bien.

Mais est-ce que la Key est aussi la commande du coup ? (key == commande == instruction ?)

Si oui, pour faire l'ajout de commande il faut faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
public void Createcmdlist (List <string> param)
{
   foreach (argument in param)
   {
      cmd=Driver.RechInstruction(argument);
      if(!Exist(cmd))
         cmdlist.Add(cmd);
      else
         cmdlist.cmd.Add(cmd.instruction, param);
   }
}

Mais je n'ai p-e pas tout cerné et donc pas répondu correctement

**Othana** · 20/10/2010, 15h21

Non, c'est RESET, le paramètre. la clef est l'équivalent de l'index pour une liste simple.

**zouuc** · 20/10/2010, 15h29

Non, c'est RESET, le paramètre.

Ce n'est pas ce que j'avais dis ?

RESET est le paramètre si je comprend bien

Voila un exemple du lien que j'ai mis plus haut :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
// Create a new dictionary of strings, with string keys.
        //
        Dictionary<string, string> openWith = 
            new Dictionary<string, string>();
 
        // Add some elements to the dictionary. There are no 
        // duplicate keys, but some of the values are duplicates.
        openWith.Add("txt", "notepad.exe");
        openWith.Add("bmp", "paint.exe");
        openWith.Add("dib", "paint.exe");
        openWith.Add("rtf", "wordpad.exe");

les clés sont txt, bmp etc ... et les valeurs (définitions) notepad.exe etc ...

Dans ton cas Param et cmd.instruction sont lesquels ?

**Othana** · 20/10/2010, 15h31

bon, param n'est utilisé que dans une méthode d'une classe externe pour obtenir le dictionnaire cmd.
Et donc, cmd.inctruction correspondrait à "txt", "bmp" etc.

Donc : cmd["instruction"]

**Othana** · 20/10/2010, 15h39

Réécriture du code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
List <Dictionary> cmdlist;
Dictionary<string,string> cmd;
 
public void Createcmdlist (List <string> param)
{
   foreach (argument in param)
   {
      cmd=Driver.RechInstruction(argument);
      if(!cmdlist.Contains(cmd))
        cmdlist.Add(cmd);
   }
}

**zouuc** · 20/10/2010, 15h40

Si ça se trouve je n'avais tout simplement pas compris ce que tu voulais faire de "Reset" par exemple.
Tu veux concaténer les différents paramètres d'une seul commande sil il y a plusieurs fois la même commande, ceci à la place d'ajouter plusieurs fois la commande dans ton dictionnaire ?

Donc Dictionary<string, string> prendrait les différents paramètres ?

Par exemple,

Au lieu d'avoir dans ton dictionnaire :
("instruction1", "Reset")
("instruction1", "Reboot")
("instruction1", "Sleep")

tu aurais
("instruction1", "ResetRebootSleep")

Ou alors je comprend rien (là désolé mais c'est pas forcement évident de comprendre avec un point de vue externe)

**Othana** · 20/10/2010, 15h55

ça c'est un autre problème.
dans cmdlist, en fait, je récupère une structure de commande.
c'est à partir de cette structure que je récupère les valeurs de même nom que <string, STRING> pour concaténer string commande=Reset+Reboot+Sleep

**zouuc** · 20/10/2010, 16h05

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
List <Dictionary> cmdlist;
Dictionary<string,string> cmd;
 
public void Createcmdlist (List <string> param)
{
   foreach (argument in param)
   {
      cmd=Driver.RechInstruction(argument);
      if(!cmdlist.Contains(cmd))
        cmdlist.Add(cmd);
      else
        cmdlist.cmd.argument += argument;
   }
}

Là ça concatène les différents arguments pour une même commande. Est-ce, ce que tu veux faire ??

**Othana** · 20/10/2010, 16h08

non, le else est de trop. les valeurs qui vont se concaténer dans la commande finale ont une autre source que cmd.

**zouuc** · 20/10/2010, 16h12

Quelle est donc cette autre source ?

Tu me demandes bien de concaténer les différents paramètres d'une même instruction, mais dans le foreach ?

**Othana** · 20/10/2010, 16h18

bon, dans cette commande, chaque argument fait l'objet d'une textbox de l'IHM : $WP+TRACK+[Tag]=[Password],[Mode],[Time],[Distance],[Number of TrackingTimes],[Track basis],[CommSelect],[Heading]
TRACK est l'instruction
imagine que sur l'IHM, j'en modifie un et je veux le renvoyer, donc en réécrivant la commande
on note, la présence de $WP, en premier, mais qui va changer ou ne pas exister, d'un appareil à l'autre
voilà ce que fait mon appli
mais cette structure de commande, elle ne la connais pas, puisque c'est différent d'un appareil à l'autre
la structure est connu dans un driver
dictionnaire = structure de commande et la liste = différentes commande pour différents arguments de l'IHM qui ne sont pas tous dans la même instruction
les valeurs des arguments sont dans l'IHM, mais la valeur de "instruction" (ici "TRACK") est connu du driver, donc il la passe directe.

construction d'une liste de listes, etc.

C#

Discussions similaires

Partager

Partager