Dando os primeiros passos - Escrevendo Código VB.NET - III

 

No artigo Dando os primeiros passos - Escrevendo Código VB.NET - II  abordei os conceitos básicos sobre operadores e funções implícitas (as que vem embutidas no VB.NET) para você que esta começando a querer aprender a utilizar a linguagem Visual Basic.NET.

 

Neste artigo vou mostrar como você pode escrever suas próprias funções e sub-rotinas no VB.NET e falar um pouco sobre escopo de variáveis.

 

VB.NET - Escrevendo suas próprias funções

 

No artigo anterior você foi apresentado ás funções que o VB.NET oferece para facilitar sua vida. Mas sempre vai ficar faltando alguma coisa ; embora o VB.NET possua milhares de funções prontas para você usar , com certeza no dia a dia você vai ter que criar sua própria função.

 

Sem problema algum ! ; o VB.NET permite que você crie suas próprias rotinas e funções. É isto que vamos mostrar agora.

 

Existem dois tipos de rotinas usadas no VB.NET :

  1. Sub-rotinas - Sub - São rotinas que realizam tarefas e que não retornam valor algum.

  2. Funções - Function - São rotinas que realizam tarefas e que retornam valores.

Sub-rotinas

 

As sub-rotinas são um bloco de código VB.NET que realiza um serviço e não retorna nenhum valor. Quando você usa o código : Console.Writeline esta usando uma sub-rotina que apenas imprime uma informação na tela e não retorna valor algum.

 

Você cria uma sub-rotina quando deseja realizar uma tarefa que vai ser repetida muitas vezes ou se a mesma tarefa precisa ser usada em muitos programas.  Com isto você esta agrupando o seu código e tornando-o mais fácil de localizar e manter pois basta você invocar a sua sub-rotina para fazer o serviço ao invés de ter que escrever todo o código novamente.

 

Para criar uma sub-rotina você usa a palavra-chave - Sub - seguido do nome da sub-rotina  e dos parâmetros que você esta passando para ela. Os parâmetros são valores que você passa para sub-rotina usar na realização da tarefa que lhe foi atribuída. A sub-rotina termina com a palavra-chave : End Sub.

 

Vejamos como fica a sintaxe:

 

Sub NomedaSubRotina (parametro1 As TipodoParametro1, Parametro2 As TipodoParametro1, ...)

    ' O código da função

    ...

End Sub

    

Abaixo temos um exemplo de uma sub-rotina que multiplica dois números inteiros x e y e escreve o resultado no console:

 

Sub Multiplica ( x As integer, y As Integer)

       Console.WriteLine( x & " x " &  y & " = " & x*y )

End Sub

 

Para chamar a sub-rotina e passar os argumentos para os parâmetros usamos a forma :   NomeSubRotina(parametro1 , parametro2)

 

No exemplo acima podemos fazer assim :

 

Module Module1

Sub Main()

  Console.WriteLine("Vou chamar a Sub-rotina : Multiplica com os argumentos: 521 e 123.")

  Console.WriteLine("Pressione algo para ver o resultado...")

  Console.Read()

  Multiplica(521, 123)

End Sub

  Sub Multiplica(ByVal x As Integer, ByVal y As Integer)

    Console.WriteLine(x & " x " & y & " = " & x * y)

    Console.Read()

  End Sub

End Module

Funções

 

As funções são idênticas ás sub-rotinas a única mudança é que elas retornam um valor.

 

No caso das funções usamos a palavra-chave : Function seguida do nome da função e da relação dos parâmetros e terminamos com a palavra-chave : End Function.

 

No código da função usamos também a palavra-chave : Return que irá retornar o valor da função.

 

Assim temos:

 

Function NomedaFuncao (parametro1 As TipodoParametro1, Parametro2 As TipodoParametro1, ...)

    ' O código da função

    ...

    Return ValordeRetorno

End Sub

 

Usando o mesmo exemplo podemos criar uma função para multiplicar dois números inteiros e retornar o resultado. Assim:

 

Function Multiplica ( x As integer, y As Integer)

       Return x*y

End Sub

 

Para chamar a função e passar os parâmetros usamos a forma :   NomeFunção(parametro1 , parametro2)

 

Um exemplo prático pode ser o seguinte :

 

Module Module1

Sub Main()

   Console.WriteLine("Vou chamar a Função : Multiplica c/parametros: 521 e 123.")

   Console.WriteLine("Pressione algo para ver o resultado...")

   Console.Read()

   Console.Write("521 x 123 = " & Multiplica(521, 123))

   Console.Read()

End Sub

    Function Multiplica(ByVal x As Integer, ByVal y As Integer)

        Return x * y

   End Function

End Module

 

Como exemplos de funções do VB.NET podemos dar como exemplo aqueles que retornam um valor para uma operação.

 

Exemplo as funções Sqrt que calcula a raiz quadrada de um numero e a função Cos que calcula o coseno de um ângulo. Estas funções pertencem a classe Math.

 

Module Module1

