Introdução ao .NET Framework – Parte 4

 

Objetivos:

 

Este parte do tutorial discute o .NET Framework e o Common Language Runtime. Também fornece introdução a sintaxe de classes, estruturas e declarações de métodos.

 

Pré-requisitos:

 

Ter estudado a parte 3 deste tutorial.

 

Usando métodos

 

Métodos fazem o trabalho para classes e estruturas. Eles calculam valores, atualizam dados, recebem informações e fazem todo o tipo de ação que caracteriza um tipo.

 

Adicionando métodos

 

Você pode adicionar métodos como membros de sua classe. Métodos representam ações que sua classe pode fazer. Métodos podem ser dividos em duas categorias: os que retornam um valor (functions no Visual Basic.NET) e os que não retornam um valor (subs no Visual Basic.NET). Os exemplos abaixo mostram os dois tipos de métodos:

 

Visual Basic .NET

 

Public Sub MySub()

       MessageBox.Show(“Este método não retorna um valor.”)

End Sub

‘ Note que o símbolo underscore ( _ ) é usado no

‘ Visual Basic .NET para que a linha seguinte seja a continuação da linha onde
‘ o ( _ ) esta localizado

Public Function Add(ByVal first As Integer, ByVal second as _

       Integer) As Integer

       Dim Result As Integer

       Result = first + second

       Return Result

 

End Function

 

Visual C# naão faz distinção entre métodos que retornam valores e métodos que não retornam valores. Tanto num caso como no outro você deve definir o tipo do retorno do método. S o método não retorna valor deve ter o tipo definido como void. Veja nas próximas linhas exemplos de métodos em C#.

 

C#

 

public void myVoidMethod(){

       MessageBox.Show(“Este método não retorna valor”);

}

public int Add(int first, int second){

       int Result;

       Result = first + second;

       return Result;

}

 

Chamando métodos

 

Um método não é executado até que seja chamado. Você pode chamar um método referenciando seu nome e seguido de seus parâmeros, caso hajam. Veja os exemplos a seguir:

 

Visual Basic .NET

 

‘ Esta linha chama o método Rotate com dois parâmetros

Rotate(45, “Graus”)

 

Visual C#

 

// Esta linha chama o método Rotate com dois parâmetros

Rotate(45, “Graus”);

 

O método Main é um caso especial. Ele é chamado no início da execução do programa. Destruidores também são métodos especiais que são chamados pelo runtime no momento em que o objeto é destruído.  Assim como os construtores que são executados no momento da incialização do método. Todos os três métodos especiais serão discutidos em detalhes em nosso tutorial.

 

Variáveis de métodos

 

Quando uma variável é declarada dentro do método dizemos que ela tem o escopo de método. Isto significa que quando o método encerrar sua execução ela é destruída e a memória que ela ocupava é liberada.

 

Variáveis que são utilizadas em blocos dentro do método tem seu escopo ainda mais reduzido. Variáveis declaradas em um loop For-Next (for) só podem ser acessadas dentro do loop em que ela foi declarada. Os exemplos abaixo demonstram isto, eles forçam um erro utilizando a variável Y fora do seu escopo.

 

Visual Basic .NET

 

Public Sub myMethod()

       Dim X As Integer

       For X = 1 To 100

                 Dim Y As Integer

                 Y = X

       Next X

       ‘ A linha seguinte vai gerar um erro

       Console.WriteLine(Y.ToString)

End Sub

 

Visual C#

 

public void myMethod(){

       int X;

       for(X=1; X < 101; X++){

                 int Y;

                 Y = X;

       }

       // A linha seguinte vai gerar um erro

       Console.WriteLine(Y.ToString)

}

 

O Visual Basic .NET permite que você crie variáveis de métodos que não são destruídas ao final da execução do método. Estas variáveis chamadas de variáveis estáticas de métodos se mantém na memória mesmo após várias execuções do método.  Você declara uma variável estática utilizando a palavra chave Static. Veja os exemplos a seguir:

 

Visual Basic .NET

 

Public Sub myMethod()

       Static Iterations As Integer

       ‘ Esta variável é incrementada cada vez que o método é executado

       Iterations += 1

End Sub

 

