Conception avec des évenements et des delegates

Version imprimable

Bonjour,
J'ai fais une classe abstraite personne, une sous classe chef de projet, analyste et développeur. Je voudrais utiliser les delegates et les events pour gérer les tâches. Ma classe Personne à ce délégué :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
    public delegate void actionAeffectuer();
 
    abstract class Personne
    {
        public event actionAeffectuer OnActionEffectuee = null;
        public actionAeffectuer listeActionsAeffectuer;
        private String _nom;
        public Personne(String nom)
        {
            _nom = nom;
        }
 
    }

Ma classe chef de projet :

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
    class ChefProjet : Personne
    {
 
        private Projet _projet;
        ChefProjet(String nom)
            : base(nom)
        {
            Projet projet = new Projet(this);
            _projet = projet;
        }
 
        public void creerAnalyste(String nom)
        {
            Analayste analyste = new Analayste(nom);
            _projet.ListePersonnes.Add(analyste);
        }
 
        public void creerProgrammeur(String nom)
        {
            Programmeur programmeur = new Programmeur(nom);
            _projet.ListePersonnes.Add(programmeur);
        }
 
        public void action()
        {
            System.Console.WriteLine("Projet terminé !");
        }
 
        public void ajouterActionAnalyser(Analayste analyste)
        {
            listeActionsAeffectuer += analyste.analyser;
        }
 
        public void ajouterActionConcevoir(Analayste analyste)
        {
            listeActionsAeffectuer += analyste.concevoir;
        }
 
        public void ajouterActionProgrammer(Programmeur programmeur)
        {
            listeActionsAeffectuer += programmeur.programmer;
        }
 
        public void ajouterActionTester(Programmeur programmeur)
        {
            listeActionsAeffectuer += programmeur.tester;
        }
    }

Ma classe projet :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
class Projet
    {
        ChefProjet _chefProjet;
        List<Personne> _listePersonnes;
        public Projet(ChefProjet chefprojet)
        {
            _chefProjet = chefprojet;
        }
 
        public List<Personne> ListePersonnes
        {
            get { return _listePersonnes; }
            set { _listePersonnes = value; }
        }
 
    }

Classe Analyste :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
    class Analayste : Personne
    {
        public Analayste(String nom)
            : base(nom)
        {
 
        }
 
        public void analyser()
        {
            System.Console.WriteLine("J'analyse");
        }
 
        public void concevoir()
        {
            System.Console.WriteLine("Je conçois");
        }
 
    }

Classe Programmeur :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
    class Programmeur : Personne
    {
        public Programmeur(String nom)
            : base(nom)
        {
 
        }
 
        public void programmer()
        {
            System.Console.WriteLine("Je programme");
        }
 
        public void tester()
        {
            System.Console.WriteLine("Je teste");
        }
 
    }

Actuellement, je peux ajouter un succession d'actions à exécuter. Cependant, grâce aux events, j'aimerais que le chef de projet soit prévenu lorsqu'un développeur ou analyste termine sa tâche. Il faut que le chef de projet s'abonne aux analystes et programmeurs ? Dès que les tâches sont terminées, j'aimerais que le chef de projet lance sa méthode action(). Et comment attendre que toutes les tâches des analystes soient terminées avant que les développeurs commencent ?
Merci.

28/03/2017, 10h29
popo

Bonjour,

Ce que tu cherche à faire ressemble beaucoup au pattern Observer.
Je ne doute pas qu'avec cette information, tu n'auras aucun mal à trouver ton bonheur sur Google.

La gestion des événements en C# est une implémentation du pattern Observable/Observer. Sur ce thread j'ai proposé un exemple de mise en œuvre des événements. Je te reposte le code :

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
  public class SelectionChangedEventArgs : EventArgs
    {
        public object OldItem { get; set; }
        public object NewItem { get; set; }
    }
 
    public delegate void SelectionChangedEventHandler(object sender, SelectionChangedEventArgs eventArgs);
 
    public interface INotifySelectionChanged
    {
        event SelectionChangedEventHandler SelectionChanged;
    }
 
    public class SelectionContainer : INotifySelectionChanged
    {
        private readonly List<object> _items = new List<object>();
        public object[] Items { get { return _items.ToArray(); } }
        public object Current { get; private set; }
 
        public void Add(object item) { if (!_items.Contains(item)) _items.Add(item); }
        public void Remove(object item)
        {
            if (_items.Contains(item))
            {
                _items.Remove(item);
                if (item == Current)
                {
                    Current = null;
                    OnSelectionChanged(item, null);
                }
            }
        }
        public bool Contains(object item)
        {
            return _items.Contains(item);
        }
 
        public void Select(object item)
        {
            if (!_items.Contains(item)) throw new InvalidOperationException("Item is not in container");
            var old = Current;
            Current = item;
            OnSelectionChanged(old, Current);
        }
 
        public event SelectionChangedEventHandler SelectionChanged;
 
        protected void OnSelectionChanged(object oldItem, object newItem)
        {
            var handler = SelectionChanged;
            if (handler != null) handler(this, new SelectionChangedEventArgs { OldItem = oldItem, NewItem = newItem });
        }
    }

En l'occurrence ce sont les classes Analyste et Developpeur qui devront proposer des événements pour les tâches, par exemple à l'acquisition, au démarrage et à la conclusion :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
public class WorkLoad { public string ToDo { get; set;} }
 
public class WorkLoadEventArgs : EventArgs { public WorkLoad WorkLoad { get; set; } }
 
public delegate void WorkLoadEventHandler(object sender, WorkLoadEventArgs args);
 
interface IWorker
{
  event WorkLoadEventHandler AcquireWorkLoad;
  event WorkLoadEventHandler BeginWorkLoad;
  event WorkLoadEventHandler CompleteWorkLoad;
}

Lorsque tu ajoutes un analyste ou développeur à la liste du chef de projet tu t'abonnes à ces événements avec un ou plusieurs méthodes du chef de projet ; sans oublier de te désabonner si tu retire un membre de la liste (afin d'éviter les fuites mémoire).