Interface mise en œuvre et l'héritage en C#

Question

J'ai un code pour mettre en œuvre l'interface en C#

public interface Intfc { void xyz();} 

public class BaseClass : Intfc 
{ 

    public virtual void xyz() 
    { 
     Console.WriteLine("In Base Class"); 
    } 
} 

public class Derived : BaseClass 
{ 
    public override void xyz() 
    { 
     Console.WriteLine("In Derived Class"); 
    } 
} 

static void Main(string[] args) 
    { 
     Derived mc = new Derived(); 
     mc.xyz(); //In Derived Class 
     ((BaseClass)mc).xyz(); //In Base Class 
     ((Intfc)mc).xyz(); //In Derived Class 

     Console.ReadKey(); 

    } 

J'ai besoin de la sortie de la console comme il est prévu dans les commentaires à Main(). Les résultats réels sont

In Derived Class 
In Derived Class 
In Derived Class 

Comment puis-je obtenir les résultats souhaités.

Answer 1

Vous devez remplacer la méthode sur la classe Dérivée au lieu d'utiliser les opérateurs virtual/override à l'aide de l'opérateur new.

http://msdn.microsoft.com/en-us/library/51y09td4(VS.71).aspx#vclrfnew_newmodifier

essayer

public interface Intfc { void xyz();} 

public class BaseClass : Intfc 
{ 
    public void xyz() 
    { 
     Console.WriteLine("In Base Class"); 
    } 
} 

public class Derived : BaseClass 
{ 
    new public void xyz() 
    { 
     Console.WriteLine("In Derived Class"); 
    } 
} 

static void Main(string[] args) 
{ 
    Derived mc = new Derived(); 
    mc.xyz(); //In Derived Class 
    ((BaseClass)mc).xyz(); //In Base Class 
    ((Intfc)mc).xyz(); //In Derived Class 

    Console.ReadKey(); 

} 

Answer 2

Vous ne pouvez pas faire cela, mc est de type Derived et il appellera toujours le xyz dans cette classe. C'est comme ça que l'héritage fonctionne. Vous avez besoin d'une instance de BaseClass:

var bc = new BaseClass(); 
bc.xyz(); // In Base Class 

Answer 3

Vous aurez besoin d'un var b = new BaseClass(). Puis b.xyz() au lieu de ((BaseClass)mc).xyz().

Answer 4

Ne pas utiliser virtual méthodes avec le modificateur override, mais ré-écrire l'interface de la classe Derived.

Le code ci-dessous présente le comportement requis, mais je considère cette approche légèrement confuse et opaque pour les utilisateurs finaux.

public interface Intfc { void xyz();} 

public class BaseClass : Intfc 
{ 

    public void xyz() 
    { 
     Console.WriteLine("In Base Class"); 
    } 
} 

public class Derived : BaseClass,Intfc 
{ 
    public void xyz() 
    { 
     Console.WriteLine("In Derived Class"); 
    } 
} 

static void Main() 
{ 
    Derived mc = new Derived(); 
    mc.xyz(); //In Derived Class 
    ((BaseClass)mc).xyz(); //In Base Class 
    ((Intfc)mc).xyz(); //In Derived Class 



} 

Answer 5

Vous manquez de comprendre le comportement de l'héritage.

Lorsque vous créez un objet de type donné que outrepasse une méthode virtuelle Vous obtiendrez toujours le résultat de cette méthode de remplacement. Le casting ne change pas la structure de l'objet, une fois que l'objet create peut changer d'état après l'opération cast.

static void Main(string[] args) 
    { 
     Intfc mc1 = new Derived(); 
     Intfc mc2 = new BaseClass(); 

      mc1.xyz(); 
      mc2.xyz(); 

     Console.ReadKey(); 

    } 

Ce produit sera la

In Base Class 
In Derived Class 

Mais parce qu'il ya toujours un mais.

Si vous écrasez cette méthode, vous obtiendrez le résultat que vous êtes jusqu'à, pour remplacer la méthode il suffit d'utiliser l'opérateur nouvelle

public class Derived : BaseClass 
{ 
    new public void xyz() 
    { 
     Console.WriteLine("In Derived Class"); 
    } 
} 

public class BaseClass : Intfc 
{ 

    public void xyz() 
    { 
     Console.WriteLine("In Base Class"); 
    } 
} 

Cela utilisera une nouvelle mise en œuvre pour DeriveClass et ancien pour BaseClass.

Liens:

What override is ?

Modifier new in method signature

What modifier new is ?

Answer 6

Lorsque vous avez ajouté le modificateur override à la méthode virtuelle héritée xyz en mc, vous l'emportaient simplement la méthode virtuelle héritée dans la instance mentionnée par mc. C'est comme si vous avez effacé le Base.xyz et écrit Derived.xyz à sa place dans la mémoire de l'instance mc. Donc l'instance référencée par mc n'a aucun enregistrement du xyz virtuel dans son implémentation et donc aucun moyen d'y accéder via la référence mc. La seule façon d'accéder à la méthode virtuelle de la base consiste à utiliser une instance de la base comme illustré ci-dessous:

var b = new BaseClass();  
b.xyz();// instead of ((BaseClass)mc).xyz()