Discussion :

[brousaille]

Bonjour,

j'ai un phénomene bizarre qui se produit lorsque j'utilise les variables d'application.

En effet j'initialise une variable d'application avec un ArrayList. Et je veux récupérer le contenu pour l'afficher ( dans une page ASP avec un DropDownList).

Voici mon code :

Code :

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

1
2
3
4
5
6
7
IList list = null;
             list = (IList)Application.Get(Constants.CITY_PRM);
             list.Insert(0, new Values("NULL", "Selectionner votre prm"));
             DDLIam.DataSource = list;
             DDLIam.DataTextField = "value";
             DDLIam.DataValueField = "id";
             DDLIam.DataBind();

En fait lorsque je fait mon Application.Get() je suis censé recevoir une liste de parametre (2 parametres) , et je stock ca dans un variable List. J'ajoute, une valeur à l'indice zero pour forcer l'utilisateur à sélectionner un parametre.

Seulement lors de mon premier passage, List contient bien les deux parametres puis j'ajoute le parametre NULL. Seulement au deuxieme passage, lorsque je fais le Application.get(), ca me renvoit mes deux parametres + le parametre NULL que j'ai ajouter au premier passage.

Plus je boucle et plus mon Application.get() me renvoit les valeurs NULL.

Au depart list vaut : PRM1, PRM2
2 eme pass list vaut : PRM1,PRM2, NULL
3 eme pass list vaut : PRM1,PRM2, NULL, NULL
etc etc.....

Je ne comprend pas ce qu'il se passe sachant que je ne rajoute jamais de valeur dans ma variable d'application, je ne fais que récupérer son contenu ??

Quelqu'un a t'il une idée de l'erreur !!!

Merci par avance de votre réponse.

B.

[brousaille]

En fait c'est comme si list pointait directement vers ma variable d'application. Car plus je rajoute de chose dans list plus ma variable d'application s'en trouve modifiée.

[Merlin]

c'est pas "comme si", c'est tout simplement la liste qui t'est renvoyée... Ce n'est pas une copie de la liste et de tous ses paramètres mais bien la liste, ze liste. Tu y accèdes via l'interface IList mais derrière c'est bien elle, pas un deep clone.
Donc si tu ajoutes des éléments, oeuf corse, ils se retrouvent dedans après, ce qui est parfaitement normal.

[brousaille]

Merci Merlin,

mais alors dans ce cas comment puis je faire pour récupérer uniquement la copie ?

[Merlin]

mais alors dans ce cas comment puis je faire pour récupérer uniquement la copie ?

il faut faire un deep clone de la liste originale.
l'un des moyens est de passer par la sérialisation mais il faut que tous les éléments de la liste soient sérialisables...
Si c'est le cas : serialiser la liste dans un stream mémoire, la déserialisée dans une autre variable liste. Tu auras un deep clone.

Maintenant il peut y avoir d'autres méthodes pour résoudre ton pb. Tu peux aussi marquer les éléments ajoutés et les supprimer à la fin du traitement. Ou peut être suffit il d'utiliser une liste à côté de la première.

[brousaille]

Merci Merlin,

quand tu me parles de Deep Clone, aurait tu un exemples.
Ma liste ne contient un ArrayList d'objet ayant pour attribut un id (int) un nom (String) et value (String). Je pense que ca doit etre serialisable sans probleme.

Mais quand meme je me demande, comment ca se fait qu'il me fournit la variable elle meme et non pas une copie ?? C'est quand meme bizarre, est ce que c'est pareille pour tout en .NET.

Genre si j'ai :

Code :

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

1
2
3
4
5
 
Int32 x = 1;
Int32 y = x;
 
y = y +1

Alors x vaudra 2 ????

Je trouve ca curieux !!!

[Merlin]

quand tu me parles de Deep Clone, aurait tu un exemples.
Ma liste ne contient un ArrayList d'objet ayant pour attribut un id (int) un nom (String) et value (String). Je pense que ca doit etre serialisable sans probleme.

Il faut que l'objet en question soit marqué par l'attribut [Serializable] sinon il n'est pas sérialisable par défaut.

Mais quand meme je me demande, comment ca se fait qu'il me fournit la variable elle meme et non pas une copie ?? C'est quand meme bizarre, est ce que c'est pareille pour tout en .NET.
Genre si j'ai :

Code :

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

1
2
3
Int32 x = 1;
Int32 y = x;
y = y +1

Alors x vaudra 2 ????
Je trouve ca curieux !!!

C'est même comme ça dans la majorité des langages POO :-)
Sous .NET la nuance est faite selon le type : type par valeur ou type par référence.
Un type par référence est un objet alloué en mémoire, sa variable "pointe" l'adresse mémoire. Un ArrayList est un type par référence.
Les type par valeur, comme leur nom l'indique, sont des types dont les instances sont allouées dans la pile et qui contiennent directement leur données. Sous C# ce sont tous les objets créés avec Struct par exemple.

De fait, si :

Code :

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

1
2
3
4
ArrayList A;
ArrayList B;
// init ici de B par new...
A = B; // les adresses sont identiques

Dans ce cas tu dis seulement que l'adresse pointée par A est identique à l'adresse pointée par B.
Donc A.add("machin"); est strictement identique à B.add("machin"); !

Mais :

Code :

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

1
2
3
4
int i = 2;
int j = 0;
j = i; // ici j = 2
j++; // j = 3; mais i reste à 2 !

ici les entiers sont des types par valeur, une affectation = créée une copie de la valeur, pas de l'adresse... Les deux variables sont et restent indépendantes...


Il est essentiel de comprendre ce mécanisme.

[brousaille]

Alors la je t'avoue que j'apprend un truc !!!
Pourtant j'ai toujours bossé en POO mais jamais je m'étais rendu compte de ca !!! En tout cas la notion de Type par référence et Type par valeur, je n'avais jamais entendu parler de ca !!! Je vais donc me renseigner la dessus !!

Merci pour ces explications Merlin !!

[Merlin]

Alors la je t'avoue que j'apprend un truc !!!
Pourtant j'ai toujours bossé en POO mais jamais je m'étais rendu compte de ca !!! En tout cas la notion de Type par référence et Type par valeur, je n'avais jamais entendu parler de ca !!! Je vais donc me renseigner la dessus !!
Merci pour ces explications Merlin !!

content de t'avoir appris un truc, surtout que c'est important comme nuance.
Sous Delphi Win32 par exemple tu retrouves les mêmes choses, il y a les types scalaires et les types objets. ça revient un peu respectivement aux types par valeur et types par références.
On retrouve ça un peu partout en fait. C'est lié au fait que si tout est objet, tout devient indirection (une variable = une adresse qui pointe vers la vraie donnée) et que cela entraine par force des baisses de performances.
La plupart des langages POO "utilisables" essayent de marier au mieux les impératifs de la POO et ceux de l'efficacité du code exécuté.
Sous Delphi win32 qui est plus "rustique", il y a des types de bases pas du tout objet, ceux là sont "copiés par valeur" et il y a des objets descendant de TObject toujours affecté par référence.
Sous C# qui est plus moderne, ils ont réussi à faire en sorte que les types "de base" comme les entiers, les dates, etc, puissent être considérés comme des objets quand c'est nécessaire (le fameux "boxing") mais qu'ils restent des types "simples" pour toutes les opérations habituelles qui ne doivent pas être ralenties par des indirections en mémoire...