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

[Tens de ter uma conta e sessão iniciada para poderes visualizar esta imagem]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 :

Sub-rotinas - Sub - Sâo rotinas que realizam tarefas e que não retornam valor algum.
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:

Citação :

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:

Citação :

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 parâmetros usamos a forma : NomeSubRotina(parametro1 , parametro2)

No exemplo acima podemos fazer assim :

Citação :

Citação :

Module Module1
Sub Main()
Console.WriteLine("Vou chamar a Sub-rotina : Multiplica com os parametros: 521 e 123.")
Console.WriteLine("Pressione algo para ver o resultado...")
Console.Read()
Multiplica(521, 123)
End Sub

Citação :

Sub Multiplica(ByVal x As Integer, ByVal y As Integer)
Console.WriteLine(x & " x " & y & " = " & x * y)
Console.Read()
End Sub
End Module

[Tens de ter uma conta e sessão iniciada para poderes visualizar esta imagem]

O nome da sub-rotina é Multiplica
x e y são os parâmetros do tipo inteiro que são fornecidos para a sub-rotina realizar a multiplicação
A sub-rotina realiza a mutiplicação usando o operador * : x*y e escreve o resultado na tela.

Funções

As funções são idênticas ás sub-rotinas a única mudança é que elas retorna 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:

Citação :

Sub NomedaFunçõa (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:

Citação :

Sub 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 :

Citação :

Citação :

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

Citação :

Function Multiplica(ByVal x As Integer, ByVal y As Integer)
Return x * y
End Function
End Module

[Tens de ter uma conta e sessão iniciada para poderes visualizar esta imagem]

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.

Citação :

Citação :

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

[Tens de ter uma conta e sessão iniciada para poderes visualizar esta imagem]

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:

Citação :

Citação :

Function CalculaPreco() As Double
'código da função
......
return valor
End Function

Citação :

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:

Citação :

Citação :

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

Citação :

Sub MudaValorParametro(ByRef valor As Integer)
valor = 1000
End Sub
End Module

[Tens de ter uma conta e sessão iniciada para poderes visualizar esta imagem]

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:

Public - As variáveis são visíveis por toda a aplicação.
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:

Public - A rotina pode ser chamada de qualquer parte de sua aplicação. É o padrão quando não se informa nada.
Private - A rotina pode ser chamada somente por outra rotina dentro do mesmo módulo ou classe onde esta definida.

Citação :

Citação :

Module Module1
Sub main()
contador1()
contador2()
End Sub

Citação :

Sub contador1()
Dim contador As Integer
For contador = 10 To 100
Console.WriteLine(contador)
Next
Console.ReadLine()
End Sub

Citação :

Sub contador2()
Dim contador As Integer
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.

Citação :

Citação :

Module Module1
Sub main()
contador1()
contador2()
End Sub

Citação :

Dim contador As Integer

Sub Scontador1()
For contador = 10 To 100
Console.WriteLine(contador)
Next
Console.ReadLine()
End Sub

Citação :

Sub contador2()
For contador = 100 To 1000
Console.WriteLine(contador)
Next
End Sub
End Module

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. Até lá...