Equivalent MyClass en C#

Question

En regardant this question, le commentateur @Jon Egerton a mentionné que MyClass était un mot clé dans VB.Net. Ayant jamais utilisé, je suis allé et a trouvé le documentation sur elle:

Le mot-clé MyClass se comporte comme une variable objet faisant référence à l'instance actuelle d'une classe comme initialement mis en œuvre. MyClass est similaire à Moi, mais tous les appels de méthode sont traités comme si la méthode était NotOverridable.

Je peux voir comment cela pourrait être utile dans certains cas. Ce que je ne peux pas penser est, comment obtiendriez-vous le même comportement en C# - c'est-à-dire, pour assurer qu'un appel à une méthode virtuelle myMethod est réellement invoqué contre myMethod dans la classe actuelle, et non un myMethod dérivé (aka dans l'IL, invoquant call au lieu de callvirt)?

Je pourrais juste avoir un moment mental complètement vide cependant.

Answer 1

According to Jon Skeet, il n'y a pas équivalent:

Non, C# n'a pas d'équivalent du mot-clé MyClass de VB.NET. Si vous voulez garantir de ne pas appeler une version substituée d'une méthode, vous devez la rendre non-virtuelle en premier lieu.

Une solution évidente serait:

public virtual void MyMethod() 
{ 
    MyLocalMethod(); 
} 

private void MyLocalMethod() 
{ 
    ... 
} 

Ensuite, vous pouvez appeler MyLocalMethod() lorsqu'un utilisateur VB écrirait MyClass.MyMethod().

Answer 2

Il n'y a pas d'équivalent C# du mot clé MyClass dans VB.Net. Pour garantir qu'une version substituée d'une méthode ne sera pas appelée, il suffit de la rendre non virtuelle.

Answer 3

En plus des réponses disant qu'il n'existe pas, vous devez le rendre non-virtuel.

Voici une smelly (lire: ne pas faire!). Mais sérieusement, repensez votre design.

Fondamentalement, déplacez toute méthode qui doit avoir la base appelée dans la classe super-base, qui se trouve au-dessus de votre classe de base existante. Dans votre appel de classe existant, appelez base.Method() pour toujours appeler celui qui ne l'est pas.

void Main() 
{ 
    DerivedClass Instance = new DerivedClass(); 

    Instance.MethodCaller(); 
} 


class InternalBaseClass 
{ 
    public InternalBaseClass() 
    { 

    } 

    public virtual void Method() 
    { 
     Console.WriteLine("BASE METHOD"); 
    } 
} 

class BaseClass : InternalBaseClass 
{ 
    public BaseClass() 
    { 

    } 

    public void MethodCaller() 
    { 
     base.Method(); 
    } 
} 

class DerivedClass : BaseClass 
{ 
    public DerivedClass() 
    { 

    } 

    public override void Method() 
    { 
     Console.WriteLine("DERIVED METHOD"); 
    } 
}