Jak wywoływać metody implementacji jawnych interfejsów wewnętrznie bez jawnego przesyłania?

Question

Jeśli mam

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

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

Jak wywołać AInterfaceMethod() z AnotherMethod() bez wyraźnej castingu?

Answer 1

Nie możesz po prostu usunąć "IAInterface". z podpisem metody?

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

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

Answer 2

Próbowałem to i to działa ...

public class AImplementation : IAInterface 
{ 
    IAInterface IAInterface; 

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

    void IAInterface.AInterfaceMethod() 
    { 
    } 

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

Answer 3

Nie możesz, ale jeśli trzeba to zrobić dużo można określić pomocnika Wygoda:

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

Zawsze, gdy chcesz wywołać metodę interfejsu, która została zaimplementowana jawnie, możesz użyć that.method() zamiast ((IAInterface)this).method().

Answer 4

Można wprowadzić pomocnika własności prywatnej:

private IAInterface IAInterface { get { return this; } } 

void IAInterface.AInterfaceMethod() 
{ 
} 

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

Answer 5

Wiele odpowiedzi, że nie można. Są niepoprawne. Istnieje wiele sposobów na to, bez korzystania z operatora obsady.

Technika # 1: Użyj operatora "as" zamiast operatora cast.

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

Technika # 2: użyj niejawnej konwersji za pomocą zmiennej lokalnej.

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

Technika # 3: napisać metodę rozszerzenia:

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

Technika # 4: wprowadzenie pomocnika:

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

Answer 6

jeszcze inny sposób (nie najlepszy):

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

Answer 7

A jeszcze inny sposób (który jest spin off of Eric's Technique # 2, a także powinien dać błąd czasu kompilacji, jeśli interfejs nie jest zaimplementowany)

 IAInterface AsIAInterface 
    { 
     get { return this; } 
    }