VB .NET 2005 - Aperfeiçoamentos da linguagem

A nova versão do Visual Basic (leia-se Visual Basic 2005 ou VS.NET 2.0) trouxe muitas novidades, muitas delas já foram tratadas em diversos artigos no site. Vejamos a seguir alguns novos recursos que foram introduzidos com o objetivo de otimizar e aperfeiçoar a linguagem.

1- Instrução Using

A instrução Using foi copiada do C# e é usada para facilitar a implementação de executar código para liberá-lo em seguida. Com esta instrução os programadores podem ter certeza de  que os tipos IDisposable envolvidos na instrução serão sempre liberados sem a necessidade de envolver estes objetos no interior de manipuladores de exceções com invocação explícita dos métodos Dispose. Vejamos o exemplo a seguir:

 Using cn As New OleDbConnection("conexao"), cmd As New OleDbCommand("cmd", cn)
     cn.Open()
     Using rdr As OleDbDataReader = cmd.ExecuteReader(Data.CommandBehavior.SingleResult)
        While rdr.Read()
         ......
        End While
     End Using
End Using

No trecho de código acima temos duas instruções Using aninhadas:

A primeira utiliza uma conexão com um banco de dados e um objeto Command e a segunda usa um objeto DataReader.

Com as instruções Using você usa os objetos e eles são liberados assim que você termina de usá-los de uma forma limpa e rápida.

A idéia e permitir a utilização dos recursos e imediatamente liberá-los da memória após sua utilização. Este é o papel do construtor Using...End Using. Você pega, usa, e não precisa ficar preocupado em liberar os recursos, Using faz isto para você.

O construtor garante que os recursos definidos no interior do bloco Using serão liberados após o fechamento do bloco.

No trecho de código abaixo vemos que as variáveis declaradas no interior de um bloco Using...End Using não estão disponíveis fora do bloco.

Public Sub AcessoDados(ByVal str As String)

  Using conn As New SqlConnection(str)
    Dim ds As DataSet
    '---codigo de acesso aos dados
  End Using
 
  ' Isto não será permitido pois os objetos conn e ds foram definidos no interior do bloco Using
  ' e não estão mais disponíveis
  conn.close
  ds = Nothing 
End Sub

2- Instrução Continue

A instrução Continue permite que se vá para a próxima interação em um loop de forma mais lógica. Além disto você pode definir para qual loop estamos indo. Vejamos um exemplo:

For i As Integer = 0 To 5

  While True
      If Condicao1 Then
         Continue While
      ElseIf Condicao2 Then
         Continue For
      End If

      Do
        If Condicao1Then
           Continue Do
        ElseIf Condicao2 Then
           Continue While
        Else
           Continue For
        End If
      Loop While Condicao2

  End While

  If Condicao1 Then
     Continue For
  End If

Next

 Temos 3 laços:
  1. Um laço For/Next
  2. Um laço While/Loop - aninhado no interior do loop For/Next
  3. Um laço Do/Loop - aninhado no interior do loop While/Loop

Vejamos o resultado da utilização da instrução Continue:

  • Dentro do laço For/Next , se condicao1 for atendida, pulamos (Continue For) para a próxima interação do mesmo laço For/next
  • Dentro do laço While/Loop, se condicao1 for atendida, pulamos (Continue While) para a próxima iteração do mesmo laço While/Loop . Se condicao2 for satisfeita pulamos (Continue For) para a próxima iteração do laço externo For/Next.
  • Dentro do laço Do/Loop, se condicao1 for atendida, pulamos (Continue Do) para a próxima iteração do mesmo laço Do/Loop; se condicao2 for atendida, saltamos (Continue While) para a próxima iteração do laço externo While/Loop.De outra forma , saltamos (Continue For) para a próxima iteração do laço For/Next.

