Comment utiliser les listes génériques ?

Version imprimable

Bonjour,
je souhaite utiliser les types génériques afin de stocker 2 types de valeurs différentes dans une variable.
En fait je construit dynamiquement une requete SQL avec des paramètres, ce sont ces paramètres que je souhaite stocker dans ma variable, ils sont de 2 types: string et object.
Le problème est que je n'ai pas très bien compris comment utiliser une liste générique avec 2 valeurs à stocker par "lignes"!:cry:

voici un début de ce que j'aimerais faire:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 private class Parameters { string paramName {get; set;} object paramValue {get; set;} } public static void Main(string[] args) { List<Parameters> maListDeParam = new List<Parameters>(); maListDeParam.Add("un string"); maListDeParam.Add("un objet"); //parcours de la liste foreach (obj o in maListDeParam) //ici l'accès aux objets de ma liste!! }
Merci d'avance à ceux qui peuvent m'aider!!!:lol:

08/04/2008, 19h21
SaumonAgile

Code:

maListe.Add(new Parameter(machaine, mavalue));

Mon code sous-entends que tu as créé le constructeur avec 2 arguments.

Vu l'utilisation (paramètre pour requête SQL), un dictionnaire semblerait plus approprié qu'une liste.

Code:

1
2
3
4
5
6
7
8
9
10
Dictionary<string, object> parametres = new Dictionary<string, object>();
parametres.Add("MonParam1", valeur1);
parametres.Add("MonParam2", valeur2);
parametres.Add("MonParam3", valeur3);
...
foreach(KeyValuePair<string, object> parametre in parametres)
{
   string paramName = parametre.Key;
   object valeur = parametre.Value;
}

Merci pour vos 2 idées.
Les 2 exemples proposés me semble convenir, sauf que je me rends compte que j'ai un 3ème paramètre à utiliser, le type de l'objet jsutement.
le dictionary accepte 3 paramètres?
SInon, pour le list "normal", je peux l'utiliser avec 3 paramètres.
L'autre problème est, comment accéder aux valeurs de mes objets stockés dans la liste?
avec le for each bien sur, mais comment spécifier la "colonne" de l'objet que je veux utiliser?

voici mon début de solution:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 private class Parameters<S, O, T> { private S paramName { get; set; } private O paramValue { get; set; } private T paramType { get; set; } public Parameters(S name, O value, T pType) { paramName = name; paramValue = value; paramType = pType; } } List<Parameters> listParameters = new List<Parameters>(); listParameters.Add(new Parameters("nom du paramètre", "valeur", typeof(string))); foreach (object o in listParameters) -----?

Le dictionary marche comme ca :
tu as une clef et un objet associé à ta clef
Tu pourrais donc avoir un truc du genre :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
private class Parameter
{
    private object paramValue { get; set; }
    private Type paramType { get; set; }
 
    public Parameters(O value, T pType)
    {
        paramValue = value;
        paramType = pType;
    }
}
 
Dictionary<string, Parameter> parametres = new Dictionary<string, Parameter>();

Ceci dit tant qu'a utiliser la généricité autant vraiment l'utiliser et avoir ceci :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
private class Parameters
        {
            private String paramName { get; set; }
            private Object paramValue { get; set; }
            private Type paramType { get; set; }
 
            public Parameters(String name, Object value, Type pType)
            {
                paramName = name;
                paramValue = value;
                paramType = pType;
            }
        }
 
List<Parameters> listParameters = new List<Parameters>();
 
listParameters.Add(new Parameters("nom du paramètre", "valeur", typeof(string)));
 
foreach (Parameters p in listParameters)
        Console.WriteLine(p.paramName);

J'espère que ca t'aidera

Finalement je me suis inspiré de vos idées et j'ai résolu mon problème comme ceci:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
 
//classe générique
public class ParametersCmd<S, O, T>
    {
        public S paramName { get; set; }
        public O paramValue { get; set; }
        public T paramType { get; set; }
 
        public ParametersCmd(S name, O value, T pType)
        {
            paramName = name;
            paramValue = value;
            paramType = pType;
        }
    }
 
 List<ParametersCmd<string, object, Type>> listParameters = new List<ParametersCmd<string,object,Type>>();
 
listParameters.Add(new ParametersCmd<string, object, Type>("nom", "valeur", typeof(string)));
 
 foreach (ParametersCmd<string, object, Type> o in listParameters)
               Writeln(o.paramName, o.paramType, o.paramValue);

Encore un grand merci!:king:

09/04/2008, 09h59
Invité

Juste une question : pourquoi tu paramétrises ta classe avec string, object et Type ? C'est pas toujours ca que tu vas utiliser comme types ? Si oui c'est inutile, la généricité n'est à employer que quand elle sert vraiment. Ca allégera ta notation si tu t'en sers pas.
A plus
09/04/2008, 13h22
nicoletflo

Citation:

Envoyé par George7

Juste une question : pourquoi tu paramétrises ta classe avec string, object et Type ? C'est pas toujours ca que tu vas utiliser comme types ? Si oui c'est inutile, la généricité n'est à employer que quand elle sert vraiment. Ca allégera ta notation si tu t'en sers pas.
A plus

J'ai fait cela, afin de pouvoir adapter cette classe à d'autres types de données!
Pour ma première utilisation de la généricité, autant aller jusqu'au bout:D
09/04/2008, 14h34
Invité

oki doki.
Bonne continuation ;)