MDI, synchroniser des formulaires enfants et pattern Observer

Bonjour,
J'ai une application MDI avec, par exemple, des formulaires enfants dont l'un permet de rentrer un client et un autre affiche la liste des clients. Je voudrais que la liste des clients soit mise à jour chaque fois qu'un nouveau client est crée, supprimé ou modifié. J'ai pensé aux évènements et au pattern Observer, mais je voudrais pouvoir ouvrir autant de formulaires de liste et de formulaire de création/modification qu'il me plaira.
Comme solution, j'ai crée des évènements ClientUpdated, ClientDeleted et ClientCearted dans le formulaire de création/modification, ainsi qu'une classe héritant d'EventArgs avec le client concerné en propriété. Puis, j'ai déclaré un gestionnaire d'évènements dans le formulaire MDI pour l'abonner aux évènements du formulaire de création/modification. Ensuite sur ouverture de mon formulaire de liste, je l'abonne aux évènements du formulaire MDI, car dans les gestionnaires d'évènements ce dernier redéclenche l'évènement qu'il a reçu.
C'est ce que j'envisageais, mais ça me semble lourd, car il faut que je déclare les évènements deux fois, une fois dans le formulaire de création/modification et une fois dans le formulaire MDI. Et comme les clients ne sont qu'un exemple, s'il y a en plus des produits, des factures, etc., ça va rapidement faire beaucoup de déclarations en double. A moins qu'il existe un moyen de propager l'évènement directement sans le redéclarer.
Je ne sais pas quelle est la meilleur approche, car je pense à d'autres solutions mais elles ont toutes des inconvénients. Donc s'il existe une pratique éprouvée dans ce domaine, je suis preneur.
Merci pour vos lumières...

Bonjour,
Tu peux creuser dans cette piste!
En mode déconnecté, si plusieurs contrôles sont liés au même DataTable, ils se trouve tous à jour quand tu insert, modifis ou supprime des données...

1 pièce(s) jointe(s)

Merci pour l'encouragement et la précision concernant les DataTables.
Vu que les réponses ne pleuvent pas, je vais détailler pour la soumettre à la critique une des solutions que j'ai envisagées. Elle ne me semble pas particulièrement élégante, mais pour l'instant je n'ai pas trouvé mieux.
Donc, au lieu de créer les évènements spécifiques ClientUpdated, ClientDeleted et ClientCearted dans le formulaire de création/modification, j'ai ajouté une énumération Create, Update, Delete à la classe héritant d'EventArgs. Ainsi, il ne me reste plus qu'un évènement ClientCUD dans le formulaire de création/modification. La contrepartie est que les abonnés doivent faire le tri pour savoir s'ils sont concernés par l'évènement, en testant le type d'objet en paramètre par exemple (Client, Produit, ...). Ci-joint, le code commenté de cette "solution", ainsi qu'un Zip du tout.
Toutes les suggestions sont les bienvenues...

Code du fichier MDI.cs (le formulaire MDI) :

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
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
 
namespace ObserverMDI
{
    public partial class MDI : Form
    {
        public event CUDEventHandler CUDEventRaised;
 
        protected virtual void OnCUDEventRaised(object sender, CUDEventArgs e)
        {
            CUDEventHandler handler = CUDEventRaised;
            if (handler != null)
            {
                //ToDo: Ajouter une gestion des erreurs au cas où le délégué foire.            
                handler(sender, e);
            }
        }
 
        public void EventRepeater(object sender, CUDEventArgs e)
        {
            //Répète l'évènement pour les formulaires enfants abonnés :
            OnCUDEventRaised(sender, e);
        }
 
        public MDI()
        {
            InitializeComponent();
            this.IsMdiContainer = true;
        }
 
        private void MDI_Load(object sender, EventArgs e)
        {
            //Affichage de quelques formulaires enfants :
            for (int i = 0; i < 3; i++)
            {
                Form1 f1 = new Form1();
                f1.MdiParent = this;
                f1.Show();
                Form2 f2 = new Form2();
                f2.MdiParent = this;
                f2.Show();
            }
 
        }
    }
}

Code du fichier Form1.cs (le formulaire de création/modification), il comporte un bouton et une textbox :

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
 
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
 
namespace ObserverMDI
{
    public partial class Form1 : Form
    {
        public event CUDEventHandler ClientCUD;
 
        protected virtual void OnClientCUD(CUDEventArgs e)
        {
            CUDEventHandler handler = ClientCUD;
            if (handler != null)
            {
                //ToDo: Ajouter une gestion des erreurs au cas où le délégué foire.            
                handler(this, e);
            }
        } 
 
        public Form1()
        {
            InitializeComponent();
        }
 
        private void button1_Click(object sender, EventArgs e)
        {
            CUDEventArgs ea = new CUDEventArgs(CUDEventArgs.CUDEventTypes.Create, textBox1.Text, null);
            OnClientCUD(ea);            
        }
 
        private void Form1_Load(object sender, EventArgs e)
        {
            //Abonnement du formulaire MDI à l'évènement :
            this.ClientCUD += new CUDEventHandler(((MDI)this.MdiParent).EventRepeater);
        }
    }
}

Code du fichier Form2.cs (le formulaire de liste), il comporte une textbox :

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
 
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
 
namespace ObserverMDI
{
    public partial class Form2 : Form
    {
        public Form2()
        {
            InitializeComponent();
        }
 
        private void Form2_Load(object sender, EventArgs e)
        {
            //Abonnement au répéteur d'évènements :
            ((MDI)this.MdiParent).CUDEventRaised += new CUDEventHandler(this.cudEventHandler);
        }
 
        private void Form2_FormClosed(object sender, FormClosedEventArgs e)
        {
            //Annulation de l'abonnement :
            ((MDI)this.MdiParent).CUDEventRaised -= new CUDEventHandler(this.cudEventHandler);
        }
 
        private void cudEventHandler(object sender, CUDEventArgs e)
        {
            //Il s'agit juste d'un test, mais il serait possible de tester le type d'objet de CUDEventArgs
            //ainsi que le type d'opération, pour savoir si le formulaire est concerné par l'évènement.
            textBox1.Text = (string)e.NewObject;
        }
    }
}

Code du fichier CUDEventArgs.cs (la classe qui hérite de EventArgs) :

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
 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace ObserverMDI
{   
    public delegate void CUDEventHandler(object sender, CUDEventArgs e);
 
    public class CUDEventArgs : EventArgs
    {
        private readonly CUDEventTypes cudEventType;
        //Objet crée ou modifié (une classe Client par exemple) :
        private readonly object newObject;
        //Objet avant modification ou suppression (une classe Client par exemple) :
        private readonly object oldObject;
 
        //Permetra de connaitre le type d'opération :
        public enum CUDEventTypes { Create, Update, Delete };
 
        public CUDEventArgs(CUDEventTypes cudEventType, object newObject, object oldObject)
        {
            this.cudEventType = cudEventType;
            this.newObject = newObject;
            this.oldObject = oldObject;
        }
 
        public CUDEventArgs(CUDEventArgs e)
        {
            this.cudEventType = e.cudEventType;
            this.newObject = e.newObject;
            this.oldObject = e.oldObject;
        }
 
        public CUDEventTypes CUDEventType
        {
            get { return cudEventType; }
        }
 
        public object NewObject
        {
            get { return newObject; }
        }
 
        public object OldObject
        {
            get { return oldObject; }
        }
    }    
}