Discussion :

[escafr]

Bonjour,

Soit 2 classes

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
 
abstract class Parent
{
 public Parent()
{
}
 
protected abstract void init();
}
 
class Enfant : Parent
{
 public Enfant()
{
}
 
protected override void init()
 {
// des choses...
}
}

je voudrais que init() soit appelé directement après que le constructeur de Enfant soit éxécuté mais l'appel doit se faire à partir de la classe Parent.

Une idée?

[cybermaxs]

après que le constructeur de Enfant soit éxécuté mais l'appel doit se faire à partir de la classe Parent.

Donc tu veux que ta classe Parente mettre du code dépendant des classes dérivées ? pas terrible d'un point de vue concept objet.

je voudrais que init() soit appelé directement après que le constructeur

pas possible non plus. On ne peut pas en c# forcer une ordre d'appel dans les méthodes.

[escafr]

roo mais c'est le bon vieux pattern des familles "je sais plus cmt il s'appelle" appliqué au constructeur

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
 
class Parent 
{
 protected virtual void beforeEvent() {}
 protected virtual void afterEvent() {}
 protected virtual void doEvent() {}
 
 private void event() 
{
// du code du parent
beforeEvent();
// du code du parent
doEvent();
// du code du parent
afterEvent();
// du code du parent
}
 
}
 
class Enfant 
{
 protected override void beforeEvent() {//Du code}
 protected override void afterEvent() {//Du code}
 protected override void doEvent() {//Du code}
}

c'est vachement utilisé pour tout ce qui est UI.. mais forcement c'est pas applicable au constructeur..
c'etait juste au cas ou...

mon pb c'est qu'il faut que j'attende que le constructeur de Enfant soit terminé pour lancer init()...

[tomlev]

roo mais c'est le bon vieux pattern des familles "je sais plus cmt il s'appelle" appliqué au constructeur

Tu parles du pattern Template Method il me semble

Mais pour les constructeurs, c'est un peu différent : le constructeur de la classe dérivée n'est pas un override du constructeur de la classe de base. Celui de la classe de base est obligatoirement exécuté avant celui de la classe dérivée, donc quand le constructeur de la classe dérivée commence à être exécuté, celui de la classe de base est déjà terminé...

Une solution serait d'avoir plusieurs méthodes Init, par exemple BeforeInit, Init et AfterInit. Si tu as besoin d'exécuter des choses avant l'appel à Init dans ta classe dérivée, tu le fais en overridant BeforeInit :

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
abstract class Parent
{
    public Parent()
    {
        BeforeInit();
        // ...
        Init();
        // ...
        AfterInit();
    }
 
    protected virtual void BeforeInit() { };
    protected abstract void Init();
    protected virtual void AfterInit() { };
}
 
class Enfant : Parent
{
    public Enfant() // appelle implicitement le constructeur de Parent
    {
    }
 
    protected override void BeforeInit()
    {
        // des choses...
    }
 
    protected override void Init()
    {
        // des choses...
    }
}

Question intéressante en tous cas

[escafr]

je peux pas faire ca non plus.

il me fait vraiment attendre la fin du constructeur d'Enfant.
pq en fait mes classes sont plutot comme ca:

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
 
abstract class Parent
{
 public Parent()
{
}
 
protected abstract void init();
}
 
class Enfant : Parent
{
 public Enfant(unType unObj): base()
{
_unObj = unObj;
}
 
private unType _unObj;
 
protected override void init()
 {
   faisQqueChoseAvc(_unObj);
 }
}

donc l'objet unObj ne sera initialisé que lorsque le constructeur de Enfant sera terminé...
et je crois pas qu'on puisse initialisé comme en C++

Code :

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

1
2
3
4
 
public Enfant(unType unObj): _unObj(unObj), base()
{
}

ce qui resoudrait mon pb...

[cybermaxs]

Pourquoi ne pas utiliser une Factory Method dans ce cas pour avoir un code du genre

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
    class Enfant : Parent
    {
        public static Enfant CreateNew(object unObj) 
        {
            Enfant newItem = new Enfant(unObj);
            newItem.AfterInit();
            return newItem;
        }
 
        private object _unObj;
        protected Enfant(object unObj) 
        {
            this._unObj=unObj;
        }
 
 
        protected void AfterInit()
        {
            // des choses...
        }
    }

[tomlev]

Ah ok, je comprends mieux le problème... ben je vois pas trop comment tu pourrais éviter d'appeler init() explicitement alors