Generics - Déclencher PropertyChanged dans l'héritière

Version imprimable

Salut,

J'ai poussé mamie dans les orties, et j'ai pris un retour de flemme...

Je veux faire une collection et une collection ordonnée, les deux observables mais abstraites pour pouvoir tout gérer trop facilement à la fin.

J'ai juste un souci pour le ProperyChanged dans la classe héritière, j'ai trouvé ça : https://msdn.microsoft.com/fr-fr/library/hy3sefw3.aspx

Mais c'est à l'ancienne pas avec INotifyPropertyChanged.

Alors... Voici le code (ne m'insultez pas, je découvre).

Pour préserver votre santé mentale, je ne met que le nécessaire

D'abord, l'item de base, T c'est le type du Id de la base de données (Guid ou Int)

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
 
    [Serializable]
    public abstract class _LookupItemBase<T> : ITable<T>, INotifyPropertyChanged
    {
         //Faites moi confiance, j'ai bien déclaré les membres privés
        public event PropertyChangedEventHandler PropertyChanged;
        public T Id
        {
            get
            {
                return _id;
            }
 
            set
            {
                _id = value;
                if (PropertyChanged != null)
                    PropertyChanged(this, new PropertyChangedEventArgs("Id"));
            }
        }
 
        public string Name
        {
            get
            {
                return _name;
            }
 
            set
            {
                _name = value;
                if (PropertyChanged != null)
                    PropertyChanged(this, new PropertyChangedEventArgs("Name"));
            }
        }
        public _LookupItemBase(){} //Constructeur neutre pour que la sérialisation fonctionne
        public _LookupItemBase(T id, string name)
        {
            this._id = _id;
            this._name = name;
        }
    }

Puis, l'item lorsque il y a ordonnancement

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
 
    [Serializable]
    public abstract class _OrderedLookupItemBase<T> : _LookupItemBase<T>
    {
        private int _sortIndex;
 
        public int SortIndex
        {
            get
            {
                return _sortIndex;
            }
 
            set
            {
                _sortIndex = value;
                //Ci dessous ce que je n'arrive pas à faire
                //if (base.PropertyChanged != null)
                //    PropertyChanged(this, new PropertyChangedEventArgs("Description"));
 
            }
        }
 
        public _OrderedLookupItemBase(T id, string name, string description, int sortIndex) : base (id, name, description)
        {
            this._sortIndex = sortIndex;
        }
    }

Après, j'ai la liste et la liste ordonnée :

Code:

1
2
3
4
5
6
 
    [Serializable]
    public abstract class _ObservableLookupBase<T> : ObservableCollection<_ObservableLookupItemBase<T>>
    {
 
    }

Code:

1
2
3
4
5
 
    [Serializable]
    public abstract class _OrderedLookupBase<T> : _LookupItemBase<T> where T : _OrderedLookupItemBase<T>
    {
    }

En commentaire ce que je n'arrive pas à faire.

La cerise sur le gâteau serait que lorsqu'une propriété d'un élément de la liste change ça cascade l'évent jusqu'à la liste...

Je vous promets, je me soigne pour ça, mais qu'est-ce que j'aime ;)

D'avance merci pour votre aide...

J'ai trouvé une implémentation mais je ne sais pas si c# recevable

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
 
    [Serializable]
    public abstract class _OrderedLookupItemBase<T> : _LookupItemBase<T>
    {
        private int _sortIndex;
 
        public new event PropertyChangedEventHandler PropertyChanged;
 
        public int SortIndex
        {
            get
            {
                return _sortIndex;
            }
 
            set
            {
                _sortIndex = value;
                if (PropertyChanged != null)
                    PropertyChanged(this, new PropertyChangedEventArgs("SortIndex"));
 
            }
        }
 
        public _OrderedLookupItemBase() { }
        public _OrderedLookupItemBase(T databaseId, string name, string description, int sortIndex) : base (databaseId, name, description)
        {
            this._sortIndex = sortIndex;
            base.PropertyChanged += _OrderedLookupItemBase_PropertyChanged;
        }
 
        private void _OrderedLookupItemBase_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
        {
            PropertyChanged(this, new PropertyChangedEventArgs(e.PropertyName));
        }
    }

Le new sur l'event permet de masquer le souchi....

Qu'en pensez-vous ? Si un autre développeur voit ça, il appelle le premier hôpital psy ou ça va ?

Merci pour votre aide.

Dans ta classe de base :)
Code:

1 2 3 4 5 6 7 protected void RaiseEvent(string desc) { if (PropertyChanged != null) { PropertyChanged(this, new PropertyChangedEventArgs(desc)); } }
Et ensuite, tu peux appeler dans la classe de base et les héritières la méthode RaiseEvent :)

Déjà, ça va te simplifier un peu la life :)

24/02/2016, 18h22
Nadinette

Ah ouais... C'est ça les mecs sont avantager avec leurs deux cerveaux
Merci pour le coup de pouce ;)

après, il faut que tu sois conscientes que l'ObservableCollection ne remonte que les Add , Remove, Changed

Citation:

Occurs when an item is added, removed, changed, moved, or the entire list is refreshed.

Donc, si tu veux que, lorsqu'un item de ta liste a une propriété qui change tu sois prévenue, tu peux faire un code genre :

C'est fait un peu à l'arrache mais l'idée est que sur un action Add de l'observableCollection, tu t'abonnes au NotifyPropertyChange de ton objet... qui est
normalement de nature INotityPropertyChanged :) )

Evidemment, pour faire propre, il faut gérer le Remove, etc... pour supprimer l'abonnement à la callback quand l'objet est supprimé de la liste :)

Mais je suis sur que tu as compris le principe, même avec 1 seul cerveau.. ( en plus, je suis avantagé, je suis gaucher :) )

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
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
public Form1()
        {
            InitializeComponent();
            myList.CollectionChanged += myList_CollectionChanged;
        }
 
        void myList_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
        {
            Trace.WriteLine("Item has changed");
            if (e.Action == System.Collections.Specialized.NotifyCollectionChangedAction.Add)
            {
                foreach (INotifyPropertyChanged obj in e.NewItems)
                {
                    obj.PropertyChanged += obj_PropertyChanged;
                }
            }
        }
 
        void obj_PropertyChanged(object sender, PropertyChangedEventArgs e)
        {
            Trace.WriteLine("Un object a changé");
        }
 
        private ObservableCollection<CNico> myList = new ObservableCollection<CNico>();
        private CNico myNico = null;
 
        private void button1_Click(object sender, EventArgs e)
        {
            myNico = new CNico(){ Id = 10, Name = "nicolas" };
            myList.Add(myNico);
        }
 
        private void button2_Click(object sender, EventArgs e)
        {
            if (myNico != null)
            {
                myNico.Name = "coucou";
            }
        }
    }
 
    public class CNico : INotifyPropertyChanged
    {
        private int id;
        private string name;
 
        private void RaiseEvent(string text)
        {
            if (PropertyChanged != null)
            {
                PropertyChanged(this, new PropertyChangedEventArgs(text));
            }
        }
 
        public string Name
        {
            get { return name; }
            set
            {
                name = value;
                RaiseEvent("Name");
            }
        }
 
        public int Id
        {
            get { return id; }
            set { id = value; }
        }
 
        public event PropertyChangedEventHandler PropertyChanged;
    }

24/02/2016, 19h09
Nadinette

Merci du conseil !