Discussion :

[Maniz]

Bonjour

Voilà, j'aimerais savoir si en Visual Basic, il existe une fonction, propriété ou autre qui permet de dé-assigner une variable avant que celle-ci n'ait atteint la fin de son module, fonction, etc..

J'ai vu par exemlpe qu'il existait la fonction Erase pour les tableau, il y en à t-il d'autres concernant variables et objets divers?


Merci d'avance si quelqu'un connait ce genre de fontion

[BenoitM]

Si c'est une objet "simple" il suffit de mettre la variable à null
Le Garbage collecteurs liberera la place
(tu peux forcer le passage du GC)
Sinon pour les objets utilisant des resources non managées (fichier, connection réseau, ect) il faut implémenter l'interface IDisposable()

Tu pourras alors utilisé Using , ou appelle la méthode Dispose()

[tomlev]

Voilà, j'aimerais savoir si en Visual Basic, il existe une fonction, propriété ou autre qui permet de dé-assigner une variable avant que celle-ci n'ait atteint la fin de son module, fonction, etc..

Code :

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

taVariable = Nothing

Mais pourquoi veux-tu faire ça au juste ?

[Maniz]

Merci pour le Dispose()

Et, mettre une variable à NULL fait que plus aucune place en mémoire ne lui est attribué? Cependant, elle reste toujours déclaré, non?

EDIT: Même question pour le Nothing ^^

Ben, pour le moment j'ai pas d'application concrète, c'est juste le fait d'avoir été obligé de mettre une variable temporaire pour clarifier le code, mais celle-ci me sert juste l'espace de quelques lignes. De ce fait, j'ai eu envie de savoir si j'avais un moyen de m'en débarasser sans attendre : Pas besoin de garder une variable inutile :p

[BenoitM]

Les variables n'ont de porté que dans le block ou elles sont déclarés

Donc si tu as une variable dans une fonction, elle ne sera accecible que dans cette fonction
Si tu l'as déclare dans un if , elle ne sera accecible que dans celui-ci
Par exemple

Code :

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

1
2
3
4
5
IF (....) THEN 
Dim i As Integer
'i existe
END IF
'i n'existe plus

Pour le null c'est l'équivalent en c# du Nothing en VB

Null/Nothing ne peuvent être utilisé qu'avec des objets de type référence (donc pas les Integer,Long,...)

[Maniz]

Merci Benoit, mais cela je le sais :p
Ma question concerne les blocs beaucoup plus grand.

If...Then
...
...
...
Déclaration
Utilisation
Destruction
...
...
End If

Et pour le GC, comment en forcer le passage? Peut-être connaissez vous un tuto détaillant son fonctionnement et les commandes associées en VB?

[BenoitM]

On ne fait pas de bloque plus grand, on découpe son programme en fonctions

Pour le Garbage Collector: GC.Collect()

Mais :
1) Avec les machines actuels tu n'as pas a te soucier d'une variable...*
2) L'appel au GC est lourd et donc à éviter

De plus quand tu mets ta varible à Nothing , elle ne sera libéré réellement que quand le GC passera donc "rien" ne sert de mettre ta variable à Nothing si tu vas bientot quitter le block où celle-ci a été déclarée

L'utilisation de la destruction d'objet n'a de sens que pour les fichiers,connection réseau,connection bd** et d'autre cas...

* J'ai pas dit qu'il fallait faire n'importe quoi non plus mais avec les DataSet/ le Binding, la couche graphique c'est pas un ou deux variables qui vont changer grand chose aux performances

**Et encore tu ne gères plus réellement la connection à la base de donnée en général il y a un pool de connection caché derrière

[Maniz]

Ouep, j'imagine bien que ce n'est pas avec des Dim que je vais dépasser les limite de la RAM de mon Ordinateur
Ma question n'avait pas vraiment pour but de débloquer quoi que ce soit, juste un but culturel :p Et qui forcément soulève d'autre choses qui m'intriguent ==> Google Chauffe^^

Enfin bref, en résumé:
Nothing permet de ré-alloué l'espace mémoire anciennement assigné à la variable
Mais pour la ré-utilisé, pas besoin de la re déclaré

