Pourquoi ai-je une erreur en C# lors du mélange de l'implémentation explicite et du polymorphisme?

Question

Je reçois cette erreur:

type Bar does not implement interface IFoo

A partir de ce code:

public interface IFoo 
{ 
    void DoA(); 

    void DoB(); 
} 

public class Foo:IFoo 
{ 

    void IFoo.DoA() 
    { 

    } 

    void IFoo.DoB() 
    { 


    } 
} 

public class Bar:Foo 
{ 

    void IFoo.DoA() 
     { 
      base.doA(); 

     } 

     void IFoo.DoB() 
     { 
      base.doB(); 

     } 
    } 

J'utilise C# 2.0.

Qu'est-ce que je fais mal?

Answer 1

J'ai également rencontré cela. ce qui est 'pire', selon la façon dont vous le regardez, c'est que vous ne pouvez pas définir les implémentations d'interface comme étant virtuelles à surcharger dans les classes descendantes. J'ai pris l'habitude de le faire:

public class Foo:IFoo 
{  
    void IFoo.DoA() 
    { 
      DoACore(); 
    } 
    void IFoo.DoB() 
    { 
      DoBCore(); 
    } 
    protected virtual void DoACore() 
    { 
    } 
    protected virtual void DoBCore() 
    { 
    } 
} 
public class Bar:Foo 
{  protected override void DoACore() 
     { 
      base.DoACore(); 
     } 
     protected override void DoBCore() 
     { 
      base.DoBCore(); 
     } 
} 

Answer 2

public class Bar : Foo, IFoo 
{ 
    // Your code 
} 

Answer 3

Voir n8wrl's answer à la façon dont vous devriez faire cela. Voir ci-dessous pour la raison pourquoi.

Vous ne pouvez pas explicitement implémenter des membres d'interface (void IFoo.DoA()) lors de la mise en œuvre implicite de l'interface. En d'autres termes, étant donné que Bar implémente uniquement IFoo en raison de l'extension Foo, vous ne pouvez pas utiliser une implémentation explicite.

Cela fonctionne:

public class Bar : Foo 
{ 
    public void DoA() 
    { 
     ... 
    } 

    public void DoB() 
    { 
     ... 
    } 

Ou ceci:

public class Bar : Foo, IFoo 
{ 
    void IFoo.DoA() 
    { 
     ... 
    } 

    void IFoo.DoB() 
    { 
     ... 
    } 

Un plus grand problème que vous aurez probablement faire face est que, puisque Foo n'est pas abstraite, elle doit mettre en œuvre DoA et DoB. Si vous également implémenter ces méthodes dans la barre, vous ne le ferez pas polymorphiquement. Vous serez hiding les implémentations Foo si le code a un handle au type Bar.

Answer 4

Je soupçonne que la confusion se pose sur la façon dont les interfaces ont été mises en œuvre en C++, comme des classes abstraites et l'héritage multiple.

Dans .NET, et interface est simplement un contrat qui dit que vous allez implémenter ces méthodes.

Vous écrivez du code ne compilera pas pour la même raison ce code compile l'habitude (ce serait avec C++):

public interface IFoo 
{ 
    void DoSomething(); 
} 

public abstract class Foo : IFoo 
{ 
} 

Foo Foo déclarant que implémente IFoo, il ne dit rien d'autre au sujet n'importe qui.

Si vous vouliez forcer les classes dérivées à mettre en œuvre que vous feriez:

public interface IFoo 
{ 
    void DoSomething(); 
} 

public abstract class Foo : IFoo 
{ 
    public abstract void DoSomething(); 
} 

Ou si vous voulez vraiment les méthodes d'interface cachées par la mise en œuvre explicite, alors quelque chose comme n8wrl affiché ci-dessus.

Answer 5

Au début, ce n'est pas clair quelle est la tâche? Si les objectifs étaient de résoudre un problème dès que possible, 'Bar: Foo, IFoo' est la solution la plus courte.

Si vous essayez simplement d'apprendre la différence d'interfaces 'implicite/explicite', vérifiez ceci post.

Notez également que la solution 'n8wrl' est discutable. C'est correct seulement si Foo a effectivement besoin d'implémenter IFoo explicitement. Si non, il y a une manière plus simple:

Espérons que cela aide.