Passo a passo: Criar e implementar Interfaces (Visual Basic)

Artigo
02/25/2013

Interfaces descrevem as características das propriedades, métodos e eventos, mas deixe os detalhes de implementação para classes ou estruturas.

Esta explicação passo a passo demonstra como declarar e implementar uma interface.

Observação
Esta explicação passo a passo não fornece informações sobre como criar uma interface de usuário.

Observação
Seu computador pode mostrar nomes ou locais diferentes para alguns dos elementos da interface do usuário do Visual Studio nas instruções a seguir. A edição do Visual Studio que você possui e as configurações que você usa determinam esses elementos. Para obter mais informações, consulte Configurações de Visual Studio.

Para definir uma interface

Abra um novo projeto de Aplicativo do Windows Visual Basic.
Adicionar um novo módulo ao projeto clicando em Adicionar módulo sobre o projeto menu.
Nomeie o novo módulo de Module1.vb e clique em Add.O código para o novo módulo é exibido.
Definir uma interface denominada TestInterface em Module1 digitando Interface TestInterface entre o Module e End Module instruções e pressionando ENTER.O Editor de código recuos de Interface palavra-chave e adiciona um End Interface instrução para formar um bloco de código.
Definir uma propriedade, método e evento para a interface, colocando o seguinte código entre o Interface e End Interface instruções:
```
Property Prop1() As Integer
Sub Method1(ByVal X As Integer)
Event Event1()
```

Implementação

Você pode perceber que a sintaxe usada para declarar membros de interface é diferente da sintaxe usada para declarar membros de classe.Essa diferença reflete o fato de que interfaces não podem conter código de implementação.

Para implementar a interface

Adicionar uma classe chamada ImplementationClass adicionando a instrução a seguir para Module1, após o End Interface instrução, mas antes de End Module instrução e pressionando ENTER:
```
Class ImplementationClass
```
Se você estiver trabalhando no ambiente de desenvolvimento integrado, o Editor de código fornece uma correspondência End Class instrução quando você pressiona ENTER.
Adicione o seguinte Implements instrução para ImplementationClass, que nomeia a interface de classe implementa:
```
Implements TestInterface
```
Quando listado separadamente de outros itens na parte superior de uma classe ou estrutura, a Implements declaração indica que a classe ou estrutura implementa uma interface.

Se você estiver trabalhando no ambiente de desenvolvimento integrado, o Editor de código implementa os membros de classe necessários para TestInterface quando você pressionar ENTER e ignore a próxima etapa.
Se você não estiver trabalhando dentro do ambiente de desenvolvimento integrado, você deve implementar todos os membros da interface MyInterface.Adicione o seguinte código para ImplementationClass para implementar Event1, Method1, e 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
```
O Implements instrução nomeia a interface e um membro de interface que está sendo implementado.
Conclua a definição de Prop1 , adicionando um campo privado para a classe armazenado o valor da propriedade:
```
' Holds the value of the property.
Private pval As Integer
```
Retornar o valor de pval da propriedade acessador get.
```
Return pval
```
Definir o valor de pval na propriedade definir acessador.
```
pval = value
```

Conclua a definição de Method1 , adicionando o seguinte código.

MsgBox("The X parameter for Method1 is " & X)
RaiseEvent Event1()

Para testar a implementação da interface

O formulário de inicialização para seu projeto com o botão direito do Solution Explorere clique em Exibir código.O editor exibe a classe para o formulário de inicialização.Por padrão, o formulário de inicialização é chamado Form1.
Adicione o seguinte testInstance campo para o Form1 classe:
```
Dim WithEvents testInstance As TestInterface
```
Declarando testInstance como WithEvents, o Form1 classe pode manipular seus eventos.

Adiciona manipulador de eventos para o Form1 classe para manipular eventos gerados por testInstance:

Sub EventHandler() Handles testInstance.Event1
    MsgBox("The event handler caught the event.")
End Sub

Adicionar um sub-rotina nomeada Test para o Form1 classe para testar a classe de implementação:

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

O Test procedimento cria uma instância da classe que implementa MyInterface, atribui essa instância para o testInstance campo, define uma propriedade e executa um método por meio da interface.

Adicione código para chamar o Test procedimento a partir de Form1 Load procedimento do seu formulário de inicialização:

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

Execute o Test procedimento pressionando F5.A mensagem "Prop1 foi definida como 9" é exibida.Após você clicar em OK, a mensagem "O parâmetro x para Method1 é 5" é exibida.Clique em OK e a mensagem "O manipulador de eventos pego o evento" é exibida.