Discussion :

[Arthis]

Bonjour à tous,

J ai un petit souci de théorie objet dont je n arrive pas à me dépétrer: UN petit exemple vaut mieux qu un long discours :

Code :

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

1
2
3
4
5
 public abstract class Entreprise
    {
        public abstract Produit GetGammeProduit();
 
    }

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Produit
    {
        public List<Produit> ListSousProduit;
        public void Marketing()
        {
        }
        public void Vente()
        {
        }
        public void SuiviQualite()
        {
        }
    }

Code :

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

1
2
3
4
5
6
7
8
 public class Boulangerie : Entreprise
    {
        public override Produit GetGammeProduit()
        {
            return new Produit();
        }
 
   }

Code :

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

1
2
3
4
5
6
    public class Viennoiserie : Produit
    {
        public new List<Viennoiserie> ListSousProduit;
        bool chocolat;
        bool beurre;
    }

J ai une classe boulangerie qui herite d une classe entreprise, et une boulangerie a des viennoiseries qui héritent de la classe produit.

Ce que j aimerais c est que ma classe boulangerie ait la méthode GetGammeProduit qui lui renvoie une viennoiserie et non pas un produit et ce sans avoir de référence à produit dans ma bouangeie , je ne voudrais y voir que des viennoiseries.

Est ce possible?

Merci d'avance de votre aide,

[tomlev]

C'est possible en masquant la méthode de la classe de base (avec new)

Code :

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

1
2
3
4
5
6
7
8
 public class Boulangerie : Entreprise
    {
        new public Viennoiserie GetGammeProduit()
        {
            return new Viennoiserie();
        }
 
   }

Mais dans ce cas, la nouvelle méthode ne sera appelée qu'à partir d'une référence de type Boulangerie...

Code :

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

1
2
3
4
Boulangerie b = new Boulangerie();
Viennoiserie v = b.GetGammeProduit(); // appelle Boulangerie.GetGammeProduit
Entreprise e = b;
Produit p = e.GetGammeProduit(); // appelle Entreprise.GetGammeProduit

Je te conseille plutôt d'utiliser une interface, qui te permet d'exploiter l'implémentation explicite :

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
public interface IEntreprise
{
    Produit GetGammeProduit();
}
 
public class Boulangerie : IEntreprise
    {
        // implémentation locale
        public Viennoiserie GetGammeProduit()
        {
            return new Viennoiserie();
        }
 
        // implémentation explicite de IEntreprise
        public Produit IEntreprise.GetGammeProduit()
        {
            return this.GetGammeProduit();
        }
 
   }

C'est le même principe que pour les classes qui héritent de DbConnection par exemple : DbConnection.CreateCommand renvoie un DbCommand, mais SqlConnection.CreateCommand renvoie un SqlCommand (et fournit une implémentation explicite de IDbConnection qui renvoie un IDbCommand, de façon à respecter l'interface).
Si tu veux plus de détails, j'ai déjà détaillé ce sujet dans un autre post :
http://www.developpez.net/forums/d61...e/#post3642951

[Arthis]

Merci pour l'explication. J'avance peu à peu dans ma compréhension du "grand Tout".

Maintenant, si je déplace un petit peu ce probleme et que je regarde objet SiteMapProvider et SiteMapnode.

Ils sont à peu pres similaires à mes objets Entreprise et produits. La seule différence est que je travaille dans ce cas là avec un framework imposé où je ne peux aps faire tout ce que je veux.

Ce que je voudrais en faire c est les modifier un peu pour avoir ce que j appellerai un navigationItem qui deriverait de sitemapNode et permettre a une navigationList qui deriverait de SiteMapProvider d avoir non pas des références a des sitemapnode mais à des navigationItem.

Or je bute sur une anguille là et je me perds !

Je n arrive pas à réutiliser au maximum ce qui a éte fait par microsoft pour lui rajouter juste les quelques propietes et méthodes qui m'interesseraient, et j ai l impression d'avoir à réecrire tout le code. Et c est un exemple avec ce sitemapprovider et ces sitemapnode, cela m est arrivé souvent de vouloir faire des choses de ce genre et de rebrousser chemin car je n'arrivais pas à trouver le moyen d'avancer convenablement.

Alors avant tout est ce la bonne méthode? Peut on jouer ainsi avec les objets de microsoft ou vaut il mieux faire des choses maison afin d'avoir le plus de latitudes possibles? Vu ma persévérance, j ai une petite idée sur la question, mais je voudrais entendre quelqu'un me le dire.. ( ou me dire non! argh..)

[davcha]

Sinon, tu peux utiliser les generics.

Genre :

class Entreprise<Viennoiserie> {....

[tomlev]

Ce que je voudrais en faire c est les modifier un peu pour avoir ce que j appellerai un navigationItem qui deriverait de sitemapNode et permettre a une navigationList qui deriverait de SiteMapProvider d avoir non pas des références a des sitemapnode mais à des navigationItem.

Même si les signatures des méthodes de SiteMapProvider que tu overrides indiquent qu'elles renvoient un SiteMapNode, tu peux très bien renvoyer un NavigationItem (à condition que NavigationItem dérive de SiteMapNode). Ensuite, quand tu utilises cette méthode, il suffit de faire un cast pour obtenir un NavigationItem...

[Arthis]

Oui mais je suis confronté à un hic. Je ne peux pas caster dans ce sens :

Code :

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

1
2
3
4
5
6
7
public new NavigationItem RootNode
        {
            get
            {
                return (NavigationItem)base.RootNode ;
            }
        }

RootNode est un sitemap node, navigationItem derive de sitemapnode, mais le cast n'est aps valide. On peu faire ca :

Code :

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

SiteMapNode node = (SiteMapNode)MonNavigationItem;

mais l inverse est impossible :

Code :

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

NavigationItem  MonNavigationItem= (NavigationItem  )MonSiteMapNode;

J ai l'impression d 'être obligé de devoir faire ca pour arriver a mes fins (ce que je n'aime pas):

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 public new NavigationItem RootNode
        {
            get
            {
                NavigationItem MonNavigationItem = new NavigationItem();
                MonNavigationItem.Description = base.RootNode.Description;
                MonNavigationItem.Key = base.RootNode.key;
                MonNavigationItem.Title = base.RootNode.Title;
                etc.....
                return MonNavigationItem;
            }
        }

Ai je mal compris ta logique quelque part?

[tomlev]

Pour que le cast fonctionne, il faut que RootNode soit effectivement une instance de NavigationItem... base.RootNode renvoie un SiteMapNode, pas un NavigationItem.

De toutes façons, je ne pense pas que ce soit une bonne idée de masquer la propriété RootNode pour redéfinir le type... Le SiteMap manipulera les nodes en tant que SiteMapNode, pas en tant que NavigationItem, et n'appellera donc pas ta propriété redéfinie...