Quel pattern utiliser ?

Version imprimable

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:

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:

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

Salut,

je verrais deux solutions.

La première, tu peux utiliser les méthodes d'extension et une interface :

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
 
public interface IChannelContainer
{
    Channel Channel
    {
        get;
        set;
    }
}
 
//dans une classe statique à part, genre 'ChannelContainerExtensions.cs'
 
...
 
public static void SetChannel(this IChanelleContainer container, Channel channel)
{
    Unregister(container);
    Register(container, channel);
}
 
private static void Unregister(IChannelContainer container)
    {
        if (container.Channel = null) return;
        container.Channel.updated -= new EventHandler(container.channel_updated);
        container.Channel.reseted -= new EventHandler(container.channel_reseted);
 
        FonctionUnregDiverses();
 
        container.Channel = null;
    }
 
    private static void Register(IChannelContainer container, Channel c)
    {
        channel.updated += new EventHandler(container.channel_updated);
        channel.reseted += new EventHandler(container.channel_reseted);
 
       FonctionRegDiverses();
 
       container.Channel = c;
    }
...

Le souci n°1 de cette solution, c'est que rien n'empêche un autre code de valoriser la propriété Channel d'un élément sans passer par les méthodes d'extension (sans passer par 'monChannelContainer.SetChannel(c)').

Du coup, je préfèrerais la solution suivante (tout dépend de ton code, de ce que tu peux modifier ou pas etc.) : utiliser la composition. Tu créés une classe ChannelContainer qui se charge d'implémenter les méthods Register() etc., et tes éléments auront un attribut ChannelContainer au lieu de Channel :

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
 
public sealed class ChannelContainer
{
    private Channel _channel;
 
    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;
    }    
}
 
//Exemple : à remplacer dans les classes qui utilisaient une propriété Channel
public class Buffer
{
    private readonly ChannelContainer _channelContainer = new ChannelContainer();
 
    public ChannelContainer ChannelContainer
    {
        get { return this._channelContainer; }
    }
}

Si jamais les corps des méthodes 'channel_updated' etc. dépendent des objets et sont différentes selon les cas (Buffer, UserControls etc), tu passes une référence à l'objet parent dans le constructeur de ChannelContainer :

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
 
public sealed class ChannelContainer
{
   ...
 
   private IChannelUser _parent;
 
   public ChannelContainer(IChannelUser parent)
   {
        this._parent = parent;
    }
 
    void Register(Channel c)
    {
        _channel.updated += new EventHandler(this._parent.channel_updated);
        _channel.reseted += new EventHandler(this._parent.channel_reseted);
   ...
}
 
public interface IChannelUser
{
    ChannelContainer ChannelContainer
    {
        get;
    }
 
    void channel_updated(object sender, EventArgs e);
    void channel_reseted(object sender, EventArgs e);
}
 
public class Buffer : IChannelUser
{
    private readonly ChannelContainer _container;
 
   public Buffer()
   {
        this._container = new ChannelContainer(this);
   }
}

19/05/2010, 11h11
mika91

Merci pour ta réponse.
Cependant, je ne suis pas sûr que ça résolve mon problème!
Ta solution n°2, de la composition est élégante, mais je dois créer une classe ChannelContainer pour chaque classe utilisant un channel, puisque les EventHandler seront différents !

Ok, tu as mis à jour ton post et tu réponds à ma question!
Parfait tout ça :ccool:
J'y étais presque celà dit, il aurait suffi que je pense à utiliser un continaer.
merci
19/05/2010, 11h41
tomlev

Tu pourrais simplement faire hériter toutes tes forms d'une classe de base ChannelForm qui déclarerait la propriété Channel