Discussion :

[shwin]

Tu as tout à fait raison, mais n'oublies pas qu'ici je donne un exemple simple en utilisant le framework .net et que mon problème est plus complexe que ça par ce que j'utilise un framework propriétaire et je suis obligé de faire une instanciation de mon objet lors du clique sur le bouton.

Si tu nous expliquait ton vrai problème au lieu de dire que tu est contraint par le FW. Tu sais, tout est pratiquement extensible. Tu peux faire ce que tu veux.

Le framework est tres bien, je suis pret a gagé que c'est ton code, ou encore ta facon de faire qui est pas correct pour ton vrai problème.

[Guulh]

Tu as tout à fait raison, mais n'oublies pas qu'ici je donne un exemple simple en utilisant le framework .net et que mon problème est plus complexe que ça par ce que j'utilise un framework propriétaire et je suis obligé de faire une instanciation de mon objet lors du clique sur le bouton.

Tu pourrais donner des détails ?
Parce qu'à mon avis, après avoir rajouté le picturebox en question dans le designer ou a la mano dans le constructeur de ta form, le code de ton button_click peut se résumer à ça :

Code :

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

1
2
3
4
5
6
private void button1_Click(object sender, EventArgs e)
        {
            if (pb.Image != null)
             pb.Image.Dispose();
            pb.Image = new Bitmap("c:\\image.jpg");
        }

Et là, pouf, pas de fuite mémoire, ni de fichier locké inutilement.

[olibara]

Et là, pouf, pas de fuite mémoire, ni de fichier locké inutilement.

Et bien justement ! c'est en faisant ca que "c:\\image.jpg" sera locké inutilement, c'est pour ca que je passe par un stream !

Pour le reste c ok

[Keihilin]

Avec ce code :

Code :

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

1
2
3
4
5
6
7
 
private void button1_Click(object sender, EventArgs e)
        {
            PictureBox pb = new PictureBox();
            pb.Image = new Bitmap("c:\\image.jpg");
            this.Controls.Add(pb);
        }

on remarque bien qu'il y a une fuite mémoire...

Comme c'est étonnant !
A chaque click tu crées un nouveau PictureBox et tu l'ajoutes à la collection de contrôles de ta Form, créant ainsi des objets qui seront toujours reférencés et qui survivront donc à un Collect()...

Donc, comme cela a déjà été dit, ce n'est pas une fuite, c'est un comportement normal par rapport à ton code.

Il y as pas de memoryleak en c# justement grace au GC

C'est surtout là-dessus que je souhaitais réagir.

Bon nombre d'applications .Net souffrent de fuites mémoire plus ou moins graves justement parce que les développeurs s'imaginent que le GC est un outil magique qui va prendre en charge le nettoyage.

1. Le GC se base sur un graph de références afin de déterminer les objets libérables. Les erreurs de design, les références croisées et les abus d'objets ou de méthodes statiques peuvent très facilement le faire pédaler dans le semoule.

2. La vision du GC reste confinée à son petit monde managé. Dès lors que le reflèxe du "using()" ou du "try/finally --> Dispose" n'est pas acquis pour toute utilisation d'objet implémentant IDisposable, le GC ne sera pas d'un grand secours...

[Immobilis]

Bon nombre d'applications .Net souffrent de fuites mémoire plus ou moins graves justement parce que les développeurs s'imaginent que le GC est un outil magique qui va prendre en charge le nettoyage.

1. Le GC se base sur un graph de références afin de déterminer les objets libérables. Les erreurs de design, les références croisées et les abus d'objets ou de méthodes statiques peuvent très facilement le faire pédaler dans le semoule.

2. La vision du GC reste confinée à son petit monde managé. Dès lors que le reflèxe du "using()" ou du "try/finally --> Dispose" n'est pas acquis pour toute utilisation d'objet implémentant IDisposable, le GC ne sera pas d'un grand secours...

+1 000 000

[Guulh]

Sauf que là, en l'occurrence, c'est pas l'utilisation de using qui va sauver la mise, puisqu'on veut que l'objet vive plus longtemps que le bloc où il a été déclaré. Et dans ce cas là, il faut bien appeler Dispose à la main, plus tard.

@olibara : je te crois sur parole, les applis que je code au taf n'ayant pas d'images à charger à la main

[Immobilis]

il faut bien appeler Dispose à la main, plus tard

devoir faire ça ne met-il pas en évidence un défaut de conception?

[Guulh]

devoir faire ça ne met-il pas en évidence un défaut de conception?

