Discussion :

[lou87]

Bonjour,

D'après mon titre le problème peut sembler simple, mais ça ne l'est pas tout à fait (enfin pour moi ).

Je voudrais déjà savoir comment l'on peut savoir (par programmation) si une variable change de valeur.

J'ai déjà trouvé quelques commencements de réponse mais je n'arrive pas à les utiliser...

(celui-ci me semble être le plus clair, mais je n'ai pas réussi à l'appliquer/l'utiliser...)

Comment puis-je faire pour utiliser cette fonction/abonnement afin de dire 'cette variable à changer de valeur donc il faut faire ça', s'il vous plaît ?

Je sais que c'est un truc tout bête mais pour l'instant je n'ai pas encore réussi à mettre le doigt dessus...

En vous remerciant.

[Invité]

Je suppose que tu veux dire une propriété parce que dans le cas d'un champ ou d'une variable locale à une fonction alors c'est impossible et pour le dernier cas ça n'a aucun intérêt.

Dans le premier lien que tu as fourni une solution simple t'est donnée à condition que tu disposes d'une Propriété. La solution fournie est identique à celle fournie par l'interface INotifyPropertyChanged. Tu verras un exemple d'implémentation sur le site MSDN ici.

[lou87]

Bonjour,

Merci de m'avoir répondu.

Cependant je n'arrive pas à comprendre comment cela fonctionne.

N'y a-t-il pas une fonction booléenne qui permettrait de dire si la valeur à changer alors la fonction renverrait true, et sinon false ?

Je dois faire assez simple car c'est un projet déjà existant et l'on est plusieurs à travailler dessus....

Car là je dois avouer que je m'y perds un peu...

Il faut juste que j'arrive à voir si la valeur de la variable ID change ou pas et si oui qu'il fasse une action.

Est-ce possible, pouvez-vous m'expliquer s'il vous plaît ?

En vous remerciant.

[Invité]

N'y a-t-il pas une fonction booléenne qui permettrait de dire si la valeur à changer alors la fonction renverrait true, et sinon false ?

Non

Déjà je ne peux pas changer le type de la class... Celui du projet est AdminUserControl et je ne peux pas le changer en INotifyPropertyChanged.

La bonne pratique t'aide toi-même mais surtout ceux qui reprendront le code après toi. La solution avec INotifyPropertyChanged ne consiste pas à renommer ta classe mais à implémenter cet interface c'est tout. La lecture du lien que je t'ai fourni et tester les exemples ne te prendra pas plus d'une heure de ton temps et l'implémentation pas plus de 15 mn.

Pense à ceux qui viendront après toi pour reprendre le code. Tu risques de déclencher des tas des crises, de dépressions, de suicides et tu en seras responsable

[lou87]

Non

Arf, c'était trop beau pour être vrai.

La bonne pratique t'aide toi-même mais surtout ceux qui reprendront le code après toi. La solution avec INotifyPropertyChanged ne consiste pas à renommer ta classe mais à implémenter cet interface c'est tout. La lecture du lien que je t'ai fourni et tester les exemples ne te prendra pas plus d'une heure de ton temps et l'implémentation pas plus de 15 mn.

C'est en cours...

Pense à ceux qui viendront après toi pour reprendre le code. Tu risques de déclencher des tas des crises, de dépressions, de suicides et tu en seras responsable

Oui j'ai des questions et réflexions bêtes/stupides............

Merci de ton aide.

(Je fermerais dès que j'aurais réussi )

[StringBuilder]

Bonjour,

Je me pose la question du besoin réel d'un événement pour savoir si une propriété à changé.

En effet, l'événement va déclencher un traitement à l'instant T où ta valeur est modifiée. Ça peut être très bien dans certains cas, mais pas systématiquement.

Si par exemple la propriété est modifiée par une saisie dans une Form, et qu'au moment de sortie de la Form tu souhaite savoir s'il faut enregistrer les modification ou non (et donc déterminer s'il y en a eu !) alors un événement, mise à part pour la beauté de l'art, ne sert à rien.

Code de départ :

Code c# :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
class MaClass
{
  public int MaValeur = 0;
 
  void MaMethode1(int val);
  {
      MaValeur = val; // Je veux savoir si j'ai modifié la valeur ici
  }
  void MaMethode2(int val);
  {
      MaValeur = val * 2; // Ou là
  }
}

Code modifié :

Code c# :

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
 
class MaClass
{
  private int backvalue_MaValeur = 0;
 
  public bool Changed = false;
  public int MaValeur
  {
     set
     {
          if (value != backvalue_MaValeur)
          {
               Changed = true;
               backvalue_MaValeur = value;
          }
     }
     get
     {
          return backvalue_MaValeur;
     }
  }
 
  void MaMethode1(int val);
  {
      MaValeur = val; // Ca met à jour Changed si la valeur est modifiée
  }
  void MaMethode2(int val);
  {
      MaValeur = val * 2; // Et là aussi
  }
}

Ceci permet aussi de piloter si oui ou non tu veux modifier la valeur en activant ou non le setter. Par exemple, si tu as un bouton "load" qui permet de charger les propriété de ton objet à partir d'une base de donnée, alors tu ne voudra pas passer "Changed" à true, au contraire.

Du coup tu feras :

Code c# :

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

1
2
3
4
5
 
  void Load(int val);
  {
      backvalue_MaValeur = val; // Là, je ne déclenche pas le "set" de MaValeur.
  }

[notia]

Les événements sont pratiques afin d'éviter de multiples implémentations de la même logique de détection/exécution. => factorisation du code.
En C# les évènements s'appuient sur le concept des délégués (Deleguate), donc attention aux performances.

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
 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace ConsoleApplication1
{
    public class MaClasse
    {
        private bool etat = false;
        public event EventHandler MonGestionEvenement;
 
        public void ChangeEtatMaClasse(bool test)
        {
            etat = test;
            OnChangeEtatMaClasse(etat, new EventArgs());
        }
 
        protected virtual void OnChangeEtatMaClasse(object sender, EventArgs e)
        {
            if (MonGestionEvenement != null)
            {
                MonGestionEvenement(sender, e);
            }
        }
 
    }
 
    class Program
    {
        static void Main(string[] args)
        {
            MaClasse m = new MaClasse();
 
            m.MonGestionEvenement += new EventHandler(ExecuterQuandChangement);
 
            m.ChangeEtatMaClasse(true);
        }
 
        static void ExecuterQuandChangement(object sender, EventArgs e)
        {
            Console.Write(sender.ToString());
            Console.ReadKey();
        }
 
    }
}