Reflection sur propriété

Version imprimable

Bonjour,

Imaginons une classe
Code:

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

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:

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;
        }
    }

18/03/2010, 14h36
escafr

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

Citation:

Envoyé par escafr

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:

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; } }

:( 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:

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...

18/03/2010, 17h04
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 :aie:

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:

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..

18/03/2010, 17h42
tomlev

Citation:

Envoyé par escafr

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 ;)
18/03/2010, 17h57
escafr

je pense pas, pq si tu rajoutes un prop qui influe sur des props, il faut que tu listes toutes les props qui influe, puis aille regarder toutes les props sur lesquels les props influencées influent, puis toutes les props des props de la prop ca fiat bcp de prop et tu es perdu maintenant :p

enfin pas gerable a grande echelle.

la tu as un tableau par classe a tenir a jour, et si tu ajoutes une prop, tu ajoutes une ligne au tableau et apres ca gere toutes les ss dependences tout seul.. c'est gagné!:ccool:
19/03/2010, 09h10
User.Anonymous

Pas mal ta solution, mais tu pourrais carrément passer par un fichier de mapping en XML ?
Comme ca tu aurais toutes tes liaisons dans un fichier qu'il suffirait de parser à la création des classes.