influance des objet sur la memoire et performance en generalRésolu

Question

Bonjour tout le monde,

je suis assez novice dans le domaine, bien qu'ayant quelques connaissances je me suis posé la question suivante lors d'un exercice, il est demander à ce que l'ellipse se redimensionne et se redessine à la taille de la zone cliente du formulaire lorsque celui est redimensionné, le code que j'ai écris fonctionne (en libérant ou en ne libérant pas les ressources) mais ma question est : ne vaut il pas mieux d'abord libérer les ressources de l'objet avant de le réemployer dans l'exemple suivant (voir évènement "resize" du formulaire): 

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Drawing.Imaging;
using System.Text;
using System.Windows.Forms;

namespace GraphicsEssais
{
    public partial class GraphicsEssais : Form
    {
        private Bitmap m_objMaSurfaceDeDessin;
        public GraphicsEssais()
        {
            InitializeComponent();
        }
        
        private void GraphicsEssais_Load(object sender, EventArgs e)
        {
            m_objMaSurfaceDeDessin = new Bitmap(this.ClientRectangle.Width, 
                this.ClientRectangle.Height, PixelFormat.Format24bppRgb);
            
             DessinerUneEllipsePleine();            
        }
        
        private void DessinerUneEllipsePleine()
        {
            Rectangle objCadre;
            Graphics objDessin;
            //on reference le bitmap objMaSurfaceDeDessin en memoire en tant que objDessin
            objDessin = Graphics.FromImage(m_objMaSurfaceDeDessin);
            
            //on vide le Bitmap referencer (objDessin)et on lui attribut une couleur
            objDessin.Clear(SystemColors.Control);
            
            //on definit la taille et l'emplcement du cadre acceuillant le dessin 
            objCadre = new Rectangle(0, 0, m_objMaSurfaceDeDessin.Width, 
                m_objMaSurfaceDeDessin.Height);
            
            //on retrécie le cadre de sorte à ce que le dessin ne soit pas recouvert par les bords
            objCadre.Inflate(-1, -1);
            
            // on trace la forme sur l'objet en l'associant au cadre
            objDessin.FillEllipse(Brushes.AliceBlue, objCadre);
            
            //on libere les resources
            objDessin.Dispose();            
        }

        private void GraphicsEssais_Paint(object sender, PaintEventArgs e)
        {            
            //on trace (dessine) le contenu du bitmap de la surface de dessin en memoire sur 
            //le formulaire 
            e.Graphics.DrawImage(m_objMaSurfaceDeDessin, 0, 0, m_objMaSurfaceDeDessin.Width,
                m_objMaSurfaceDeDessin.Height);
            
            //on libere les ressources
            e.Dispose();
        }

        private void GraphicsEssais_FormClosed(object sender, FormClosedEventArgs e)
        {
            //on libere les ressources a la fermeture du programme
            m_objMaSurfaceDeDessin.Dispose();
        }

        private void GraphicsEssais_Resize(object sender, EventArgs e)
        {
            //***********************************************************************
    // C'est ici que je me suis posé la question, dans l'evenement Resize:
    // Faut il ici d'abord libérer les ressources de m_ objMaSurfaceDeDessin
    // ou cela n'a aucune importance ou influance? (mémoire, performance?)
            //***********************************************************************
            //on libere les recource du bitmap

            m_objMaSurfaceDeDessin.Dispose();
            
            //on crée un nouveau Bitmap
            m_objMaSurfaceDeDessin = new Bitmap(this.ClientRectangle.Width, 
                this.ClientRectangle.Height, PixelFormat.Format24bppRgb);
            
            DessinerUneEllipsePleine();
            
            this.Invalidate();
        }

       
    }
}

Le code n'est surement pas extraordinaire et super optimiser, il y a surement moyen de faire plus conçit et de l'optimiser, mais mon but premier pour le moment est de l'écrire par les moyens les plus simple et les plus "détaillés" possible histoire de comprendre au mieux ce qui ce passe lors de l'execution? Toutefois je suis preneur de toutes remarques, commentaires ou conseil afin de pouvoir m'ameliorer et de progresser dans la bonne voie?


Si quelqu'un pouvais m'éclaircir, je le remerci d'avance?

Lutinore · Accepted Answer

Salut, tu pouvais déssiner directement l'ellipse sur la forme sans passer par un bitmap.. mais si tu souhaites avoir un buffer en champ privé de la classe alors c'est la bonne méthode.

C'est bien d'appeller Dispose sur le buffer avant d'en créer un second, ça libère les ressources et particulièrement les ressources non managées bien plus vite que le GC. En général, après Dispose on met l'objet à NULL mais là comme tu réalloues tout de suite la variable ça revient au même.

Safti · Answer

Bonjour et merci pour ta réponse,  les choses sont un peu plus clair?

Pour ce qui est du Bitmap c'est demandé dans l'exercice? C'est un peu plus compliqué mais cela comporte des avantages apparemment (à approfondir...), certes pas dans cet exemple précis avec qu'un seule objet à dessiner mais avec plusieurs voir toute une interface si j'ai bien compris.

Bon je peu à présent attaquer le chapitre suivant? dur de se remettre dans le bain après 10ans? les objets sont un monde totalement différent par rapport à la programmation séquentiel? ;o)))

Influance des objet sur la memoire et performance en general

2 réponses

Votre réponse

Discussions similaires