A seguir mais 3 exemplos de utilização da instrução Continue:
a)  Continue For
Dim j As Integer = 0
Console.WriteLine("Neste loop não será exibido o valor de j igual a 25")
For i As Integer = 1 To 100
   j += 1
   If j = 25 Then Continue For
   ' Quando j for igual a 25 , esta linha não será executada
   Console.WriteLine("i= {0}, j= {1}", i, j)
Next

b) Continue Do

Console.WriteLine("Neste loop o valor de x=15 não será exibido.")
Dim x As Integer = 0
Do
   x += 1
   If x = 15 Then Continue Do
   ' Quando x for igual a 15 esta linha não será executada
   Console.WriteLine("x= {0}", x)
Loop While x < 25

3. Continue While
Console.WriteLine("Neste loop o valor de y=30 não será exibido.")
Dim y As Integer = 0
While y < 50
   y += 1
   If y = 30 Then Continue While
   ' Esta linha de código não será executada quando y for igual a 30
   Console.WriteLine("y= {0}", y)
End While

3- Operador IsNot

Você usa o operador Is quando deseja verificar se um objeto que aponta para um variável é o mesmo que aponta para outra variável.

Se temos duas variáveis m1 e m2 que apontam para o mesmo objeto criado na memória podemos fazer o seguinte:

If m1 is m2 then

para o caso acima o valor de retorno será um True pois assumimos que ambas apontam para o mesmo objeto.

Para verificar se os objetos contidos nas duas variáveis sejam diferentes até o presente momento fazíamos assim:

If Not m1 is m2 then

Neste caso o retorno seria False pois ambas possuem o mesmo conteúdo. (Retornaria True se o conteúdo dos objetos fosse diferente.)

Geralmente usamos este tipo de comparação quando queremos verificar se o conteúdo não seja Nothing (Nulo), teremos neste caso:

If Not m1 is Nothing then

Meio confuso, não é mesmo...

Pois bem pensando em tornar tal operação mais clara no Visual Basic 2005 temos o operador IsNot.

Ele substitui os operadores Is e Not. Desta forma a última comparação ficaria assim:

If m1 IsNot Nothing then

aluminou  um pouco certo !!!!

Se você esta torcendo o nariz para o IsNot e achando tudo isto desnecessário. Tudo bem , continue usando as opções anteriores...

4- O operador TryCast

Tanto o VB.NET como C# são linguagens fortemente tipadas (como Java), isto significa que o compilador verifica por compatibilidades de tipos em tempo de execução em quase todos os casos , impedindo atribuições incompatíveis , proibindo atribuições questionáveis e fornecendo casts quando a compatibilidade de um tipo puder ser determinada apenas em tempo de execução.

Algumas conversões ocorrem automaticamente, sem você ter que se preocupar. Por padrão no VB.NET o casting é automático quando você atribui objetos a variáveis. Os objetos são então convertidos à força para o tipo da variável. Este comportamento pode ser influenciado pelas declarações:

- Option Strict On - (padrão) - o casting é restrito é não é automático
- Option Strict Off - permite conversões implícitas no seu código

Para realizar um casting explícito (conversão forçada) podemos usar o operador Ctype() ou DirectCast()

Veja mais detalhes no artigo:  VB.NET - Casting : Ctype ou DirectCast. - Fazendo Casting. Ctype ou DirectCast ?

Pois bem, pois o VB 2005 oferece outro operador de conversão chamado TryCast que é equivalente ao operador as do C#.

"Mais um ???? ".Você deve estar pensando...

Deve haver alguma diferença !!! E , realmente há...

A primeira diferença é que tanto Ctype como DirectCast lançam a exceção InvalidCastException enquanto que o operador TryCast retorna um resultado Nothing se não for possível realizar a conversão. Pensando nisto você poderia fazer assim :

m = TryCast(obj, Integer)
If m IsNot Nothing then
       .....
End if

Outra forma de usar o TryCast seria otimizar o código quando há necessidade de realizar conversões. Vejamos um exemplo:

