Discussion :

[escafr]

Bonjour,

Imaginons une classe

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
 
class toto {
 
private double _prix;
public double prix 
{
get {return _prix;}
set {_prix = value; onPropertyChanged("prix") ;}
}
 
 
private double _quantite;
public double quantite 
{
get {return _quantite;}
set {_quantite = value; onPropertyChanged("quantite") ;}
}
 
public double valeur 
{
get {return prix * quantite;}
}

J'aimerais pouvoir créer le graph de dépendance entre propriétés:
- la modif de prix fait modifié valeur
- la modif de quantité fait modifié valeur
Si prix est modifié alors je veux qu'il y ait un onPropertyChanged d'appeler pour valeur.


Peut on utiliser la réflexion pour faire ceci? et donc pouvoir définir les liens entre propriétés?

L'idéal étant de pouvoir le faire entre plusieurs classes....

Thx pour l'aide

[User.Anonymous]

Ce serait plutot des listeners qui serait intéressant dans ton cas.

Un truc dans le genre permet de changer le prix et d'afficher la valeur modifié

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
 
    public class cPrix
    {
        public event EventHandler<EventArgs> OnPropertyChanged;
        private double _prix;
 
        public double Prix
        {
            get { return _prix; }
            set
            {
                _prix = value;
                OnPropertyChanged(this, EventArgs.Empty);
            }
        }
 
        public double Valeur
        {
            get { return Prix * 10; }
        }
    }
 
    public class Main
    {
        private cPrix p;
 
        public void onLoad()
        {
            p = new cPrix();
            p.OnPropertyChanged += new EventHandler<EventArgs>(p_OnPropertyChanged);
 
            //Affichage de la valeur
            lblValeur.Text = p.Valeur;
        }
 
        public void p_OnPropertyChanged(object sender, EventArgs e)
        {
            //Mise à jour de la valeur à chaque chgt de prix
            lblValeur.Text = p.Valeur;
        }
 
        public void ChangePrix()
        {
            //Chgt de prix qui déclenchera la mise à jour de la valeur
            p.Prix = 12;
        }
    }

[escafr]

ouais mais justement je veux pas faire un listener par propriété, cest moche..

[tomlev]

Peut on utiliser la réflexion pour faire ceci? et donc pouvoir définir les liens entre propriétés?

Non, ce n'est pas possible : la réflexion permet d'examiner la signature et les métadonnées des membres de classe, mais pas leur code...

La solution généralement utilisée dans ce genre de cas est d'appeler onPropertyChanged pour toutes les propriétés dont tu sais qu'elles seront impactées :

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
class toto
{
    private double _prix;
    public double prix 
    {
        get {return _prix;}
        set
        {
            _prix = value;
            onPropertyChanged("prix") ;
            onPropertyChanged("valeur") ;
        }
    }
 
    private double _quantite;
    public double quantite 
    {
        get { return _quantite; }
        set
        {
            _quantite = value;
            onPropertyChanged("quantite") ;
            onPropertyChanged("valeur") ;
        }
    }
 
    public double valeur 
    {
        get { return prix * quantite; }
    }

[escafr]

je m'en doutais un peu.

J'ai fait tout un truc pour que ce soit plus propre pour créer un arbre.

si ca vous interesse:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
protected override void initPropertiesDependencies()
        {
            propertiesDependencies = new Dictionary<string, List<PairObjProperty>>
            {
                {"solde", new List<PairObjProperty> {new PairObjProperty(this,"recommandedNominalRestant"), new PairObjProperty(this,"nominalRestant")}},
                {"obsTitresEligibles", new List<PairObjProperty> {new PairObjProperty(this,"dicoTitresEligibles"), new PairObjProperty(this,"sommeTitresEligiblesRestant"), new PairObjProperty(this,"sommeTitresEligibles")} },
                {"obsTitresSelectionnes", new List<PairObjProperty> {new PairObjProperty(this,"nominal"), new PairObjProperty(this,"recommandedNominal"), new PairObjProperty(this,"sommeTitresEligibles")} },
                {"recommandedNominal", new List<PairObjProperty> {new PairObjProperty(this,"recommandedNominalRestant")}},
                {"nominal", new List<PairObjProperty> {new PairObjProperty(this,"nominalRestant")}}
            };
        }

avec ca j'initialise toutes les dependences simples, puis un ptit algo bidon genere toutes les dependences pour 1 prop.
apres suffit d'appeler OnPropertyChange("laprop") et ca appelle tous les autres.. mais c'est pas super joli...

[tomlev]

bien vu... mais j'ai peur que ça fasse perdre plus de temps de créer l'arbre de dépendences que de gérer ça manuellement

[escafr]

la clarté du code m importe plus que la rapidité de celui ci....
Qd tu dois gerer les dependences sur 10-15 prop dans 10 classes differentes.. ca peut vite devenir le bordel à debuguer..

Puis je crée mon arbre que qd je crée mon obj, après c'est good..

je pourrais meme pousser le vice en créant tout ca statiquement, comme ca c'est fait une bonne fois pour toute au debut du programme..
la reflection me servira à recuperer mes props dynamiquements
donc ca fera un graph par Classe au lieu d'un graph par objet, ce qui n'est pas top top..

la seule utilité de ca étant que je veux pouvoir appelé le onPropertyChange sur des Prop d'une autre classe .
exemple rapide

Code :

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

1
2
3
4
5
6
7
8
9
10
 
class A 
{
   public Type obj {get; set {_obj = value; OnPropertyChange("obj")}}
}
 
class B
{
  public A a {get; set {_a = value; OnPropertyChange("a"); value.OnPropertyChange("obj");
}

Il y a un peu plus de boulot mais ca pourrait etre super efficace...je verrais ca demain..

[tomlev]

la clarté du code m importe plus que la rapidité de celui ci....

En fait je ne parlais pas de la rapidité du code, mais de la rapidité de développement