Heritage et interface

Version imprimable

30/05/2017, 17h01
agparchitecture

Heritage et interface
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:

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.
30/05/2017, 19h29
jcdentons
Bonjour agparchitecture,

Vous pouvez utiliser le mot clé new
Code:

1 2 3 4 5 class B : A { public new bool IsEmpty() { ... } }
30/05/2017, 20h12
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.
30/05/2017, 20h30
jcdentons

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

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:

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
  }
}

30/05/2017, 22h54
François DORIN

Citation:

Envoyé par agparchitecture

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.

Citation:

Envoyé par jcdentons

Bonjour agparchitecture,

Vous pouvez utiliser le mot clé new

Code:

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:

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.