Comment appeler des méthodes d'implémentation d'interface explicite en interne sans conversion explicite?

Question

Si je

public class AImplementation:IAInterface 
{ 
    void IAInterface.AInterfaceMethod() 
    { 
    } 

    void AnotherMethod() 
    { 
     ((IAInterface)this).AInterfaceMethod(); 
    } 
} 

Comment appeler AInterfaceMethod() de AnotherMethod() sans coulée explicite? Vous ne pouvez pas simplement supprimer le "IAInterface."

Answer 1

de la signature de la méthode?

public class AImplementation : IAInterface 
{ 
    public void AInterfaceMethod() 
    { 
    } 

    void AnotherMethod() 
    { 
     this.AInterfaceMethod(); 
    } 
} 

Answer 2

essayé et ça fonctionne ...

public class AImplementation : IAInterface 
{ 
    IAInterface IAInterface; 

    public AImplementation() { 
     IAInterface = (IAInterface)this; 
    } 

    void IAInterface.AInterfaceMethod() 
    { 
    } 

    void AnotherMethod() 
    { 
     IAInterface.AInterfaceMethod(); 
    } 
} 

Answer 3

Vous ne pouvez pas, mais si vous devez le faire beaucoup vous pouvez définir une aide de commodité:

private IAInterface that { get { return (IAInterface)this; } }

Chaque fois que vous souhaitez appeler une méthode d'interface explicitement implémentée, vous pouvez utiliser that.method() au lieu de ((IAInterface)this).method().

Answer 4

Vous pouvez introduire une aide propriété privée:

private IAInterface IAInterface { get { return this; } } 

void IAInterface.AInterfaceMethod() 
{ 
} 

void AnotherMethod() 
{ 
    IAInterface.AInterfaceMethod(); 
} 

Answer 5

Un certain nombre de réponses disent que vous ne pouvez pas. Ils sont incorrects. Il y a beaucoup de façons de le faire sans utiliser l'opérateur de casting.

Technique n ° 1: Utiliser l'opérateur "as" à la place de l'opérateur de moulage.

void AnotherMethod() 
{  
    (this as IAInterface).AInterfaceMethod(); // no cast here 
} 

Technique n ° 2: utiliser une conversion implicite via une variable locale.

void AnotherMethod() 
{  
    IAInterface ia = this; 
    ia.AInterfaceMethod(); // no cast here either 
} 

Technique # 3: écrire une méthode d'extension:

static class Extensions 
{ 
    public static void DoIt(this IAInterface ia) 
    { 
     ia.AInterfaceMethod(); // no cast here! 
    } 
} 
... 
void AnotherMethod() 
{  
    this.DoIt(); // no cast here either! 
} 

Technique # 4: Mettre en place une aide:

private IAInterface AsIA() { return this; } 
void AnotherMethod() 
{  
    this.AsIA().IAInterfaceMethod(); // no casts here! 
} 

Answer 6

Encore une autre façon (pas le meilleur):

(this ?? default(IAInterface)).AInterfaceMethod(); 

Answer 7

Et encore une autre façon (qui est une spin-off de La technique n ° 2 d'Eric et devrait aussi donner une erreur de compilation si l'interface n'est pas implémentée)

 IAInterface AsIAInterface 
    { 
     get { return this; } 
    }