Sub Imprimir(ByVal m As Object)
    Dim ImprimeObject As IPrintable

    If TypeOf m Is IPrintable Then
        ImprimeObject = DirectCast(m, IPrintable)
        ImprimeObject.Print()
    End If
    ...
End Sub

No trecho de código acima, o método aceita um objeto, e, se o mesmo implementar uma interface particular, realiza um operação. Tudo parece certo no código, exceto pelo fato de termos uma redundância. Ao executar o if o compilador vai verificar a expressão TypeOf e se o objeto m implementar a interface IPrintable temos a seguir outra verificação sobre o objeto m do mesmo tipo. Você tem portanto duas verificações de casting no seu código, uma seguida da outra, e isto não é muito bom.

Onde podemos usar o novo operador TryCast para contornar o problema ?

Simples , o TryCast combina as duas verificações em uma única. Usando o operador iremos tentar realizar a conversão e se ela for bem sucedida o valor será retornado para o tipo, se não for possível,l irá retornar Nothing, como já vimos acima. Então podemos fazer assim :

Sub Imprimir(ByVal m As Object)
    Dim ImprimeObject As IPrintable = TryCast(m,IPrintable)

    If ImprimeObject IsNot Nothing Then
        ImprimeObject.Print()
    End If
    ...
End Sub

Nota: baseado em uma comentário de Paul Vick, autor do livro : The Visual Basic .NET Programming Language

5- Sobrecarga de operadores