Sub Main()

   Dim raiz, angulo As Double

 

  raiz = Math.Sqrt(100)

  angulo = Math.Cos(1.12)

 

  Console.WriteLine(" Raiz = " & raiz)

  Console.WriteLine("Angulo = " & angulo)

  Console.Read()

End Sub

End Module

 

 

O uso dos parâmetros não é obrigatório nas sub-rotinas nem nas funções , assim , você pode definir uma função sem parâmetros, mas deve definir o tipo de valor que será retornado:

 

Function CalculaPreco() As Double

     'código da função

     ......

     return valor

End Function       

Dim Preco as Double

Preco = CalculaPreco()

 

A função CalculaPreco não usa parâmetros mas deve informar o tipo do valor que irá retornar. No caso a função retorna um valor do tipo Double.

Para usar a função temos que declarar uma variável compatível com o valor de retorna e chamar a função.

 

 

Nota: as variáveis que você declara em uma sub-rotina ou função são locais e apenas visíveis pelo código da função ou sub-rotina.

 

Alterando o valor do parâmetro : ByVal ou ByRef ?

 

Na função multiplica usamos a palavra-chave ByVal , o que significa ByVal ?

 

ByVal significa que estamos passando o argumento(parâmetro) por valor;  desta forma a função ou sub-rotina não pode modificar o valor do argumento.

 

Quando você usa ByVal o VB.NET faz uma cópia do valor do parâmetro e então o VB.NET passa uma cópia do valor para a rotina. Desta forma a rotina não pode alterar o valor do parâmetro.

 

Se quisermos permitir que o argumento seja alterado pela função ou sub-rotina devemos usar a chave ByRef.

 

Quando você usa ByRef a rotina pode alterar o valor do parâmetro pois recebe uma referência ao parâmetro , e, a alteração do parâmetro na rotina se reflete no parâmetro passado.Vejamos o exemplo abaixo:

 

Module Module1

Sub Main()

   Dim Numero As Integer = 100

 

    Console.WriteLine("Valor de 'Numero' ANTES de chamar a sub-rotina: " & Numero)

    Console.Read()

 

   MudaValorParametro(Numero)

 

   Console.WriteLine("Valor de 'Numero' DEPOIS de chamar a sub-rotina: " & Numero)

   Console.Read()

 

End Sub

  Sub MudaValorParametro(ByRef valor As Integer)

      valor = 1000

  End Sub

End Module

 

 

Escopo das variáveis em rotinas e funções

 

Para terminar vamos falar um pouco sobre o escopo. O escopo refere-se a visibilidade das variáveis rotinas e funções dentro de um programa. Talvez você tenha bons motivos para que uma rotina ou variável não acesse todas as variáveis do seu programa . Permitir que todas as variáveis do seu programa seja acessadas por todas a rotinas do programa pode lhe trazer algumas dores de cabeça , pois , dependendo da complexidade do programa você pode perder o controle sobre quem esta alterando e acessando quem.

 

Até agora usamos a palavra-chave Dim para declarar uma variável . Porém podemos declarar variáveis fora das rotinas e funções e assim torná-las acessíveis  a outras rotinas.

 

Para fazer isto podemos usar as palavras-chave Public e Private:

  1. Public - As variáveis são visíveis por toda  a aplicação.

  2. Private - As variáveis são visíveis dentro do módulo ou classe onde foram declaradas.

Podemos usar as palavras-chave acima também para definir o escopo de funções e rotinas. Da mesma forma temos para funções e sub-rotinas:

  1. Public - A rotina pode ser chamada de qualquer parte de sua aplicação. É o padrão quando não se informa nada.

  2. Private - A rotina pode ser chamada somente por outra rotina dentro do mesmo módulo ou classe onde esta definida.

Module Module1

Sub main()

  contador1()

  contador2()

End Sub

Sub contador1()

  Dim contador As Integer

   For contador = 10 To 100

     Console.WriteLine(contador)

    Next

  Console.ReadLine()

End Sub

Sub contador2()

   Dim contador As Integer

  For contador = 100 To 1000

     Console.WriteLine(contador)

   Next

End Sub

End Module

Module Module1

Sub main()

  contador1()

  contador2()

End Sub

Dim contador As Integer

 

Sub contador1()

   For contador = 10 To 100

     Console.WriteLine(contador)

    Next

  Console.ReadLine()

End Sub

Sub contador2()

  For contador = 100 To 1000

     Console.WriteLine(contador)

   Next

End Sub

End Module
variável contador tem escopo local : as variáveis são visíveis somente em cada sub-rotina . É declara dentro de cada rotina. variável contador tem escopo global:é visível por ambas as sub-rotinas. É declarada fora das rotinas.

 

Os conceitos apresentados não esgotam o assunto , mesmo por que , abordei somente os conceitos mais usados.

 

Em um próximo artigo vou mostrar como aplicar todos estes conceitos em uma aplicação VB.NET. ]

 

Aguarde : Dando os primeiros passos - Escrevendo Código VB.NET - IV ...

 

 

Referências:

José Carlos Macoratti