Bonjour,
Dans l'attente du livre de pattern que j'ai commandé, j'aimerais avoir votre avis sur ce cas tout simple.

J'ai une classe Channel qui fait différentes choses et lève différents événements (updated, reseted, inverted...)
Ensuite, j'ai plusieurs classes, dérivant de Form, de UserControl, de diverses autres classes non graphiques (Measure, Buffer, Scan...) qui ont tous pour propriété un Channel.
Donc pour toutes ces classes, je me retrouve avec un bout de code identique ressemblant à ça:
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
 
class ChannelForm : Form
{
    Channel _channel = null;
    public Channel Channel
    {
        get {return _channel;}
        set {
             Unregister();
             Register(value);
       }
    }
 
    void Unregister()
    {
        if (_channel = null) return;
        _channel.updated -= new EventHandler(channel_updated);
        _channel.reseted -= new EventHandler(channel_reseted);
 
        FonctionUnregDiverses();
 
        _channel = null;
    }
 
    void Register(Channel c)
    {
        _channel.updated += new EventHandler(channel_updated);
        _channel.reseted += new EventHandler(channel_reseted);
 
       FonctionRegDiverses();
 
       _channel = c;
    }
 
 
    *****************************
    Reste de la classe, utilisant _channel
    *****************************
    ...
}
Comment faire pour enlever cette petite redondance de code ?
Utiliser une classe statique, qui gère l'enregistrement du channel et de ces événements ?
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
 
public static class ChannelManager
{
    public static void Register(Channel c, IChannelConsummer consummer)
    {
        Unregister(consummer);
 
        c.updated+=consummer.ChannelUpdated();
        c.reseted+=consummer.ChannelReseted();
        consummer.ChanneldAdded();
 
        ToChannels.Add(consummer, c);
    }
 
    public static void Unregister(IChannelConsummer consummer)
    {
        Channel ch = GetChannel(consummer);
        if ( ch == null) return;
 
        ch.updated-=consummer.ChannelUpdated();
        ch.reseted-=consummer.ChannelReseted();
        consummer.ChanneldRemoved();
 
        ToChannels.Remove(consummer);
     }
 
     static Dictionnary<IConsummer,Channel> ToChannels = new Dictionnary<IConsummer,Channel>();
     Channel GetChannel(IConsummer c)
     {
        Channel tmp;
        ToChannels.tryGetValue(c, ref tmp);
         return tmp;
     }
}
 
interface IChannelConsummer()
{
 
      ChannelAdded();
      ChannelRemoved();
 
      ChannelUpdated();
      ChannelReseted();
 
}
Qu'en pensez-vous ?
Est-ce un pattern connu ? Quel est son nom ?
Merci