Discussion :

[nicoletflo]

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"!

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

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
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!!!

[SaumonAgile]

Code :

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

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

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

[StormimOn]

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

Code :

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

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

[nicoletflo]

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 :

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
 
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)
-----?

[Invité]

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

Code :

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

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 :

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

[nicoletflo]

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

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
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!

[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

[nicoletflo]

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

[Invité]

oki doki.
Bonne continuation