Discussion :

[CUCARACHA]

Salut,

Je suis en train de parfaire mes connaissances en matière d'objet. En effet, venant du monde VB où les objets ne sont utilisés que pour simplifer certains tratement, je n'ai que de quelques notions de conception. Je me suis donc donné un cas pratique : la construction d'un gestionnaire de projets.


Il permet d'afficher un projet de deux façons :

• Calendrier
• Diagramme de Pert.

Le calendrier peut afficher soit

• Un jour
• Une semaine
• Un Mois
• Une Année

Au final j'aimerais avoir un composant Projet qui disposerait des deux interfaces Calendrier et Pert. Tous deux seront capables d'afficher des Taches

Pert dispose d'une seule interface

Le calendrier dispose de 4 interfaces correspondantes à chacune des périodes pouvant être affichées.

J'aimerais savoir comment je dois créer cette petite structure objet.

Dois-je utiliser une Interface pour chaque affichage et les appeler

buildYear
buidMonth
buildWeek
buildDay

?

D'avance merci

Laurent

[Invité]

je pense que j'utiliserai une classe calendrier, dont je dérivaie jour, mois , année, pareil pour le diagramme de pert.

Je créerai une interface que j'utiliserai pour l'implémentation de Calendrier et Pert. Et j' l'utiliserai pour faire la déclaration dans projet et ensuite tu créer ton instanciation avec le bon objet.

[CUCARACHA]

Salut,

Merci pour ta réponse matinale

En fait, je compte même créer un WebCustomControl qui dispose des 2 types d'affichages Calendrier et Pert qui sont eux même des composants.

Le composant Projet a une propriété displayType qui est un enum Calendar/Pert

Pert n'a qu'un mode d'affichage mais Calendar en a un par type de période (Année, Mois, Semaine, jour).

Ce que je ne sais pas faire c'est appeler la bonne methode de construction en fonction du type d'affichage:

Créer une classe builder et des interfaces IBuildYear,IBuildMonth,IBuildWeek et IBuildDay

J'aimerais pouvoir faire :

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
 
MyProject.Calendar.BuildYear()
//ou
MyProject.Pert.Build()
 
//Je simplifie :
class Project {
    public Calendar CalendarMode = new Calendar();
    public Pert PertMode = new Pert();
}
 
interface IBuildYear {
    void build() {}
}
 
interface IBuildMonth {
    void build() {}
}
 
interface IBuildWeek {
    void build() {}
}
 
interface IBuildDay {
    void build() {}
}
 
class IBuilder:IBuildYear,IBuildMonth,IBuildWeek,IBuildDay {
    public IBuilder(enDisplayPeriods DisplayPeriod){
 
    }
}

Je ne connais pas la syntaxe mais j'aimerais arriver à un résultat a peu près comme ça, c'est à dire que j'implémente la bonne interface en fonction du mode d'affichage demandé ?

Pourrais-tu déjà me dire si la logique te parait juste ?

D'avance merci

Laurent

[dev01]

Code :

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

1
2
3
4
5
6
 
//Je simplifie :
class Project {
    public Calendar CalendarMode = new Calendar();
    public Pert PertMode = new Pert();
}

si tu fait ça c'est que tu n'a pas compris la POO ...

on ne met pas de variable publique ou à de très rare exception près.

sinon pour faire ce que tu veux faire il faut passer par une interface commune à tes types d'affichage.

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
 
public interface IDisplay
{
   void Show();
}
 
public class Calendar : IDisplay
{  
    public void Show()
    {
         //code d'affichage
    }
}
 
public class Pert : IDisplay
{
   public void Show()
   {
      //code affichage
    }
}
 
class Project {
    private IDisplay displayMode;
 
    public void SetDisplayCalendar()
    {
        displayMode = new Calendar();
     }
 
    public void SetDisplayPret()
    {
       displayMode = new Pret();
    }
 
    public void DisplayAll()
    {
        this.displayMode.Show();
     }
}

avec ça tu peux facile passer de l'un à l'autre .

[CUCARACHA]

Merci pour ta réponse.

Je vais essayer de monter ça et de le compiler.

Je te dirais si ça fonctionne...

Bien à toi

Laurent

[CUCARACHA]

Salut,

Bon j'ai implémenté ma structure. Je ne peux pas encore tester mais ça compile, c'est déjà ça.

Question :

Je ne veux pas que mes interfaces soient accessible depuis l'extérieur du composant. Ne devrais-je pas les déclarer en tant que protected plutôt que public ?

Bien à toi

Laurent

[dev01]

Je ne veux pas que mes interfaces soient accessible depuis l'extérieur du composant. Ne devrais-je pas les déclarer en tant que protected plutôt que public ?

Non Protected ne te donnerais rien ... il faut les mettre en internal

[CUCARACHA]

Merci beaucoup pour ton aide, j'apprécie...

@+

Laurent

[CUCARACHA]

Salut,

Bon j'ai réfléchi à la structure définitive que je veux obtenir mais je n'arrive pas à l'implémenter.

j'aimerais avoir ceci :

ezProject est un composant qui a deux modes d'affichage :
Pert
Calendrier

ezPert est un composant qui n'a qu'un mode d'affichage

ezCalendrier est un composant qui a 4 modes d'affichage qui sont :
Année
Mois
Semaine
Jour

au niveau de la syntaxe externe j'aimerais avoir ceci

si je veux que ezProject construise un calendrier je voudrais pouvoir faire ceci :

MyProject.Build.Calendar.Year();
ou
MyProject.Build.Calendar.Month();
...

Pour avoir la même hiérarchie et pour me permettre d'autres modes d'affichage en pert, j'aimerais avoir:

MyProject.Build.Pert.Pert();

Sans vouloir abuser, si tu pouvais me fournir un exemple d'implémentation avec des interfaces de cette structure, je crois que ça me débloquerait et que ça m'aiderait à comprendre.

Cela m'amène une question :

Les trois composants peuvent être utilisés séparément, en effet, il est possible de n'avoir besoin que d'un calendrier mais pas d'un projet.

Si je crée une interface IBuild, est-il convenable que les 3 composants en héritent ou vaut-il mieux définir une interface pour chaque composant ?

D'avance merci pour tes réponses....

Laurent