Null..à la même vocation que nothing sauf que c'est du C#

Et l'utilisation forcé du GC est déconseillé :p

Je me trompe?

[tomlev]

Nothing permet de ré-alloué l'espace mémoire anciennement assigné à la variable
Mais pour la ré-utilisé, pas besoin de la re déclaré

Le fait d'affecter Nothing à la variable fait qu'elle ne référence plus l'objet, c'est tout. Si c'était la dernière référence à cet objet, celui-ci devient éligible au ramassage par le GC.

[sinople]

Disons que la gestion du ramasse miette (GC) est une chose complexe qui a retenu tout l'attention pendant un bout de temps au développeur de Microsoft. Si l'on a pas confiance dans l'implémentation de ce concept par le créateur du produit, on a meilleur temps de changer de technologie...

Dans les bonnes pratiques de tous les jours on libère les objets potentiellement volumineux et problèmatique (voir la liste dans un poste ci dessus) à l'aide d'un bloc Using (équivalent à un Dim objet suivit d'un objet.dispose mais plus propre (indentation du code et pas de risque d'oublier le dispose ou de supprimer ce dernier lors de la prochaine modification du code)).

Mettre des nothing en rafale dans une fonction et/ou procédure n'augmentera les performances de votre application d'une façon non mesurable, par contre la diminution de la lisibilité de votre code sera parfaitement mesurable !

A la place, séparé vos pavés de code en des fonctions ou procédures, d'une dizaine de ligne. Vous y gagnerez à tous les tableaux !

Il y a des situations ou l'utilisation du GC.Collect() est tout de même utile. Par exemple dans l'utilisation des objets Excel dans votre code afin d'éviter que des instances de ce dernier restent ouvertes.

[Maniz]

Merci de toutes vos réponses, je suis content de ces nouvelles connaissances :p

Je passe le sujet en résolu

[Pol63]

il y a deux choses à différencier, la portée de la variable dans le code, et l'espace mémoire de celle ci

concernant l'espace mémoire :

en .net il y a un espace mémoire appelé la pile (stack) et un appelé le tas (heap)
la pile est pour les types par valeurs (date, booleen, nombre, string, structure ...)
dim a as integer = 32
=> a obtient 4 octets sur la pile, ces 4 octets contiennent 32 en binaire
a = 16
=> à l'espace mémoire on vient écrire 16 en binaire à la place de 32
dim b as integer = a
=> b obtient 4 octets sur la pile, ces 4 octets contiennent la même chose que a (une copie) en binaire

le tas est pour les types par référence (object et tout ce qui en dérive, button, textbox et toutes les classes)
dim a as button
=> a obtient 4 (ou 8 en x64) octets sur la pile, ces octets contiennent un pointeur vers un espace mémoire ailleurs mais ce pointeur vaut Nothing, il ne pointe vers rien
a = new button
=> le pointeur prend une valeur qui désigne l'espace mémoire utilisé par l'instance du bouton
a = new button
=> le pointeur change de valeur et désigne un autre espace mémoire, l'ancien espace mémoire n'est plus pointé par rien, il sera libéré par le gc à l'occasion
dim b as button
=> quelques octets pour le pointeur, mais qui vaut Nothing
b = a
=> le pointeur de b obtient la même valeur que le pointeur de a, donc il désigne le même espace mémoire que a, donc toute modification sur a le sera aussi sur b
b = nothing
=> b ne pointe plus vers l'instance du bouton, mais a pointe encore vers cet espace mémoire
a = nothing
=> a ne pointe plus vers l'instance du bouton, plus personne ne pointe vers lui, le GC viendra alors le libérer à l'occasion (ca peut etre 2 secondes après comme 8 heures après)



concernant la portée des variables, il n'y a que des bloc qui font que tu n'as plus le droit de taper leur nom après le bloc

faire des plus petits morceaux de programme est une des solutions pour ton problème

mettre à Nothing est fait automatiquement en sortie de bloc

à l'aide d'un bloc Using (équivalent à un Dim objet suivit d'un objet.dispose mais plus propre (indentation du code et pas de risque d'oublier le dispose ou de supprimer ce dernier lors de la prochaine modification du code))..

