Novidades no Visual Basic .NET Whidbey
Este artigo apresenta as evoluções que estão sendo preparadas pela Microsoft para a próxima versão do Visual Basic .NET (codename “Whidbey”), com enfoque nos novos elementos da linguagem: “Generics”, sobrecarga de operadores, tipos “unsigned”, blocos “Using”, e muito mais.
Introdução
As novidades são muitas, e todas ótimas. Tenho certeza de que todos os profissionais que utilizam o Visual Basic .NET e que apostam na tecnologia ficarão satisfeitos, pois constatamos que o VB continua mantendo a sua principal característica de uma linguagem fácil de escrever e entender. Foram agregados recursos poderosos necessários ao desenvolvimento e que, até este momento, faziam parte de outras linguagens, como o C#.
Existem também as novidades relativas à IDE. Segundo a Microsoft, as funcionalidades adicionadas à IDE proporcionaram um aumento de 60% na produtividade. São funcionalidades como o retorno do “Edit & Continue”, que representou uma grande “choradeira” na comunidade quando o VB.Net foi lançado. É claro que ainda é cedo, e certamente haverá mudanças até o lançamento final, porém teremos a oportunidade de ver um pouco antes o que virá e, com isso, planejar melhor nosso futuro com relação à adoção dessa ou daquela ferramenta ou tecnologia.
Generics
Os generics são uma importante inovação, não apenas do Visual Basic .Net como também do .Net Framework, e podem ser usados no Visual C++ e no Visual C#. Em uma definição simplista, os Generics consistem em uma forma com a qual podemos declarar e definir qualquer objeto (classes, estruturas, interfaces, métodos e delegações) com um tipo não especificado. O tipo a ser utilizado será definido no momento da utilização do objeto desejado e será inserido pelo compilador.
Devemos utilizar Generics quando:
- Buscamos maior performance na implementação de coleções, pois não teremos a perda ocorrida pelas operações de “Boxing” / “Unboxing” e “casts” causada pelo fato de utilizarmos o tipo Object nas implementações de coleções para armazenar nossos objetos. Essa foi uma das principais razões para incluir os Generics no .NET Framework;
- Queremos trabalhar com tipos seguros (“type safety”), pois com os “generics” o compilador realiza a verificação dos tipos em tempo de compilação, e não em tempo de execução (o que ocorreria se usássemos o tipo Object);
- Queremos reutilizar nosso código, pois “generics” promovem de forma eficiente a reutilização de código, já que não existe a dependência explícita de um tipo;
- Desejamos algoritimos abstratos, genéricos e independentes de tipos para realizar as operações.
Um detalhe importante sobre os Generics é que seu uso torna o código não “CLS-Compliant”, ou seja, o código escrito passa a não estar de acordo com as especificações existentes no CLS – Common Language Specification, que é o documento que define como deve ocorrer a interoperabilidade entre as linguagens que utilizam o .Net Framework. Desse modo, o código nem sempre será reconhecido por outra linguagem. Para tranqüilizá-los, posso afirmar que não há nenhum problema de integração entre as linguagens incluídas por padrão no Visual Studio .Net. A Listagem 1 mostra um exemplo do uso de Generics, denominados classes de Pessoa e Empresa:
Public Class Pessoa
...
Public ReadOnly Property Id() As Int32
...
End Property
Public Property Nome() As String
...
End Property
...
End Class
Public Class Empresa
...
Public ReadOnly Property Id() As Int32
...
End Property
Public Property NomeFantasia() As String
...
End Property
...
End Class
As classes e interfaces “Generics” são encontradas no namespace System.Collections.Generic. Elas são caracterizadas pelo sufixo “” após seu nome, o qual indica o tipo que será atribuído. Também podemos definir nossos próprios tipos como Generics, utilizando o novo elemento de linguagem “Of” do Visual Basic .Net, que identifica um tipo de dados que servirá como parâmetro numa classe, estrutura, interface, método ou delegação. A Listagem 2 mostra como ele funciona:
Public Class Machine(Of ItemType)
Private _assembler As ItemType
Private _assemblyDate As Date
Public Sub New()
End Sub
Public Property Assembler() As ItemType
Get
Return Me._assembler
End Get
Set(ByVal Value As ItemType)
Me._assembler = Value
End Set
End Property
Public Property AssemblyDate() As Date
Get
Return Me._assemblyDate
End Get
Set(ByVal Value As Date)
Me._assemblyDate = Value
End Set
End Property
End Class
Neste exemplo, temos quatro demostrações do uso de Generics: na definição da Classe – Public Class Machine(Of ItemType), na definição do tipo privado _assembler – Private _assembler as ItemType, na definição da propriedade Assembler – Public Property Assembler() As ItemType, e, por último, na definição do parâmetro do assessor Set da propriedade Assembler – Set(ByVal Value as ItemType). É importante notar que todas as declarações realizadas para o uso de Generics na classe Machine seguem a definição estipulada para a classe, ou seja, utilizam o termo ItemType. Esse termo não é um termo reservado do Visual Basic .Net, mas apenas uma palavra que escolhi para dizer ao compilador que este é o ponto no qual deverão ocorrer as substituições pelo tipo em tempo de compilação. Você pode testar isso alterando-o para qualquer palavra que deseje. Veja na Figura 1 como é realizado o uso da classe genérica:
O que ocorre é que, em tempo de compilação, o compilador do Visual Basic .Net substitui as definições de um determinado tipo (neste exemplo definido pelo termo ItemType) pelo tipo que desejamos que o objeto assuma. Dessa maneira, dispensamos as operações de conversão ou “boxing/unboxing” para os tipos utilizados e, assim, ganhamos em performance. Este conceito ficará mais claro no próximo exemplo.
Na Figura 2, implementamos a classe System.Collections.Generic.Dictionary, na qual podemos verificar claramente como o compilador do Visual Basic .Net trabalha:
Note que, uma vez definido o tipo para a classe System.Collections.Generics.Dictionary como “Pessoa”, quando tentamos passá-lo para um tipo String recebemos um erro de compilação que informa que a conversão não é possível.
Sobrecarga de Operadores
A possibilidade dar uma nova versão aos operadores existentes havia sido negada aos desenvolvedores nas duas primeiras versões do Visual Basic .Net. Porém, na sua 3ª versão, este recurso estará finalmente disponível. Ele é representado pelo novo elemento de linguagem “Operator”, que serve para declarações de símbolo de operador, operandos e todo o código necessário para implementar um procedimento de operação em classes ou estruturas. A Listagem 3 apresenta a declaração da sobrecarga do operador “+” para uma classe chamada “Class1”:
Public Shared Operator +(ByVal a As Class1, ByVal b As Class1) As Class1
...
End Operator
Podemos realizar a sobrecarga dos seguintes tipos de operadores:
- Unários - os operadores +, -, IsTrue, IsFalse e Not;
- Binários – os operadores +, -, *, /, \, &, ^, >>, <<, =, <>, >, >=, <, <=, And, Like, Mod, Or e Xor. O operador “=” listado destina-se a operações de comparação, e não de atribuição;
- Conversões – o operador CType (neste caso por meio dos elementos de linguagem Narrowing ou Widening, também novos no VB.Net Whidbey). Conversões Narrowing são aquelas onde podem ocorrer perdas de informações durante uma conversão (por exemplo, de um tipo Int64 para um Int32). Conversões Widening são exatamente o contrário.
A Listagem 4 apresenta a classe “Fracao” e é um exemplo de uso de sobrecarga de operadores:
Public Class Fracao
Private _numerador, _denominador As Int32
Public Sub New(ByVal numerador As Int32, ByVal denominador As Int32)
With Me
._numerador = numerador
._denominador = denominador
End With
End Sub
Public Sub New(ByVal numero As Int32)
With Me
._numerador = numero
._denominador = 1
End With
End Sub
Public Shared Operator +(ByVal a As Fracao, ByVal b As Fracao) As Fracao
Console.WriteLine("No operador +")
If (a._denominador = b._denominador) Then
Return New Fracao((a._numerador + b._numerador), a._denominador)
End If
'Solução simples para frações diferentes
'1/2 + 3/4 == (1*4) + (3*2) == 10/8
Dim prod1 As Int32 = (a._numerador * b._denominador)
Dim prod2 As Int32 = (b._numerador * a._denominador)
Return New Fracao((prod1 + prod2), (a._denominador + b._denominador))
End Operator
Public Shared Operator =(ByVal a As Fracao, ByVal b As Fracao) As Boolean
Console.WriteLine("No operador =")
If ((a._denominador = b._denominador) And (a._numerador = b._numerador)) Then
Return True
End If
Return False
End Operator
Public Shared Operator <>(ByVal a As Fracao, ByVal b As Fracao) As Boolean
Console.WriteLine("No operador <>")
Return Not (a = b)
End Operator
Public Overrides Function ToString() As String
Dim s As String = Me._numerador.ToString + "/" + Me._denominador.ToString
Return s
End Function
End Class
Veja na Figura 3 o código utilizado para executar a classe Fracao e o seu resultado:
Novos operadores
Não podemos nunca nos esquecer de que o Visual Basic é uma linguagem voltada, principalmente, para a produtividade do desenvolvedor. Conseqüentemente, temos 3 novos operadores: IsTrue, IsFalse e IsNot.
O operador IsTrue determina se uma expressão é verdadeira, e o operador IsFalse avalia exatamente o contrário. O detalhe é que não podemos utilizar esses operadores diretamente no nosso código. Eles só podem ser utilizados pelo compilador do VB.Net a partir do uso da cláusula OrElse. No entanto, podemos sobrescrevê-lo, conforme visto no tópico Sobrecarga de Operadores.
Já o operador IsNot é utilizado para comparar duas variáveis de objeto e verificar se as elas se referem a diferentes objetos (retornando um valor booleano – True se não se referirem). Veja na Listagem 5 o uso do novo operador:
'Forma antiga
If Not (f1 Is f2) Then Console.WriteLine("- Referências diferentes.")
'Forma nova
If (f1 IsNot f2) Then Console.WriteLine("- Referências diferentes.")
Dim f3 As Fracao = f1
If (f1 IsNot f3) Then
Console.WriteLine("- Referências diferentes.")
Else
Console.WriteLine("- Referências iguais.")
End If
O resultado que teremos para a execução das linhas acima é:
- Referências diferentes.
- Referências diferentes.
- Referências iguais.
Nas duas primeiras linhas, as referências são diferentes porque os objetos f1 e f2 são duas instâncias distintas da classe Fracao (veja o tópico Sobrecarga de Operadores). Na terceira linha, a referência é igual porque f3 recebe uma referência da classe f1.
Expansão de classes e estruturas
Muitas vezes nos deparamos com a necessidade de expandir um objeto sem que necessariamente utilizemos o recurso de herança. O novo termo reservado Partial do Visual Basic .Net Whidbey foi criado justamente para fechar esta lacuna. Esse termo indica que a classe ou estrutura que o contém está expandindo uma declaração de classe ou estrutura principal já existente. Veja na Listagem 6 a expansão da classe “Pessoa”:
Partial Class Pessoa
Private _dataDeNascimento As Date
Public Property DataDeNascimento() As Date
Get
Return Me_dataDeNascimento
End Get
Set(ByVal Value As Date)
Me._dataDeNascimento = Value
End Set
Public Overrides Function ToString() As String
Return "Pessoa.Extends"
End Function
End Class
Note que não temos uma definição de visibilidade para o módulo expandido, e nem poderemos fazê-lo, já que ele assume o definido anteriormente para a classe ou estrutura principal. Existe um outro ponto muito importante: a classe ou estrutura que contém o termo Partial precisa estar no mesmo namespace que a classe ou estrutura principal (pode inclusive estar em arquivos diferentes), mas todos devem estar no mesmo projeto. A Figura 4 mostra a classe Pessoa antes e depois de ter sido expandida:
Novos tipos de dados
O Visual Basic .Net contará com os seguintes tipos de dados numéricos:
-
Tipos de dados “signed” (valores que podem ser negativos ou positivos):
- SByte – armazena 1 byte, com um range de valores que vai de -128 até 127. Até então tínhamos apenas o tipo Byte, que tinha um range de 0 até 255.
-
Tipos de dados “unsigned” (valores somente positivos):
- UShort – armazena 2 bytes, com um range de valores que vai de 0 até 65.535. É a versão unsigned para o tipo Short (antigo Integer no VB6), e representa o tipo System.UInt16;
- UInteger – armazena 4 bytes, com um range de valores que vai de 0 até 4.294.967.295. É a versão unsigned para o tipo Integer (antigo Long no VB6) e representa o tipo System.UInt32;
- ULong - armazena 8 bytes, com um range de valores que vai de 0 até 18.446.744.073.709.551.615 (1.8...E+19). É a versão unsigned para o tipo Long e representa o tipo System.UInt64;
É necessário tomar cuidado, pois os novos tipos de dados não são “CLS-Compliant”.
Sentença Using
Para aqueles que conhecem o termo reservado “using” do C#, posso resumir: “É isso mesmo. É a mesma sentença que tanto queríamos ver no VB”. Quando utilizamos o “Using”, permitimos que o sistema, e aí entenda-se Garbage Collector, remova automaticamente as variáveis e suas referências do sistema. Isso é possível, pois o método Dispose do objeto é automaticamente chamado (logo, o objeto necessita ter o método Dispose implementado).
A Listagem 7 nos permite verificar que a implementação da senteça Using do Visual Basic .Net é composta de 3 partes principais: a aquisição do recurso, representado por uma lista dos recursos que serão gerenciados (se definirmos mais de um, usamos a vírgula como separador); o uso, representado pelas sentenças de uso do objeto definido anteriormente; e a liberação, representada pela sentença “End Using” (que define o fechamento e a liberação dos recursos alocados). No caso da Listagem 7, se acompanharmos a execução do código (observando a propriedade State do objeto cn (SqlConnection) através da janela “Watch”), veremos que assim que a execução sair do bloco Using será fechada, independentemente de termos fechado a conexão explicitamente no código.
Using cn As New SqlClient.SqlConnection( _
"server=(local);database=Northwind;trusted_connection=true")
With cn
.Open()
If (.State = ConnectionState.Open) Then _
Console.WriteLine("Conexão aberta!")
End With
End Using
Para finalizar, é importante lembrar que o uso dos recursos está limitado ao Bloco Using. A IDE do Visual Basic .Net apresentará um erro de compilação se tentarmos utilizá-los fora do bloco.
Sentença Continue
A sentença Continue foi projetada para permitir que, em situações em que tenhamos vários “loops” aninhados, possamos transferir o controle de um loop mais interno para outro mais externo, em sua próxima repetição. Esse procedimento é diferente do simples uso da sentença “exit”, que nos levaria para a linha seguinte do loop externo. Veja na Listagem 8 a implementação da sentença Continue, inserida no contexto de um loop tipo For, que por sua vez está aninhado dentro de um loop tipo While.
Dim linha, coluna As Integer
Dim ultimaLinha As Integer = 6
Dim ultimaColuna As Integer = 3
Dim a(,) As Double = New Double(ultimaLinha, ultimaColuna) {}
Dim b(7) As Double
linha = -1
While linha < ultimaLinha
linha += 1
coluna = -1
While coluna < ultimaColuna
coluna += 1
a(linha, coluna) = 0
For i As Integer = 0 To b.GetUpperBound(0)
If b(i) = coluna Then
Console.WriteLine("Valor de col no continue: {0}", coluna)
Continue While 'Com esta sentença, o controle retorna para a linha While coluna
'Exit For 'Com esta sentença, o controle segue para a linha seguinte a Next i
Else
Console.WriteLine("Valor de col no For: {0}", coluna)
a(linha, coluna) += (linha + b(i)) / (coluna - b(i))
End If
Next i
Console.WriteLine("Valor de col no While, após o continue ou não: {0}", coluna)
End While
End While
Caso realizemos aninhamento de loops iguais (For dentro For) e desejarmos transferir o controle do For interno para o externo, não conseguiremos transferir o controle. Da mesma forma, não poderemos colocar a sentença Continue dentro de blocos Try e Finally – mas poderemos colocar dentro dos blocos catch. A Listagem 9 mostra o certo e o errado:
...
While coluna < ultimaColuna
coluna += 1
a(linha, coluna) = 0
For i As Integer = 0 To b.GetUpperBound(0)
If b(i) = coluna Then
Console.WriteLine("Valor de col no continue: {0}", coluna)
Try
'Faz alguma coisa...
Continue While 'ERRADO!!!
Catch ex As Exception
'Faz alguma coisa...
Continue While 'CERTO!!!
Finally
'Faz alguma coisa...
Continue While 'ERRADO!!!
End Try
...
Next i
Console.WriteLine("Valor de col no While, após o continue ou não: {0}", coluna)
...
End While
...
Edit and Continue
Desde o lançamento do Visual Studio .NET, os desenvolvedores VB se ressentem da perda do antigo “Edit & Continue”, fornecido no Visual Basic 6 e que lhes proporcionava enorme produtividade. Desde então, vêm pedindo muito à Microsoft a volta dessa funcionalidade. Poucos têm noção de que essa volta não era tão simples assim, pois se antes o VB era uma ferramenta isolada, agora ele faz parte de um ambiente integrado, compartilhado por todas as linguagens que usam o Visual Studio .Net.
Por esse motivo, foram necessárias duas versões do Visual Studio até que pudéssemos voltar a fazer uso dessa funcionalidade, agora totalmente restaurada no Whidbey (veja a Figura 5).
Insert Snippets
Snippets são fragmentos de código. A nova funcionalidade “Insert snippets”, ativada quando acionamos o menu de contexto (pop-up menu) na janela de codificação do Visual Studio, tem por objetivo fornecer ao desenvolvedor fragmentos de código para mais de 500 atividades rotineiras da programação. São blocos de código para manipulação de strings, trabalho com arquivos ou com o registry ou ainda com controles adicionados em Windows Forms. O melhor dessa funcionalidade é que, além da grande quantidade de código que acompanhará o produto, ainda teremos a possibilidade de criar ou modificar os códigos existentes e de compartilhar nossos “snippets”, podendo armazená-los tanto localmente quanto na rede.
Exception Handler
O tratamento de erros vem apresentado grandes melhorias, sempre buscando aumentar a produtividade do desenvolvedor.
Error Correction: se analisarmos a Figura 6, notaremos como o Visual Basic .Net age: ele identifica o código escrito com erros e sugere a solução correta. No entanto, a funcionalidade ainda precisa de alguns ajustes. Se analisarmos o código proposto para a correção do problema existente, veremos que este “fix” não é completo, pois não sugere o valor inicial para a nossa variável no loop. Mas a idéia da funcionalidade é abreviar nossas preocupações com relação àqueles erros banais que cometemos na codificação e que nos tomam tempo e, além disso, não podemos nos esquecer de que esta é a versão Alpha, e ainda há muito tempo até o lançamento do produto.
Exception Assistant: a Figura 7 apresenta outra e oportuna novidade da IDE do Visual Basic .Net: o Exception Assistant. Para compreendermos o que ele significa, devemos ter em mente o que acontece em tempo de depuração de código em desenvolvimento quando ocorre uma exceção não-tratada: a execução pára e o Visual Basic apresenta uma mensagem sobre o erro ocorrido, dando-nos as opções de fazer uma pausa (Break) ou continuar (Continue) a execução do código. Com esta nova funcionalidade, a IDE do Visual Basic .Net apresenta um “balão” com uma descrição clara do erro, onde ele ocorreu, como resolvê-lo e dicas para tratá-lo, tudo com links para o Help do Visual Studio. Para ficar perfeito, só precisa inserir o erro, o que ele ainda não faz. Mas com o retorno do Edit & Continue, poderemos facilmente solucionar o problema.
Smart Tags: a Figura 8 mostra a funcionalidade Smart Tag da IDE do Visual Basic .Net oferecendo sugestões de correção para um tipo digitado errado. As sugestões que serão tratadas pelas Smart Tags são: verificação de tipos escritos de forma errada, não-inclusão de uma referência para um assembly necessário e tentativa de sobrecarregar um método com uma assinatura incorreta. O compilador também advertirá o desenvolvedor sobre codificações com erro de semântica que poderão causar erros de execução na aplicação, como, por exemplo, códigos que acessam elementos sem inicialização.
XML Comments
Uma funcionalidade muito aguardada pelos desenvolvedores do Visual Basic (e que já havia no C#) consistia na possibilidade de gerar documentação XML na codificação do Visual Basic .Net. Diferentemente do que acontece no C#, onde é acrescentada mais uma “\” às barras necessárias para o comentário normal (“\\”), o time do Visual Basic optou por um caminho diferente e adotou o símbolo “'''” (três apóstrofes) para a geração de comentário XML. A Listagem 10 apresenta a inserção de comentários XML num snippet de código:
'''
''' Realiza a leitura de arquivos tipo '.txt'.
'''
''' O local onde o arquivo está armazenado.
''' Este método realiza a leitura de arquivos tipo "txt" e
''' apresenta seus dados no console da aplicação. Caso o arquivo aberto não seja do tipo permitido,
''' uma exceção do tipo ArgumentException será retornada.
Private Sub ReadTxtFiles(ByVal path As String)
'Aqui temos a codificação do método
End Sub
Melhorias no desenvolvimento de aplicações cliente Windows
O desenvolvimento de aplicações Windows foi reforçado sobremaneira no Whidbey, com destaque para o acesso às fontes de dados, a produtividade em geral e a instalação das aplicações, além de performance e segurança. A toolbox oferece novos controles: SplitContainer, WinBarDropDown, ActiveDocumentHost, PropertyGrid, WebBrowser, RichTextBox, Sound, entre outros. Esses controles respondem a inúmeros pedidos da comunidade. Por exemplo, o controle WebBrowser permite abrir páginas Web ou outros documentos baseados na Web de dentro de formulários Windows. Esse controle já inclui entre suas propriedades e métodos aqueles inerentes aos navegadores Web.
Outro recurso interessante é a possibilidade de editar as propriedades dos controles durante o design do Windows Form (Figura 9), dispensado o uso da janela Properties. A IDE também o auxiliará em atividades corriqueiras como alinhamento de grupos de controles, tracejando linhas (snap lines) como referência. É possível, a qualquer momento, criar um array de um determinado controle adicionado ao formulário. Para isso, basta clicar com o botão direito do mouse no controle e nas opções disponibilizadas no menu de contexto e selecionar Create New ControlArray. No ambiente de design, temos as Smart Tags, que neste contexto tem por finalidade facilitar a customização dos controles para ações corriqueiras, como as que envolvem “look and feel” e conexão com dados. Outra funcionalidade é a Data Preview, que permitirá ao desenvolvedor verificar ainda em tempo de design como ficará um determinado controle populado com os dados de uma base de informações.
Por fim, uma das novidades mais aguardadas no Whidbey chama-se ClickOnce. Trata-se de uma nova tecnologia para o deployment de aplicações, voltada para a estratégia de deployment “No-Touch” (Sem toque). Em suma, faremos o deployment de aplicações Windows através da Web, de forma fácil e segura. O ClickOnce permitirá que as aplicações Windows Client possam ser publicadas, instaladas e atendidas sem a preocupação com a quebra das funcionalidades existentes no sistema operacional. Funcionará através da publicação da instalação com capacidade para executar aplicações offline, rollback de versões anteriores, listagem da aplicação no menu Iniciar e catálogo de remoção de programas existentes no Painel de Controle do Windows.
Conclusão
As novas implementações do Visual Basic .NET reforçam o comprometimento da Microsoft com a produtividade e com os recursos necessários para que os desenvolvedores escrevam soluções mais robustas. A versão Whidbey do Visual Studio .Net tem como principal característica a integração com o SQL Server Yukon. Outros destaques encontrados nesta edição, são as melhorias realizadas no .Net Framework, no ADO.Net e no ASP.Net.
