Tutorial: Crear e implementar interfaces (Visual Basic)

Artículo
06/08/2015

Las interfaces describen las características de las propiedades, los métodos y los eventos, pero dejan los detalles de la implementación para las estructuras o clases.

Este tutorial explica cómo declarar e implementar una interfaz.

Nota

Este tutorial no proporciona información sobre cómo crear una interfaz de usuario.

Nota

Es posible que tu equipo muestre nombres o ubicaciones diferentes para algunos de los elementos de la interfaz de usuario de Visual Studio en las siguientes instrucciones. La edición de Visual Studio que se tenga y la configuración que se utilice determinan estos elementos. Para obtener más información, consulte Personalizar la configuración de desarrollo en Visual Studio.

Para definir una interfaz

Abra un nuevo proyecto de aplicación para Windows de Visual Basic.
Agregue un módulo nuevo al proyecto haciendo clic en Agregar módulo en el menú Proyecto.
Asigne al módulo el nombre Module1.vb y haga clic en Agregar. Aparecerá el código del módulo nuevo.
Defina una interfaz con el nombre TestInterface dentro de Module1; para ello, escriba Interface TestInterface entre las instrucciones Module y End Module y presione ENTRAR. El Editor de código aplica una sangría delante de la palabra clave Interface y agrega una instrucción End Interface para formar un bloque de código.
Defina una propiedad, un método y un evento para la interfaz; para ello, sitúe el siguiente código entre las instrucciones Interface y End Interface:
```
Property Prop1() As Integer 
Sub Method1(ByVal X As Integer)
Event Event1()
```

Implementación

Puede notar que la sintaxis utilizada para declarar los miembros de la interfaz es diferente de la sintaxis utilizada para declarar los miembros de la clase. Esta diferencia refleja el hecho de que las interfaces no pueden contener código de implementación.

Para implementar la interfaz

Agregue una clase denominada ImplementationClass; para ello, agregue la siguiente instrucción a Module1 después de la instrucción End Interface pero antes de la instrucción End Module y, a continuación, presione ENTRAR:
```
Class ImplementationClass
```
Si está trabajando dentro del entorno de desarrollo integrado, el Editor de código proporciona la instrucción End Class correspondiente al presionar ENTRAR.
Agregue la siguiente instrucción Implements a ImplementationClass, que da nombre a la interfaz que implementa la clase:
```
Implements TestInterface
```
Cuando se muestra separada de otros elementos en la parte superior de la clase o estructura, la instrucción Implements indica que la clase o estructura implementa una interfaz.

Si está trabajando dentro del entorno de desarrollo integrado, el Editor de código implementa los miembros de clase requeridos por TestInterface al presionar ENTRAR, y se puede omitir el paso siguiente.
Si no está trabajando dentro del entorno de desarrollo integrado, debe implementar todos los miembros de la interfaz MyInterface. Agregue el código siguiente a ImplementationClass para implementar Event1, Method1 y Prop1:
```
Event Event1() Implements TestInterface.Event1

Public Sub Method1(ByVal X As Integer) Implements TestInterface.Method1
End Sub 

Public Property Prop1() As Integer Implements TestInterface.Prop1
    Get 
    End Get 
    Set(ByVal value As Integer)
    End Set 
End Property
```
La instrucción Implements asigna un nombre a la interfaz y al miembro de la interfaz que se está implementando.
Para finalizar la definición de Prop1, agregue un campo privado a la clase que almacenó el valor de propiedad:
```
' Holds the value of the property. 
Private pval As Integer
```
Devuelva el valor de pval desde el descriptor de acceso get de la propiedad.
```
Return pval
```
Establezca el valor de pval en el descriptor de acceso set de la propiedad.
```
pval = value
```
Para finalizar la definición de Method1, agregue el código siguiente:
```
MsgBox("The X parameter for Method1 is " & X)
RaiseEvent Event1()
```

Para probar la implementación de la interfaz

Haga clic con el botón secundario del mouse en el formulario de inicio del proyecto en el Explorador de soluciones y haga clic en Ver código. El editor mostrará la clase del formulario de inicio. De manera predeterminada, el formulario de inicio se denomina Form1.
Agregue el siguiente campo testInstance a la clase Form1:
```
Dim WithEvents testInstance As TestInterface
```
Al declarar testInstance como WithEvents, la clase Form1 puede controlar sus eventos.
Agregue el siguiente controlador de eventos a la clase Form1 para controlar los eventos desencadenados por testInstance:
```
Sub EventHandler() Handles testInstance.Event1
    MsgBox("The event handler caught the event.")
End Sub
```

Agregue una subrutina denominada Test a la clase Form1 para probar la clase de implementación:

Sub Test()
    '  Create an instance of the class. 
    Dim T As New ImplementationClass
    ' Assign the class instance to the interface. 
    ' Calls to the interface members are  
    ' executed through the class instance.
    testInstance = T
    ' Set a property.
    testInstance.Prop1 = 9
    ' Read the property.
    MsgBox("Prop1 was set to " & testInstance.Prop1)
    '  Test the method and raise an event.
    testInstance.Method1(5)
End Sub

El procedimiento Test crea una instancia de la clase que implementa MyInterface, asigna esa instancia al campo testInstance, define una propiedad y ejecuta un método a través de la interfaz.

Agregue código para llamar al procedimiento Test desde el procedimiento Form1 Load del formulario de inicio:

Private Sub Form1_Load(ByVal sender As System.Object, 
                       ByVal e As System.EventArgs) Handles MyBase.Load
    Test() ' Test the class.
End Sub

Ejecute el procedimiento Test presionando F5. Aparecerá el mensaje "Prop1 se ha definido como 9". Tras hacer clic en Aceptar, aparecerá el mensaje "El parámetro X de Method1 es 5". Al hacer clic en Aceptar, aparecerá el mensaje "El controlador de eventos ha interceptado el evento".