Héritage d'interface C # à la classe abstraite

Question

Supposons que si j'ai une Interface telle que définie ci-dessous:

public interface IFunctionality
{
    void Method();       
}

et j'implémente cette interface pour une classe abstraite comme indiqué ci-dessous:

public abstract class AbstractFunctionality: IFunctionality
{
    public void Method()
    {
        Console.WriteLine("Abstract stuff" + "\n");
    }       
}

de plus, j'ai un béton de classe qui Hérite de la classe abstraite comme ci-dessous:

public class ConcreteFunctionality: AbstractFunctionality
{
    public void Method()
    {
        Console.WriteLine("Concrete stuff" + "\n");
    }
}

Maintenant, j'ai le code suivant

ConcreteFunctionality mostDerived = new ConcreteFunctionality();
AbstractFunctionality baseInst = mostDerived;
IFunctionality interfaceInst = mostDerived;
mostDerived.Method();
baseInst.Method();
interfaceInst.Method();

Une sortie qui je suis arriver après l'exécution de ce genre de choses est le suivant.

Concrete stuff
Abstract stuff
Abstract stuff

Mais ce que j'ai attendu la sortie de "Béton Trucs" dans les trois cas que ce que je fais ici est l'assignation de la référence de l' ConcreteFunctionality pour les variables de type AbstractFunctionality et IFunctionality.

Ce qui se passe à l'intérieur. Veuillez préciser.

Answer 1

Ici:

public class ConreteFunctionality:AbstractFunctionality
{
    public void Method()
    {
        Console.WriteLine("Concrete stuff" + "\n");
    }
}

... vous n'êtes pas en substituant l' existant méthode. Vous êtes en train de créer une nouvelle méthode qui se cache à l'existant. (Vous devriez recevoir un avertissement, trop, ce qui suggère l'utilisation de l' new modificateur si vous voulez vraiment ce comportement.) L'interface a été mis en œuvre en AbstractFunctionality, de sorte que l'interface de cartographie tableau fait référence à la méthode dans cette classe.

Maintenant, si vous ré-écrire l'interface:

public class ConcreteFunctionality : AbstractFunctionality, IFunctionality

... puis l'interface de mappage de se référer à la méthode en ConcreteFunctionality et vous obtiendrez le comportement que vous attendez pour l'appel par le biais de l' interface (c'est à dire votre troisième appel), mais que vous souhaitez toujours obtenir la mise en œuvre, en AbstractFunctionality pour votre deuxième appel.

Il serait généralement plus propre et plus sain d'esprit de préservation de faire de la méthode en AbstractFunctionality virtuel, et de la remplacer en ConcreteFunctionality. De cette façon, il va utiliser l' ConcreteFunctionality mise en œuvre dans tous les cas.

Answer 2

Vous devez définir les classes comme:

 public abstract class AbstractFunctionality:IFunctionality
{
    public virtual void Method()
    {
        Console.WriteLine("Abstract stuff" + "\n");
    }       
}

public class ConreteFunctionality:AbstractFunctionality
{
    public override void Method()
    {
        Console.WriteLine("Concrete stuff" + "\n");
    }
}
 

Comme vous n'avez pas surchargé Method () dans ConreteFunctionality, l'environnement d'exécution exécute Method () associé à l'objet AbstractFunctionality, car il ne peut pas appliquer de polymorphisme dynamique ici. L'introduction de virtual et override permet à l'environnement d'exécution d'exécuter la méthode remplacée dans la classe enfant.

Answer 3

Il vous manque virtual et override mots-clés. Sans cela, vous n'obtenez pas de fonctions virtuelles.

Vous pouvez marquer Method dans AbstractFunctionality comme virtual et marque l' Method en ConreteFunctionality comme override. Comme mihirj a montré.

Similaire questions abordées dans - Pourquoi C# interface des méthodes non déclarée abstraite ou virtuelle?