Discussion :

[agparchitecture]

Bonjour à tous, je rencontre un problème actuellement et me pose quelques questions sur l'héritage et sur les interfaces.

voici le code suivant:

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
 
interface ITest
{
 bool IsEmpty();
}
 
Class A : ITest
{
public bool IsEmpty()
{
//du code
}
 
Class B : A, ITest
{
 
}

Le compilateur compile sans erreur sur la class B puisque la classe A possède les méthodes nécessaire à l'interface.

Je me demandais donc comment je pouvais masquer public bool IsEmpty dans la class B pour être sur que l'interface soit également implémentée dans la class B.

Merci.

[jcdentons]

Bonjour agparchitecture,

Vous pouvez utiliser le mot clé new

Code :

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

1
2
3
4
5
class B : A {
public new bool IsEmpty() {
...
}
}

[agparchitecture]

Merci ca marche bien mais comment m'assurer que la classe B possède bien toute les méthodes imposées par l'interface.

J'avais essayé un sealed dans la classe A mais ca ne fonctionne pas.

[jcdentons]

Pourquoi avez-vous besoin de faire hériter B de A ?
Sinon, A pourrait être abstrait ?

[jcdentons]

Sinon vous pouvez utiliser une autre classe abstraite pour les méthodes communes à A et B, sans faire d'héritage entre A et B :

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
 
interface ITest
{
  bool IsEmpty();
}
 
abstract class C
{
  public void MethodeCommune() 
  {
      ...
  }
}
 
class A : C, ITest
{
  public bool IsEmpty()
  {
    //du code
  }
}
 
class B : C, ITest
{
  // On est obligé d'implémenter IsEmpty()
  public bool IsEmpty()
  {
    //du code
  }
}

[Noxen]

Bonjour agparchitecture,

Vous pouvez utiliser le mot clé new

Code :

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

1
2
3
4
5
class B : A {
public new bool IsEmpty() {
...
}
}

Je ne pense pas que le mot clé new correspondent à son besoin, et surtout sont effet est différent d'override / virtual / interface. La méthode est redéfinie au sein de la classe mais impose une liaison statique (par opposition à dynamique) et ne respecte pas par exemple le polymorphisme. Exemple :

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
namespace NewOrOverride
{
    interface ISample
    {
        void Write();
    }
 
    class A : ISample
    {
        public void Write()
        {
            Console.WriteLine("A");
        }
    }
 
    class B : A
    {
        public new void Write()
        {
            Console.WriteLine("B");
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            var a = new A();
            a.Write();
            // "A"
            var b = new B();
            b.Write();
            // "B"
            ISample i = a;
            i.Write();
            // "A"
            i = b;
            i.Write();
            // "A"
            a = b;
            a.Write();
            // "A"
            Console.ReadKey();
        }
    }
}

L'idée de la classe abstraite par contre me paraît bonne, bien qu'il soit difficile de juger eu égard au peu d'informations fournies.

[François DORIN]

Je me demandais donc comment je pouvais masquer public bool IsEmpty dans la class B pour être sur que l'interface soit également implémentée dans la class B.

Ce n'est pas possible. Ce que tu cherches à faire, c'est en gros dire que la classe B hérite de A de manière privée. En C#, l'héritage est forcément public. Il faudrait utiliser du C++ pour cela (et encore, pas sur que le C++/CLI supporte cette notion d'héritage privé).

En gros, l'héritage public signifie "B est une spécialisation de A", tandis que l'héritage privé signifie "B est implémenté en tant que A".

Un moyen de simuler l'héritage privé est de remplacer l'héritage par de la composition.