Discussion :

[stailer]

Salut,

J'ai posté un message il y a quelques temps sur les performances... Après quelques réponses qui m'ont aiguillé je peux me rendre compte aujourd'hui que mes gros soucis de fuites mémoire sont liés au "OnPropertyChanged" (je dois encore faire des tests pour vraiment en être sur).

En effet, j'ai une fenêtre très très chargée en composants (100 environ dont 2 DataGrid Telerik) et beaucoup de liaisons et d'appels dynamiques entre eux.

En enlevant simplement l'appel à mes ObservableCollection en OnPropertyChanged il me faut au moins 100 clics entre ma fenêtre d'accueil et cette fenêtre pour passer de 100 megs à 200 megs (processus IExplorer dans le gestionnaire des tâches).

En les réactivant : au bout de 12 clics je suis à 200 megs et ça freeze méchamment.

Ma question : l'un d'entre vous aurait-il concrètement implémenté un pattern genre WeakEvent que j'ai du mal à comprendre pour le moment ?

A part ce pattern (en espérant qu'il fonctionne bien), connaissez vous d'autres solutions pour "vider" la mémoire ? j'ai essayé le GC mais rien ne se passe...

Merci pour vos réponses,

[Samuel Blanchard]

La bonne solution sera d'implémenté pour chaque += un -=.
En pratique je n'implémente jamais de WeakEvent

[stailer]

ok ça je l'ai fait plus ou moins mais je me suis mal expliqué... Je parle ici des propriétés, pas des événements. Exemple :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
private ObservableCollection<clients> _clients;
public ObservableCollection<clients> AllClients()
{
    get { return _clients;}
    set {
         _clients = value;
         OnPropertyChanged("AllClients");
    }
}

Je suis en MVVM et cette propriété est appelée par binding directement dans un contrôle d'une vue, par exemple un datagrid :

Code :

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

1
2
 
ItemsSource={Binding AllClients, Mode=TwoWay}

Donc te concernant tu as également des forms avec une bonne 100ene de composants mais pas de souci de fuite mémoire aussi énorme ?

[Samuel Blanchard]

Non pas de problème de fuite. Le souci que tu rencontres ici est que ta gestion de collection n'est pas complète.

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
 
private ObservableCollection<Client> _clients;
 
public ObservableCollection<Client> AllClients()
{
    get { return _clients;}
    set {
 
         if( _clients != null )
         {
             // on désabonne l'ancien objet
             value.CollectionChanged -= new NotifyCollectionChangedEventHandler(AllClients_CollectionChanged);
         }
 
         _clients = value;
 
         if( value != null )
        {
             // on abonne le nouvelle objet
             value.CollectionChanged += new NotifyCollectionChangedEventHandler(AllClients_CollectionChanged);
        }
    }
}
 
private void AllClients_CollectionChanged( object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
        {
            switch( e.Action )
            {
                case NotifyCollectionChangedAction.Add :
 
                    foreach (Client client in e.NewItems)
                    {
                        client.PropertyChanged += new PropertyChangedEventHandler(ClientPropertyChanged);
                    }
 
                    break;
 
                case NotifyCollectionChangedAction.Remove:
                    foreach (Client client in e.OldItems)
                    {
                        client.PropertyChanged -= new PropertyChangedEventHandler(ClientPropertyChanged);
                    }
                    break;
            }
        }
 
        void ClientPropertyChanged(object sender, PropertyChangedEventArgs e)
        {
            Client client = sender as Client;
 
            switch( e.PropertyName )
            {
            }
        }

Je te conseille d'ecrire un snippet de ce type de collection qui, certe, est un peu lourd mais indispensable pour ne pas tomber dans le piège des memoryleaks Si tu veux je peux t'envoyer le mien.

[stailer]

Ah oui... la c'est du lourd..

je vais donc changer mes propriétés dès demain et tester ça.
Ca m'embête un peu mais bon.. 30 lignes de code pour 20 propriétés ça fait 600 lignes. Heureusement qu'on a les region

Merci beaucoup pour ta réponse qui je pense va m'enlever une grosse épine du pied. je te tiens au courant.

[Skyounet]

Non pas de problème de fuite. Le souci que tu rencontres ici est que ta gestion de collection n'est pas complète.

Hum je vois pas en quoi ton bout de code va l'aider...

A quoi bon s'abonner à CollectionChanged et à PropertyChanged si on ne fait rien dedans ?

Qu'entends-tu par : "pas complète" ?
Si son but est d'exposer simplement une ObservableCollection, ça sert à quoi de s'abonner au CollectionChanged puis à chaque PropertyChanged de chaque item de cette collection ? (par ailleurs tu ne t'abonnes pas au PropertyChanged des items présents dans la collection à l'assignation, seulement aux éléments rajoutés par la suite).

J'ai peut-être pas compris ce qu'il demande mais bon.

[Samuel Blanchard]

A quoi bon s'abonner à CollectionChanged et à PropertyChanged si on ne fait rien dedans ?

Le but etait de montrer comment on s'abonne proprement à PropertyChanged à l'intérieur d'une collection. Après je ne connais pas ce qu'il veut faire dedans. C'est à lui de rajouter sa propre gestion de propertyChanged

Qu'entends-tu par : "pas complète" ?

Quand on fait un += proprement on fait normalement un -=

Si son but est d'exposer simplement une ObservableCollection, ça sert à quoi de s'abonner au CollectionChanged puis à chaque PropertyChanged de chaque item de cette collection ?

Si j'ai bien compris le problème de Stailer, il a besoin de gérer les PropertyChanged dans une ObservableCollection proprement afin d'éviter des memoryleaks. Pour que les élements ajoutés/retirés de la collection prennent en compte l'evenement PropertyChanged, il faut bien s'abonner à CollectionChanged.

(par ailleurs tu ne t'abonnes pas au PropertyChanged des items présents dans la collection à l'assignation, seulement aux éléments rajoutés par la suite).

c'est vrai j'ai oublié dans mon exemple. Je l'ai écris un peu à l'arrache