Ben... non ?
Indépendamment du concept de langage managé ou pas, de GC et tout le bazar : les objets ont une durée de vie, qui est certes le plus souvent celle du bloc où ils ont été déclarés (qu'ils soient des variables membres d'un objet, ou déclarés dans le corps d'une méthode), mais pas systématiquement.

Sinon, il n'y aurait pas le mot-clé "delete" en C++.

Dans le cas qui nous intéresse, justement : le picturebox a une propriété Image, dont le type est Disposable parce qu'une Image détient des ressources non managées. On veut changer cette image de temps en temps. On ne dispose l'image ni avec un bloc using, ni dans le Dispose de la form, mais à la main.

[Keihilin]

Non, pas dans le cas des Winforms et contrôles apparentés.

Par extensions on pourrait dire que le problème ne peut pas vraiment se résumer à l'utilisation d'un "using()" pour tout objet dont le cycle de vie dépend d'une action de l'utilisateur...

[Guulh]

Non, pas dans le cas des Winforms et contrôles apparentés.

Parce que là en l'occurrence, indépendamment du problème de durée de vies des objets, en plus de ne pas disposer ses objets Image, Axiome utilisait un nouveau picturebox à chaque fois, ce qui est certes pas la meilleure chose à faire Mais le problème dont il est question n'est pas limité aux Winforms, qui font un usage standard de IDisposable : un gros machin (la form) instancie des tas de petits machins (les contrôles), dont il assure la responsabilité, puisqu'il les détruit quand lui-même est détruit.

[Immobilis]

Il est possible de faire une propriété pour accéder à la PictureBox comme cela est fait ci dessous pour un DataSet:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
private System.Data.DataSet _ds = null;
protected System.Data.DataSet ds
{
    get {
        if (_ds == null)
        {
            _ds = new System.Data.DataSet();
        }
        return _ds;
    }
}

Mais bon, en .net, tout est question de "class". S'agissant d'un bout de code non géré, la classe devrait être tout de même disposable. J'insiste lourdement?
A+

[Guulh]

Mais bon, en .net, tout est question de "class". S'agissant d'un bout de code non géré, la classe devrait être tout de même disposable. J'insiste lourdement?
A+

Beh c'est a dire que je vois pas ce que tu veux dire Quel rapport entre le lazy loading que tu présentes et la durée de vie des objets ? Tout est question de class ? Et personne ne doute que des classes comme PictureBox ou Bitmap doivent être Disposable

En plus, la, dans ton exemple, tu crees un dataset sans le disposer, alors que c'est idisposable Donc y'a bien des cas où on crée un objet sans le détruire aussitôt.

Et comme je disais tout a l'heure, le problème ici, c'est pas la picture box, puisqu'il suffit juste de changer sa propriete Image, sans toucher a la pb elle-même. La PictureBox, c'est un Control, et dans la plupart des applis, on définit ses controles dans le designer et on n'en rajoute ni n'en enlève plus au runtime.

[Immobilis]

En plus, la, dans ton exemple, tu crees un dataset sans le disposer, alors que c'est idisposable

Parce que j'ai pas codé la méthode dispose, vu que j'ai mis un exemple ici: http://www.developpez.net/forums/m4110724-8/. Ca me semblait
Ce "lazy loading" serait plutôt un "loading on demand". Je sais pas si ce terme existe, mais il se conformerait au "instancier tard libérer tôt". Vu que c'est un membre privé, il suffit d'appeler la propriété pour créer l'objet ou récupérer l'instance en cours (tu l'as compris).

Bon, je dis peut-être quelques betises vu que je fais jamais de WinForms.

Je viens de remarquer un truc. Si j'ai un Form2.cs, j'ai aussi Form2.Designer.cs dans lequel je trouve:

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
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
namespace WindowsApplication1
{
    partial class Form2
    {
        /// <summary>
        /// Required designer variable.
        /// </summary>
        private System.ComponentModel.IContainer components = null;
 
        /// <summary>
        /// Clean up any resources being used.
        /// </summary>
        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
        protected override void Dispose(bool disposing)
        {
            if (disposing && (components != null))
            {
                components.Dispose();
            }
            base.Dispose(disposing);
        }
 
        #region Windows Form Designer generated code
 
        /// <summary>
        /// Required method for Designer support - do not modify
        /// the contents of this method with the code editor.
        /// </summary>
        private void InitializeComponent()
        {
            this.components = new System.ComponentModel.Container();
            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
            this.Text = "Form2";
        }
 
        #endregion
    }
}

Un WinForm est disposable. Donc, il faudrait placer dans la méthode Dispose tout les objets disposables et les disposer.

Non?

A+

[Guulh]

Un WinForm est disposable. Donc, il faudrait placer dans la méthode Dispose tout les objets disposables et les disposer.

Ca tombe bien, c'est ce que fait le designer tout seul
C'est ce que je disais tout a l'heure :

les objets ont une durée de vie, qui est certes le plus souvent celle du bloc où ils ont été déclarés (qu'ils soient des variables membres d'un objet, ou déclarés dans le corps d'une méthode), mais pas systématiquement.

Mais la, vu qu'on change l'image plusieurs fois pendant la vie de la fenetre (dans l'exemple d'Axiome, on change d'image a chaque click sur un bouton), on est amené à créer (et donc à disposer) plusieurs fois des objets disposable.

[Immobilis]

Mais la, vu qu'on change l'image plusieurs fois pendant la vie de la fenetre (dans l'exemple d'Axiome, on change d'image a chaque click sur un bouton),

C'est plutôt toujours la même ou j'ai loupé un post?

du coup l'image est rapidement disposé (juste après l'accolade de fermeture) et ne sera pas visible dans la forme après le clique sur le bouton.

Je comprend pas trop ça. Comment se fait-il que l'image n'est pas visible?

Ca tombe bien, c'est ce que fait le designer tout seul

Ah? Parce que j'ai ajouté une PictureBox en mode design et VS n'a pas ajouté le dispose de cet objet dans le dispose du formulaire.
A quoi vois-tu qu'il le fait?

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
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
namespace WindowsApplication1
{
    partial class Form1
    {
        /// <summary>
        /// Required designer variable.
        /// </summary>
        private System.ComponentModel.IContainer components = null;
 
        /// <summary>
        /// Clean up any resources being used.
        /// </summary>
        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
        protected override void Dispose(bool disposing)
        {
            if (disposing && (components != null))
            {
                components.Dispose();
            }
            base.Dispose(disposing);
        }
 
        #region Windows Form Designer generated code
 
        /// <summary>
        /// Required method for Designer support - do not modify
        /// the contents of this method with the code editor.
        /// </summary>
        private void InitializeComponent()
        {
            this.pictureBox1 = new System.Windows.Forms.PictureBox();
            ((System.ComponentModel.ISupportInitialize)(this.pictureBox1)).BeginInit();
            this.SuspendLayout();
            // 
            // pictureBox1
            // 
            this.pictureBox1.Location = new System.Drawing.Point(13, 13);
            this.pictureBox1.Name = "pictureBox1";
            this.pictureBox1.Size = new System.Drawing.Size(100, 50);
            this.pictureBox1.TabIndex = 0;
            this.pictureBox1.TabStop = false;
            // 
            // Form1
            // 
            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
            this.ClientSize = new System.Drawing.Size(292, 273);
            this.Controls.Add(this.pictureBox1);
            this.Name = "Form1";
            this.Text = "Form1";
            ((System.ComponentModel.ISupportInitialize)(this.pictureBox1)).EndInit();
            this.ResumeLayout(false);
 
        }
 
        #endregion
 
        private System.Windows.Forms.PictureBox pictureBox1;
    }
}

Serait-ce parce qu'il l'ajoute à la collection des controles?

Code :

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

this.Controls.Add(this.pictureBox1);

Et que ensuite

Code :

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

components.Dispose()

Du coup, il faut peut-être suivre un pattern particulier pour ajouter des contrôles dynamiquement, non?
A+

[Guulh]

C'est plutôt toujours la même ou j'ai loupé un post?

Ca doit être pour l'exemple qu'il a collé un nom de fichier en dur. Ou peut être que ce fichier est modifié par un autre process. Parce qu'en effet, ça servirait à rien de ercharger toujours la même image.

Je comprend pas trop ça. Comment se fait-il que l'image n'est pas visible?

Beh si tu disposes un objet, il est plus utilisable.

Serait-ce parce qu'il l'ajoute à la collection des controles?

Code :

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

this.Controls.Add(this.pictureBox1);

Et que ensuite

Code :

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

components.Dispose()

Du coup, il faut peut-être suivre un pattern particulier pour ajouter des contrôles dynamiquement, non?
A+

Tout juste Il suffit de faire comme le designer, en cas de création dynamique de contrôle : l'ajouter à la collection après sa création. Si on en a plus besoin avant la mort de la Form, il faut juste le Disposer après l'avoir enlevé de la collection Controls.

[Immobilis]

Beh si tu disposes un objet, il est plus utilisable.

Non? Ce que je me demandais c'est pourquoi l'image ne serait-elle pas visible alors qu'elle a été ajouté à la PictureBox et la PictureBox ajoutée aux controles? Il faut vraiment que la durée de vie de la PB soit la même que celle du form?

[Guulh]

Non? Ce que je me demandais c'est pourquoi l'image ne serait-elle pas visible alors qu'elle a été ajouté à la PictureBox et la PictureBox ajoutée aux controles?

Beh parce que ses ressources (graphiques, GDI+ en l'occurence) ont été libérées. Et que si on a disposé un objet, c'est qu'on considère qu'on en a plus besoin. et une image qu'on affiche dans une fenêtre, on en a besoin.

La doc : http://msdn.microsoft.com/en-us/library/8th8381z.aspx

Call Dispose when you are finished using the Image. The Dispose method leaves the Image in an unusable state. After calling Dispose, you must release all references to the Image so the garbage collector can reclaim the memory that the Image was occupying.

[Immobilis]

Bon il semblerait que la meilleur solution soit:

1. Form1.cs

   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
   24
   25
   26
   27
   28
   29
   using System;
   using System.Collections.Generic;
   using System.ComponentModel;
   using System.Data;
   using System.Drawing;
   using System.Text;
   using System.Windows.Forms;
   using System.IO;
    
   namespace WindowsApplication1
   {
       public partial class Form1 : Form
       {
           private PictureBox pb = null;
    
           public Form1()
           {
               InitializeComponent();
           }
    
           private void button1_Click(object sender, EventArgs e)
           {
               using (FileStream fs = new FileStream(@"c:\temp\test.jpg", FileMode.Open, FileAccess.Read))
               {
                   pb.Image = Image.FromStream(fs, true, true);
               }
           }
       }
   }

2. Form1.Designer.cs

   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
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36
   37
   38
   39
   40
   41
   42
   43
   44
   45
   46
   47
   48
   49
   50
   51
   52
   53
   54
   55
   56
   57
   58
   59
   60
   61
   62
   63
   namespace WindowsApplication1
   {
       partial class Form1
       {
           /// <summary>
           /// Required designer variable.
           /// </summary>
           private System.ComponentModel.IContainer components = null;
    
           /// <summary>
           /// Clean up any resources being used.
           /// </summary>
           /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
           protected override void Dispose(bool disposing)
           {
               if (disposing && (components != null))
               {
                   components.Dispose();
               }
               base.Dispose(disposing);
           }
    
           #region Windows Form Designer generated code
    
           /// <summary>
           /// Required method for Designer support - do not modify
           /// the contents of this method with the code editor.
           /// </summary>
           private void InitializeComponent()
           {
               this.button1 = new System.Windows.Forms.Button();
               this.pb = new System.Windows.Forms.PictureBox();
    
               this.SuspendLayout();
               // 
               // button1
               // 
               this.button1.Location = new System.Drawing.Point(181, 217);
               this.button1.Name = "button1";
               this.button1.Size = new System.Drawing.Size(75, 23);
               this.button1.TabIndex = 0;
               this.button1.Text = "button1";
               this.button1.UseVisualStyleBackColor = true;
               this.button1.Click += new System.EventHandler(this.button1_Click);
               // 
               // Form1
               // 
               this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
               this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
               this.ClientSize = new System.Drawing.Size(292, 266);
               this.Controls.Add(this.button1);
               this.Controls.Add(this.pb);
               this.Name = "Form1";
               this.Text = "Form1";
               this.ResumeLayout(false);
    
           }
    
           #endregion
    
           private System.Windows.Forms.Button button1;
       }
   }

Les compteurs de perf affichent les valeurs de "handles GC" les moins élevées (cf image jointe)

Ce compteur affiche le nombre actuel de handles GC utilisés. Les Handles GC sont des handles pour les ressources externes au CLR et à l'environnement managé. Les handles occupent de petites quantités de mémoire dans le tas GC, mais nécessitent des ressources non managées qui peuvent être coûteuses.

[Guulh]

Sauf qu'il y a pas besoin de déclarer la picturebox dans le form.cs, autant le laisser dans le form.designer.cs.

Et ta solution crée une nouvelle instance de Image, qu'il faudrait bien disposer à la main si jamais on change d'image par la suite.