Interface, héritage, polymorphisme

**Pfeffer** · 20/09/2017, 09h36

Bonjour à tous,

J'ai un problème de conception et j'aimerai être sûr de faire juste...
J'ai un objet "Task" avec deux méthodes "run" et "stop".
J'ai un ojet dérivé de "Task" qui est "TaskTest".
J'ai une interface "ITask" avec la méthode "run"

Ce que je veux:
- Rendre obligatoire la présence de la méthode "run" dans les classes dérivées, d'ou ITask
- La méthode run et stop dans la classe base exécute un code commun à toutes les classes dérivées
- utiliser le polymorphisme pour executer la méthode run de chaque classe dérivée

Mais impossible de rendre obligatoire l'écriture de la méthode "run" dans les classes dérivées.

Comment dois-je m'y prendre ? Voici le code que je tente de mettre en place ...

Voici le code:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
/// <summary>
    /// Interface de gestion des tâches
    /// </summary>
    public interface IGTMTask
    {
        /// <summary>
        /// Méthode permettant d'exécuter la tâche
        /// </summary>
        void run();
    }

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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
 
/// <summary>
    /// Objet représentant une tâche 
    /// </summary>
    public class Task 
    {        
        /// <summary>
        /// Date de début d'extraction
        /// </summary>
        private DateTime dtStart;
 
        /// <summary>
        /// Date de fin d'extraction
        /// </summary>
        private DateTime dtEnd;
 
        /// <summary>
        /// Indicateur de temps permettant de connaitre le teps d'exécution d'une tâche
        /// </summary>
        private Stopwatch sw;        
 
        #endregion
 
        #region Constructeurs
 
        /// <summary>
        /// Constructeur par défaut
        /// </summary>        
        public GTMTask()
        {
            this.sw = new Stopwatch();            
        }
 
        #endregion
 
        #region méthodes publiques
 
        /// <summary>
        /// Démarrage du chrono 
        /// </summary>
        public virtual void run()
        {
            try
            {
                sw.Start();
            }
            catch (Exception) { }
        }
 
        /// <summary>
        /// Arrêt du chrono
        /// </summary>
        public void stop()
        {
            try
            {
                sw.Stop();
            }
            catch (Exception) { }
        }
 
        #endregion
    }

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
 
 
 /// <summary>
    /// Tâche permettant de tester 
    /// </summary>
    public class TaskDerived : Task, ITask
    {
        #region Méthodes publiques
 
        /// <summary>
        /// Méthode principale
        /// </summary>
        public override void run()
        {
            try
            {
                base.run(); // -- Appel de la méthode de base
 
                for (int iSec = 5; iSec <= 100; iSec++)                                    
                    System.Threading.Thread.Sleep(1000);                
            }
            catch (Exception ex)
            {                
            }
            finally
            {                        
            }
        }
 
        #endregion
    }

**Pol63** · 20/09/2017, 09h48

si tu veux du code de base dans run, et rendre obligatoire la dérivation de cette méthode en gardant le code de base :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
public abstract class TaskBase
{
 
    public abstract void Run();
 
    public void RunBase() // cette méthode est de l'interface
    {
        // code
        this.Run();
    }
 
}

en séparant en deux méthodes, ca permet d'éviter de forcer le développeur d'écrire l'appel à base.Run, qu'il pourrait oublier

au passage réfléchis si l'interface est bien utile ... la classe de base peut peut-être suffire ...