Embora a variável permaneça na memória, ela só pode ser acessada durante a execução do método. Você pode usar uma variável estática de método quando desejar rastrear quantas vezes o método é executado.

 

Nota

 

Esta característica não está disponível no C#. A palavra chave static no C# tem um significado diferente do Visual Basic .NET.  Iremos estudar isso mais a frente em nosso tutorial.

 

Parâmetros

 

Um método pode ter um ou mais parâmetros. O parâmetro é um argumento que é passado para o método no momento em que o método é chamado. Parâmetros são delimitados por parênteses depois do nome do método na declaração do parâmetro e dever ter seu tipo especificado. Abaixo exemplos do uso de parâmetros:

 

Visual Basic .NET

 

Public Sub DisplayName(ByVal name As String, ByVal age As Byte)

       Console.WriteLine(“Hello “ & name & “. You are “ & _

                 age.ToString & “years old.”)

End Sub

 

Visual Basic C#

 

public void DisplayName(string name, byte age){

       Console.WriteLine(“Hello “ + name + “. You are “  +

                 Age.ToString() + “years old.”);

}

 

Este método precisa de dois parâmetros: O primeiro parâmetro é uma string com o nome de name e um segundo parâmetro que é um byte cujo nome é age. Estas variáveos tem duração apenas enquanto o método durar e não podem ser utilizadas após seu encerramento. Iremos tratar com mais detalhes sobre escopo nos próximos tópicos desse tutorial.

 

Parâmetros podem ser passados de duas formas por valor ou por referência. No .NET Framework caso não seja especificado assume-se que o parâmetro esta sendo passado por valor, este é o padrão. Passar parâmetros por valor significa que uma cópia dos valores informados são é passada para o método. Qualquer mudança realizada no parâmetro não altera o valor original da variável. Embora  a forma padrão de passar parâmetros seja por valor aconselhamos a você a explicitar a forma como o parâmetro é passado utilizando a palavra chave ByVal.

 

Quando o parâmetro é passado por referência a  localização na memória onde a variável reside  é que é passada para o parâmetro. Qualquer alteração realizada no parâmetro reflete em sua variável de origem. Para passar um parâmetro por referência no Visual Basic .NET utilize a palavra chave ByRef. No Visual C# a palavra chave ref deve ser utilizada.  Os exemplos abaixo demostram nossas últimas explicações.

 

Visual Basic .NET

 

Public Sub Demo1()

       Dim x,y As Integer

       x = 15

       y = 20

       ‘  A linha seguinte chama o método Demo2 ( visto mais à frente)

       Demo2(x, y)

       ‘ Que valores x e y tem agora ?

       MessageBox.Show(“X = “ & x.ToString & “ Y = “ & y.ToString)

End Sub

Public Sub Demo2(ByVal p1 As Integer, ByRef p2 As Integer)

       p1 = p1 + p2

       p2 = p2 + p1

End Sub

 

Visual Basic C#

 

public void Demo1(){

       int x,y;

       x = 15;

       y = 20;

       // A linha seguinte chama o método Demo2 ( visto mais à frente)

       Demo2(x, ref y);

       // Que valores x e y tem agora ?

       MessageBox.Show(“X = “ + x.ToString + “ Y = “ + y.ToString);

}

public void Demo2(int p1, ref int p2){

       p1 = p1 + p2;

       p2 = p2 + p1;

}

 

Nos exemplos acima duas variáveis são criadas x e y e valores são atribuídas a elas. AS variáveis x e y são passadas para o segundo método. x é passado por valor e y é passado por referência e ambas são representadas no segundo método por p1 e p2. Porque x foi passado como por valor p1 representa uma cópia do valor de x. Quando o método terminar o conteúdo da variável sera limpo e a memória utilizada por ela também.  Já o parâmetro p2 não contém o valor de nada. Em vez disso contém o endereço onde o valor atual da variável y  é armazenado na memória. Logo quando ele encontra a linha p2 = p2 + 1 o valor armazenado no local de memória representado por p2 é alterado. Desta forma quando o método Demo2 se encerra o valor de X permanece 15 enquanto o valor de Y foi alterado para 55.

 

Note que se o parâmetro que vai passar é de um tipo por referência. Não importa como você vai definir que ele deve ser passado. Ele sempre vai ser passado por referência.