et je rappelle aussi que ca permet d'appeler le dispose en cas d'exception aussi

dispose lui libère la mémoire non managée plus rapidement car dans le cas d'une image par exemple, le framework ne s'occupe pas de l'image, il demande à windows de s'en occuper, .dispose dit donc à windows qu'il n'en a plus besoin et windows libère la mémoire automatiquement

[tomlev]

Quelques petites précisions/corrections par rapport aux infos données par Pol63 :

• On parle habituellement de "types valeur" (structures, enums) et "types référence" (classes, interfaces, delegates), et non pas de types "par valeur" ou "par référence". Je sais, ça change pas grand chose... mais ça éloigne (un peu) la confusion qui est souvent entre le concept de types valeur/référence et le concept de passage de paramètres par valeur ou par référence.
• Cette affirmation :
  

  la pile est pour les types par valeurs (date, booleen, nombre, string, structure ...)

  est incorrecte.
  
  • String est un type référence et non un type valeur
  • La pile n'est pas "pour" les types valeur ; c'est une "croyance" très répandue et qui est fausse. La pile est pour les paramètres de méthode et pour les variables locales (entre autres). Les objets de type valeur peuvent être sur la pile, mais ils peuvent aussi être sur le tas (soit en étant membres d'un objet qui est sur le tas, soit via le boxing). Les objets de type référence sont par contre toujours sur le tas (mais les références à ces objets peuvent être sur la pile)

Ouais je sais, je chipote un peu

[Pol63]

String est un type référence et non un type valeur

je veux bien croire que c'est un type référence, car il peut valoir nothing, et pourtant quand on met un string dans un autre, modifier l'un ne modifie pas l'autre
enfin j'imagine bien pourquoi ce que je viens dire est aussi faux, mais c'est troublant

La pile n'est pas "pour" les types valeur ; c'est une "croyance" très répandue et qui est fausse. La pile est pour les paramètres de méthode et pour les variables locales (entre autres). Les objets de type valeur peuvent être sur la pile, mais ils peuvent aussi être sur le tas (soit en étant membres d'un objet qui est sur le tas, soit via le boxing). Les objets de type référence sont par contre toujours sur le tas (mais les références à ces objets peuvent être sur la pile)

là ça me perd un peu

Ouais je sais, je chipote un peu

et tu fais bien
j'ai failli hésiter à sortir des trucs pointus de peur de dire des conneries, mais j'me suis dit que dans le pire des cas j'en apprendrais plus via les corrections ^^

[tomlev]

je veux bien croire que c'est un type référence, car il peut valoir nothing, et pourtant quand on met un string dans un autre, modifier l'un ne modifie pas l'autre
enfin j'imagine bien pourquoi ce que je viens dire est aussi faux, mais c'est troublant

Qu'est-ce que tu appelles "mettre un string dans un autre" au juste ? Une chaine en .NET est immuable, tu ne peux pas la modifier... Affecter une autre valeur à une variable de type String ne modifie pas la chaine, ça fait juste pointer la variable vers une autre chaine.

Plein d'infos utiles sur les chaines ici :
http://csharpindepth.com/Articles/General/Strings.aspx

là ça me perd un peu

Bah c'est simple en fait... la pile contient les paramètres des méthodes et les variables locales. Ces variables sont :

• soit de type valeur, auquel cas elle contiennent directement une instance de ce type
• soit de type référence, et dans ce cas la variable contient juste une référence vers un objet qui est sur la pile.

Les objets qui sont sur la pile ont des membres, qui peuvent être de type valeur ou de type référence. L'objet contient donc des instances de type valeur, et/ou des références vers des instances de type référence

[sinople]

Je confirme pour l'histoire de la string qui n'est pas d'un type valeur (par contre un char est lui valeur).

C'est en effet pour cette raison que parfois la concaténation de chaîne en série peut être optimisée niveau gestion de la mémoire par un string builder.

En effet chaque modification sur une string va prendre un nouveau emplacement de mémoire (et balancer l'ancien vers le pool qui attend le GC).