O Visual Basic 2005 trouxe uma grande novidade :  a sobrecarga de operadores (ninguém mais vai poder falar que só o C# tem.)

Quando falamos em operadores , a primeira coisa que vêm a mente são os operadores para adição (+), subtração (-), divisão (/) e multiplicação (*).

Antes do advento na nova versão do VS.NET você somente podia usar estes operadores com tipos numéricos.

Agora podemos sobrecarregar o operador + , por exemplo, para poder somar outros tipos de dados , além de somar números e concatenar strings.

Para sobrecarregar um operador no Visual Basic 2005, você precisa criar um método especial de operador na sua classe ou estrutura. Esse método deve ser declarado usando as palavras-chave Public Shared Operator, seguidas do símbolo para o operador a ser sobrecarregado.

O método de operador aceita dois parâmetros, estes representam os valores nos dois lados do operador. A ordem pode ser relevante dependendo da classe e do operador.(Lembre-se: a ordem das parcela/fatores não altera a soma/multiplicação, mas, na divisão e subtração isto não é verdade.)

Vamos dar um exemplo prático. Vamos supor que eu desejo sobrecarregar o operador (+) para poder somar objetos de um classe PedidoItem que possui os seguintes propriedades:
Classe PedidoItem Propriedades
  ProdutoID
Quantidade
PrecoUnitario
Total

Eu vou criar um projeto do tipo Windows Application com um formulário e uma classe contendo os métodos acima e o operador + sobrecarregado.

Para sobrecarregar o operador (+) vou criar um método com a seguinte assinatura:

Public Shared Operator +(ByVal Item1 As PedidoItem, ByVal Item2 As PedidoItem) As PedidoItem

Este método esta somando item1 e item2 da classe PedidoItem que será criada em seguida.

Vamos ao código. Abra o VB 2005 e crie um novo projeto chamado sobrecargaOperador.

A seguir inclua uma nova classe via Menu Project opção Add Class. Inclua o seguinte código nesta classe:

 
Public Class PedidoItem

    Private _produtoid As String
    Private _quantidade As Int32
    Private _precounitario As Decimal

    Public Property ProdutoID() As String
        Get
            Return _produtoid
        End Get
        Set(ByVal Value As String)
            _produtoid = Value
        End Set
    End Property

    Public Property Quantidade() As Int32
        Get
            Return _quantidade
        End Get
        Set(ByVal Value As Int32)
            _quantidade = Value
        End Set
    End Property

    Public Property PrecoUnitario() As Decimal
        Get
            Return _precounitario
        End Get
        Set(ByVal Value As Decimal)
            _precounitario = Value
        End Set
    End Property

    Public ReadOnly Property Total() As Decimal
        Get
            Return PrecoUnitario * Quantidade
        End Get
    End Property


    Public Shared Operator +(ByVal Item1 As PedidoItem, ByVal Item2 As PedidoItem) As PedidoItem

        If Item1.ProdutoID <> Item2.ProdutoID Then
            Throw New Exception("Você somente pode somar itens de PedidoItem onde o ProdutoID for o mesmo para ambos os objetos.")
        Else
            Dim item As New PedidoItem
            With item
                .ProdutoID = Item1.ProdutoID
                    .Quantidade = Item1.Quantidade + Item2.Quantidade
                .PrecoUnitario = Item1.PrecoUnitario
            End With
            Return item
        End If
    End Operator
End Class

Perceba que o método Operator +/End Operator esta verificando se o produtoid é o mesmo para ambos os objetos antes de realizar a soma dos objetos. Se forem diferentes será lançada uma exceção, i.e, somente podemos somar itens para o mesmo produto.

Basicamente eu estou somando dois objetos do tipo da classe definida usando o operador + . Para isto eu tive que usar o novo recurso presente no VB.NET 2005.

Nota: Se você não compreende o conceito de sobrecarga leia o artigo: VB .NET - Primeiros passos - Conceitos - VI.

Vamos testar ???

Inclua um botão de comando no formulário padrão form1.vb e no evento click do mesmo inclua o seguinte código:

 
rivate Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click

        'criando instâncias da classe PedidoItem    
        Dim Item1 As New PedidoItem
        Dim Item2 As New PedidoItem
        Dim Item3 As PedidoItem

        'atribuindo valores aos objetos
        With Item1
            .ProdutoID = "10"
            .Quantidade = 5
            .PrecoUnitario = 6
        End With

        With Item2
            .ProdutoID = "10"
            .Quantidade = 4
            .PrecoUnitario = 6
        End With

        'aqui eu estou usando o método com a sobrecarga de operadores e somando 
        'os objetos item do tipo PedidoItem
        Item3 = Item1 + Item2

        'o valor exibido deverá ser igual a 54
        MsgBox(Item3.Total)

    End Sub

Executando o código e clicando no botão de comando teremos o resultado exibido como sendo igual a 54. Embora o exemplo seja simples espero que você tenha entendido o conceito com este exemplo.

Não vai ser todo o dia que você vai precisar usar este recurso da linguagem mas ele já esta presente e pronto para quando a necessidade bater a porta.

6- Instâncias Padrão

Se você conhece o VB5 ou VB6 já conhece o recurso da instância padrão e deve ter percebido que nas primeiras versões do VB.NET para exibir um formulário você tinha que criar uma instância do mesmo. Vejamos uma comparação

VB5 ou VB6 VB.NET 1.0 / VB.NET 1.1
 

                     form2.Show

 

        Dim frm2 as New form2
       frm2.Show

Após muito lamentos, a Microsoft trouxe na nova versão a possibilidade de você poder abrir diretamente o formulário, como se fazia antes. Você continua podendo criar a instância antes de exibir o formulário, mas, pode também usar a instância padrão diretamente ou através da coleção My.Forms.

Usando a instância padrão no VB 2005:

Form2.Show()     ou       My.Forms.Form2.Show()

Até o próximo artigo VB.NET...  

Veja os Destaques e novidades do SUPER DVD Visual Basic (sempre atualizado) : clique e confira !

Quer migrar para o VB .NET ?

Quer aprender C# ??

Quer aprender os conceitos da Programação Orientada a objetos ?

Quer aprender o gerar relatórios com o ReportViewer no VS 2013 ?

  Gostou ?   Compartilhe no Facebook   Compartilhe no Twitter

Referências:

José Carlos Macoratti