Perché? Ridichiarare le cose per implementare le interfacce ?! in VB.NET

Question

Lavoro in VB.NET v2

Ho un'interfaccia IMyInterface e questa interfaccia implementa un metodo MyMethod .

Ho un oggetto MyObjectBase . Questo oggetto contiene un metodo (lo stesso) MyMethod .

1) Se ora faccio MyObject Inherits MyObjectBase implementa IMyInterface devo ridefinire? (shadow, override) MyMethod nella classe MyObject ?

2) Cosa succede ora se invece il metodo MyMethod disponga di un MyEvent evento ?

Grazie.

Answer 1

In VB.NET, è necessario manualmente associare il contratto di interfaccia con le implementazioni. Dai un'occhiata al seguente esempio:

Interface MyInterface
    Sub Foo()
End Interface

Class TestClass
    Implements MyInterface

    Public Sub Test() Implements MyInterface.Foo
        Console.WriteLine("Test")
    End Sub

    Public Sub Foo()
        Console.WriteLine("Foo")
    End Sub
End Class

Quindi dai un'occhiata al seguente codice e al suo output:

Dim x As New TestClass()
x.Foo()                           ' Output: Foo '
Dim y As MyInterface = x
y.Foo()                           ' Output: Test '

Questo ha il vantaggio che l'implementazione di un'interfaccia non ti limita a nominare la tua funzione come vuoi . Lo svantaggio è che devi associare esplicitamente i metodi della tua classe alle dichiarazioni dell'interfaccia usando la parola chiave Implements .

---

Tanto su una spiegazione. Ora fammi arrivare al tuo problema: dato che non puoi fare in modo che Button implementi IVisibleChanged, puoi fare qualcosa del genere:

Private Event MyVisibleChanged() Implements IVisibleChanged.VisibleChanged

Private Sub RethrowVisibleChanged() Handles MyBase.VisibleChanged
    RaiseEvent MyVisibleChanged()
End Sub

MyBase è una parola chiave VB.NET che si riferisce alla superclasse. Allo stesso modo, nel caso di MyMethod , puoi farlo

Private Sub MyInterfaceMethod() Implements IMyInterface.Method
    MyBase.Method()
End Sub

Potrebbe sembrare un lavoro extra inutile, ma in un certo senso ha senso: Button.VisibleChanged e IVisibleChanged.VisibleChanged potrebbero essere eventi con due semantiche completamente diverse, a cui capita di avere lo stesso nome (dopo tutto il Button non non implementa IVisibleChanged ). Con il tuo codice, crei esplicitamente una connessione tra quei due.

Answer 2

È perché implementi la tua classe figlio che devi ridefinirla. Credo che se erediti dal caso di base, che viene comunque implementato, non dovrai farlo se non ti serve.