liaison de données - difficulté à comprendre

**bubblebe** · 02/05/2017, 19h35

Bonjour à tous,

Voilà j'ai lu et relu la question des event et j'ai vraiment du mal à faire le saut vers la liaison de donnée signalant le changement de propriété

je reprend le code d'ici https://msdn.microsoft.com/fr-fr/lib...v=vs.110).aspx

j'annote comment je comprend le truc

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
using System.ComponentModel;

namespace SDKSample
{

  public class Person : INotifyPropertyChanged
  {
      private string name;
     
      public event PropertyChangedEventHandler PropertyChanged; // déclaration de l'évenement qui va avoir comme nom de variable "PropertyChanged" et ayant la signature de "PropertyChangedEventHandler "

      public Person()
      {
      }

      public Person(string value)
      {
          this.name = value;
      }

      public string PersonName
      {
          get { return name; }
          set
          {
              name = value;
             
              OnPropertyChanged("PersonName"); // on fait appel à la méthode pour signaler la modification de propriété avec en param le nom de la propriété modifié
          }
      }

    
      protected void OnPropertyChanged(string name)
      {
          PropertyChangedEventHandler handler = PropertyChanged; // La je commence à bloquer : on créé un pointeur handler de la signature (ou de type?)  PropertyChangedEventHandler  qui pointe vers lévenement déclaré plus haut? C'est chinois... lol 
          if (handler != null) // pourquqoi doit-on vérifier que le handler n'est pas null? je suppose qu'on vérifie qu'il est associé à un propriété mais je ne vois pas où on l'a associé
          {
              handler(this, new PropertyChangedEventArgs(name));
          }
      }
  }
}

Si quelqu'un a le courage de m'expliquer le bout de code? la je patauge completement.

Merci

**MABROUKI** · 04/05/2017, 01h15

bonjour

// pourquqoi doit-on vérifier que le handler n'est pas null?

Parce que le Delegate est null , s'il n'y a pas d'abonné :
le Delegate n'existe que s'il y a un class qui s'y abonne
Exemple d'abonné qui instancie le Delegate (c'est du Wpf car INotifyPropertyChanged n'est valide qu'en Wpf):

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
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using System.ComponentModel;
 
namespace WpfDelegate
{
    /// <summary>
    /// Logique d'interaction pour MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {
        private Person person = null;
        public MainWindow()
        {
            InitializeComponent();
            this.Loaded += new RoutedEventHandler(MainWindow_Loaded);
            this.Closing += new CancelEventHandler(MainWindow_Closing);
        }
        void MainWindow_Loaded(object sender, RoutedEventArgs e)
        {
            person = new Person();
            // instanciation du delegate
            person.PropertyChanged += new PropertyChangedEventHandler(p_PropertyChanged);
        }
 
        void MainWindow_Closing(object sender, CancelEventArgs e)
        {
            if (person !=null)
                //nullification du delegate
            person.PropertyChanged -=new PropertyChangedEventHandler(p_PropertyChanged);
            person = null;
        }
 
 
        void p_PropertyChanged(object sender, PropertyChangedEventArgs e)
        {
            if (e.PropertyName == "PersonName")
                ;//action
 
        }
    }
 
 
 
  public class Person : INotifyPropertyChanged
  {
      private string name;
 
      public event PropertyChangedEventHandler PropertyChanged; // déclaration de l'évenement qui va avoir comme nom de variable "PropertyChanged" et ayant la signature de "PropertyChangedEventHandler "
 
      public Person()
      {
      }
 
      public Person(string value)
      {
          this.name = value;
      }
 
      public string PersonName
      {
          get { return name; }
          set
          {
              name = value;
 
              OnPropertyChanged("PersonName"); // on fait appel à la méthode pour signaler la modification de propriété avec en param le nom de la propriété modifié
          }
      }
 
 
      protected void OnPropertyChanged(string name)
      {
          PropertyChangedEventHandler handler = PropertyChanged; // La je commence à bloquer : on créé un pointeur handler de la signature (ou de type?)  PropertyChangedEventHandler  qui pointe vers lévenement déclaré plus haut? C'est chinois... lol 
          if (handler != null) // pourquqoi doit-on vérifier que le handler n'est pas null? je suppose qu'on vérifie qu'il est associé à un propriété mais je ne vois pas où on l'a associé
          {
              handler(this, new PropertyChangedEventArgs(name));
          }
      }
  }
}

bon code...

**François DORIN** · 04/05/2017, 08h44

Bonjour,

Envoyé par bubblebe

Code :

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

1
2
3
4
5
6
7
8
9
10
11
      protected void OnPropertyChanged(string name)
      {
          PropertyChangedEventHandler handler = PropertyChanged; // La je commence à bloquer : on créé un pointeur handler de la signature (ou de type?)  PropertyChangedEventHandler  qui pointe vers lévenement déclaré plus haut? C'est chinois... lol 
          if (handler != null) // pourquqoi doit-on vérifier que le handler n'est pas null? je suppose qu'on vérifie qu'il est associé à un propriété mais je ne vois pas où on l'a associé
          {
              handler(this, new PropertyChangedEventArgs(name));
          }
      }
  }
}

La gestion des événements est à la fois simple et compliquée : simple quand on a compris, et compliqué quand on se plonge dedans la première fois

Pour répondre à la première question, à savoir pourquoi on copie le handler dans une variable, c'est pour tenir compte des accès potentiellement concurrentiels. En effet, si on fait un truc du style :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
      protected void OnPropertyChanged(string name)
      {         
          if (PropertyChanged != null)
          {
              PropertyChanged(this, new PropertyChangedEventArgs(name));
          }
      }
  }
}

alors entre le moment où la propriété est testé dans le if et le moment où elle est effectivement appelée ensuite, la propriété peut avoir changé et être null si on est dans un environnement multithread. Aussi, la bonne pratique, pour se prémunir de se genre d'effet désagréable et au combien super chiant à diagnostiquer est de toujours écrire le déclenchement des événements de la sorte. Ainsi, ils sont sûrs, quelque soit l'environnement dans lequel il est utilisé (monotâche ou multitâche).

Pour le second point, pourquoi faut-il tester le null, comme MABROUKI le signale justement, c'est parce que un delegate vide est un delegate... null !

Autre détail, qui n'a rien à voir avec le sujet initial, mais qu'il est fort utile de connaître, notamment dans le cas de l'implémentation de INotifyPropertyChanged. Comme tu as pu le constater, tu passes en paramètre le nom de la propriété qui a été modifiée, sous forme de chaîne de caractères. Ce qui est chiant avec cela, c'est que tu n'es pas à l'abris d'une faute de frappe ou de renommer ta propriété en oubliant de changer la chaîne qui ferait que ton événement deviendrait inutilisable. Aussi, il existe l'opérateur nameof, qui prend le nom d'une entité en paramètre et qui retourne le nom sous forme de chaîne de caractères. Ainsi, tu disposes d'une vérification à la compilation du nom de ta propriété

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
 public string PersonName
      {
          get { return name; }
          set
          {
              name = value;
 
              OnPropertyChanged(nameof(this.PersonName));
          }
      }

**bubblebe** · 04/05/2017, 19h05

Un tout grand merci pour vos réponses qui vont me donner du grain à moudre

C'est super sympa.
J'avoue que c'est un gros passage à avaler pour moi

je potasse là dessus et je reviens demain si j'ai encore des interrogations

liaison de données - difficulté à comprendre

Windows Forms

Discussions similaires

Partager

Partager