O que há de novo no Visual Basic 2010

Desde o nascimento da linguagem Visual Basic em 1991, ela tem sido uma ferramenta altamente eficiente para a construção de aplicativos. Quase 20 anos depois, ele continua a oferecer fácil integração com o Microsoft .NET Framework, permitindo que os desenvolvedores escrevam aplicativos que abrangem desktops, telefones, navegadores e até mesmo a nuvem.

A Microsoft lançará o Visual Studio 2010 este mês, que inclui o Visual Basic versão 10 (às vezes chamado de VB 2010 ou VB10). Esta versão é a mais poderosa até agora e inclui muitos recursos que economizam tempo para ajudar os desenvolvedores a fazer mais com menos linhas de código. Aqui, você receberá todo o conteúdo necessário para compreender e aproveitar totalmente o Visual Basic no Visual Studio 2010.

coevolução

No passado, Visual Basic e C# eram desenvolvidos por equipes separadas, o que muitas vezes resultava em recursos aparecendo primeiro em uma linguagem e depois em outra. Por exemplo, o C# possui propriedades autoimplementadas e inicializadores de coleção que não estão disponíveis no Visual Basic, e o Visual Basic possui recursos como ligação tardia e parâmetros opcionais que não estão disponíveis no C#. Mas sempre que um idioma recebe um novo recurso, muitos clientes solicitam que esse recurso também seja adicionado ao outro idioma.

Para atender a essa necessidade, a Microsoft fundiu as equipes de Visual Basic e C# para implementar uma estratégia de coevolução. O objetivo é promover o desenvolvimento comum dessas línguas. Quando um recurso importante é introduzido em um idioma, ele também aparece no outro idioma. Isso não quer dizer que todos os recursos estarão presentes nos dois idiomas e funcionarão exatamente da mesma maneira; na verdade, cada idioma tem sua própria história, alma e sentimento – e é importante preservar essas características;

No .NET Framework 4, o Visual Basic e o C# deram um grande passo em direção a esse objetivo, cada um absorvendo muitos dos recursos existentes do outro. No entanto, a co-evolução não afecta apenas a funcionalidade anterior; é também uma estratégia para o desenvolvimento futuro destas linguagens. Com esse espírito, o .NET Framework 4 introduz novos recursos poderosos em ambas as linguagens, como o tempo de execução de linguagem dinâmica, tipos de interoperabilidade incorporados e variação genérica, permitindo que os desenvolvedores de Visual Basic e C# aproveitem ao máximo o .NET Framework.

O que há de novo no Visual Basic 2010

Os novos recursos do Visual Basic 2010 foram projetados para ajudá-lo a fazer mais com menos linhas de código. Nossa equipe de design do Visual Basic examinou atentamente os locais onde os desenvolvedores normalmente precisam escrever muitos códigos padronizados e tediosos e encontrou maneiras de deixar o compilador fazer o trabalho. Claro, esta é uma visão geral, agora vamos dar uma olhada mais profunda em cada recurso.

Caractere implícito de continuação de linha

Visual Basic é uma linguagem orientada a linhas que usa uma sintaxe clara semelhante ao inglês para melhorar a legibilidade. Mas isso geralmente faz com que o código atinja o limite de 80 caracteres por linha, forçando os desenvolvedores a rolar bastante. Você pode usar o caractere sublinhado para informar ao compilador que o processamento da próxima linha deve continuar como a linha atual (ou seja, para tratar múltiplas linhas físicas como uma única linha lógica). Mas ter que digitar o caractere de sublinhado repetidamente tem sido irritante e, na verdade, uma das principais solicitações de recursos durante anos foi fazer com que o compilador corrigisse esse problema.

No Visual Basic 2010, o compilador pode resolver esse problema. O compilador agora sabe quais tokens (como vírgulas, parênteses e operadores) tendem a aparecer antes dos caracteres de continuação de linha e insere caracteres para que os desenvolvedores não precisem mais inserir caracteres. Por exemplo, certamente não é lógico terminar uma instrução Visual Basic com uma vírgula, o compilador sabe disso, portanto, quando o compilador vê um fluxo de tokens como {vírgula, enter}, ele infere a presença de um caractere de continuação de linha, conforme mostrado na Figura O exemplo em 1 é mostrado.

Figura 1 Inferir caracteres de continuação de linha

<Extension()>

Função FilterByCountry(

Clientes ByVal como IEnumerable (Of Customer),

ByVal país As String) As IEnumerable(Of Customer)

Consulta escura =

De c Em clientes

Onde c.Country = país

Selecione <Cliente>

<%=

c.Nome e

, &

c.País

%>

</Cliente>

Consulta de retorno

Função final

No Visual Basic 2008, o código da Figura 1 exigiria nove caracteres de sublinhado. Entretanto, em cada um dos casos a seguir, o compilador infere quando o caractere de sublinhado é necessário e permite que ele seja ignorado:

Após o atributo <Extension()>

depois ((parêntese esquerdo) na declaração do método

após o , (vírgula) do primeiro parâmetro

antes) (parêntese direito) na declaração do método

depois = (sinal de igual)

depois de <%= (a tag de abertura de uma expressão incorporada)

Após cada e comercial (e comercial) em texto XML

antes de %> (tag final da expressão incorporada)

Este novo recurso do compilador é particularmente útil para assinaturas de métodos, que também funcionarão bem com mais de 80 caracteres no exemplo mostrado (se cada parte estiver na mesma linha). Na Figura 2, você verá todas as combinações de tags e posições para as quais os caracteres de continuação de linha estão implícitos.

Figura 2 Quando o caractere de continuação de linha está implícito

Como você pode ver, existem mais de 60 lugares no idioma onde o caractere de sublinhado não é obrigatório. (Na verdade, nenhum dos exemplos de código neste artigo exige caracteres de continuação de linha.) É claro que você ainda pode usar o caractere de sublinhado, portanto, o código de versões anteriores do Visual Basic ainda será compilado conforme o esperado.

DeclaraçãoLambda

O termo lambda pode parecer assustador à primeira vista, mas lambda é apenas uma função definida dentro de outra função. O Visual Basic 2008 introduziu expressões lambda com a palavra-chave Function:

Dim customers As Customer() = ...

Array.FindAll(clientes, Função(c) c.Country = Canadá)

As expressões lambda permitem expressar a lógica localmente de maneira granular e compacta, sem precisar dividi-la em vários métodos. Por exemplo, aqui está a representação do código anterior no Visual Basic 2005 (que não oferece suporte a expressões lambda):

Dim query = Array.FindAll(customers, AddressOf Filter)

...

Filtro de função (ByVal c como cliente) como booleano

Retornar c.País = Canadá

Função final

Infelizmente, as expressões lambda do Visual Basic 2008 exigem que a expressão retorne um valor, portanto o código a seguir:

Array.ForEach(customers, Function(c) Console.WriteLine(c.Country))

Levará à seguinte situação:

'Compile error: Expression does not produce a value.

Console.WriteLine é um procedimento Sub (void em C#), portanto não retorna um valor, por isso o compilador gera um erro. Para lidar com essa situação, o Visual Basic 2010 introduziu suporte para lambdas de instrução, que são lambdas que contêm uma ou mais instruções:

Array.ForEach(customers, Sub(c) Console.WriteLine(c.Country))

Como Console.WriteLine não retorna um valor, podemos simplesmente criar um Sub lambda em vez de um Function lambda. Aqui está outro exemplo usando múltiplas instruções:

Array.ForEach(customers, Sub(c)

Console.WriteLine(Nome do país:)

Console.WriteLine(c.País)

Fim Sub)

Quando esse código é executado, ele imprime duas linhas para cada cliente. Observe também que se você passar o mouse sobre c durante a codificação, verá que o compilador inferirá o tipo como Customer (também é legal digitar c As Customer para declarar explicitamente o tipo). Escrever manipuladores de eventos dinamicamente é outro ótimo uso de lambdas de instrução:

AddHandler b.Click, Sub(sender As Object, e As EventArgs)

MsgBox (botão clicado)

'insira uma lógica mais complexa aqui

Finalizar sub

E, de fato, você pode usar lambdas de instrução com um recurso introduzido no Visual Basic 2008: delegação flexível. (Você pode usar delegados – ponteiros de função com segurança de tipo – para executar múltiplas funções ao mesmo tempo.) Essa combinação resulta em uma assinatura muito mais simples:

AddHandler b.Click, Sub()

MsgBox (botão clicado)

'insira uma lógica mais complexa aqui

Finalizar sub

A frouxidão da delegação permite que você ignore completamente os parâmetros nos manipuladores de eventos – esta é uma boa vantagem, desde que eles não sejam usados, portanto, sejam apenas visualmente intrusivos.

Além dos Sub lambdas de linha única e Sub lambdas de múltiplas linhas que vimos até agora, o Visual Basic 2010 também oferece suporte a lambdas de funções multilinhas:

Dim query = customers.Where(Function(c)

'Retornar apenas clientes que não foram salvos

'insira uma lógica mais complexa aqui

Retornar c.ID = -1

Função final)

Outro aspecto interessante das declarações lambdas é como elas se cruzam com os delegados anônimos introduzidos no Visual Basic 2008. As pessoas muitas vezes confundem esses delegados com os métodos anônimos do C#, embora eles não sejam estritamente iguais. A delegação anônima ocorre quando o compilador do Visual Basic infere o tipo de delegado com base na assinatura do método lambda:

Dim method = Function(product As String)

Se produto = Papel Então

Devolver unidades de 4,5' em estoque

Outro

Devolva 10'10 de todo o resto

Terminar se

Função final

MsgBox(método(Papel))

Se você executar este código, verá o valor 4,5 exibido na caixa de mensagem. Além disso, se você passar o mouse sobre o método, verá o texto Dim method As <Function(String) As Double>. Como não fornecemos um tipo de delegado real, o compilador irá gerar um automaticamente da seguinte forma:

Delegate Function $compilerGeneratedName$(product As String) As Double

Isso é chamado de delegado anônimo porque só aparecerá no código gerado pelo compilador, e não no código escrito. Observe que quando na verdade nenhuma cláusula As é fornecida para especificar o tipo de retorno do lambda, o compilador infere o tipo de retorno para Double. O compilador examinará todas as instruções de retorno dentro do lambda e determinará os tipos Double (4.5) e Integer (10):

'Notice the As Single

Método Dim = Função (produto como string) como único

Se produto = Papel Então

Devolver unidades de 4,5' em estoque

Outro

Devolva 10'10 de todo o resto

Terminar se

Função final

Em seguida, ele executa seu algoritmo de tipo de linha de base e determina que pode converter com segurança 10 em Double, mas não pode converter com segurança 4,5 em Integer, portanto, Double é a melhor escolha;

Você também pode controlar explicitamente o tipo de retorno; nesse caso, o compilador não tentará inferir o tipo. É muito comum atribuir o lambda a uma variável com um tipo delegado explícito, em vez de confiar no compilador para inferir o tipo delegado:

Dim method As Func(Of String, Single) =

Função (produto)

Se produto = Papel Então

Devolver unidades de 4,5' em estoque

Outro

Devolva 10'10 de todo o resto

Terminar se

Função final

Como um tipo de destino explícito é fornecido, não há necessidade de declarar As String ou As Single, o compilador pode inferir sua existência com base no tipo delegado no lado esquerdo da instrução. Portanto, se você passar o mouse sobre o produto, verá que o tipo inferido é String. Você não precisa mais especificar As Single porque o tipo de delegado já fornece essas informações. No exemplo anterior, a assinatura do delegado Func (incluído no .NET Framework) é semelhante a esta:

Delegate Function Func(Of T, R)(ByVal param As T) As R

Há uma pequena exceção, como veremos mais adiante na seção sobre Variância Genérica.

Propriedades implementadas automaticamente

No Visual Basic, as propriedades são membros de classe que expõem o estado de um objeto ao mundo externo. Uma declaração de propriedade típica é semelhante a esta:

Private _Country As String

País da propriedade como string

Pegar

País_de_retorno

Fim

Definir (valor ByVal como string)

_País = valor

Conjunto final

Fim da propriedade

Na verdade, um conceito muito simples com 10 linhas de código. Como um objeto típico geralmente possui dezenas de propriedades, você acaba incluindo muito código clichê na definição de sua classe. Para simplificar essas tarefas, o Visual Basic 2010 introduz propriedades autoimplementadas, que permitem definir propriedades simples com apenas uma linha de código:

Property Country As String

Nesse caso, o compilador continuará a ser executado e gerará automaticamente getters, setters e campos de suporte. O nome de um campo suportado é sempre o nome de um atributo precedido por um caractere de sublinhado: _Country neste exemplo. Esta convenção de nomenclatura garante compatibilidade de serialização binária ao alterar propriedades implementadas automaticamente para propriedades regulares. A serialização binária continuará funcionando enquanto os nomes dos campos de suporte forem os mesmos.

Uma das coisas legais que você pode fazer com propriedades implementadas automaticamente é especificar um inicializador que defina o valor padrão da propriedade quando o construtor for executado. Por exemplo, um cenário comum com classes de entidade define a chave primária com um valor como -1 para indicar que ela está em um estado não salvo. O código ficará assim:

Property ID As Integer = -1

Quando o construtor é executado, o campo de apoio (_ID) é automaticamente definido com o valor -1. A sintaxe do inicializador também funciona para tipos de referência:

Property OrderList As List(Of Order) = New List(Of Order)

Como você não precisa digitar o nome do tipo duas vezes, a linha de código anterior pode não ter características muito óbvias do Visual Basic. A boa notícia é que existe uma sintaxe mais curta para declarações de variáveis ​​regulares que é consistente com a sintaxe permitida pelo Visual Basic:

Property OrderList As New List(Of Order)

Você pode até usar esta sintaxe com um inicializador de objeto para permitir que outras propriedades sejam definidas:

Property OrderList As New List(Of Order) With {.Capacity = 100}

Obviamente, para propriedades mais complexas, uma sintaxe estendida ainda é necessária. Você ainda pode digitar Property{Tab} para ativar o fragmento de propriedade antigo. Alternativamente, após digitar a primeira linha da propriedade, você pode simplesmente inserir Get{Enter} e o IDE irá gerar a propriedade no estilo antigo:

Property Name As String

Pegar

Fim

Definir (valor ByVal como string)

Conjunto final

Fim da propriedade

Geralmente descobrimos: a nova sintaxe da propriedade é quase idêntica à dos campos públicos, então por que não usar campos públicos? Existem vários motivos:

A maior parte da infraestrutura de vinculação de dados do .NET funciona em termos de propriedades e não de campos.

Uma interface não pode impor a presença de um campo; ela pode impor a presença de um atributo;

As propriedades fornecem flexibilidade de longo prazo para alterar regras de negócios. Por exemplo, suponha que alguém introduza uma regra segundo a qual os números de telefone devem ter 10 dígitos. Esta validação não pode ser realizada se atribuída a um campo público. Alterar campos públicos para propriedades é uma mudança significativa para cenários como serialização e reflexão binária.

Inicializador de coleção

Uma prática comum do .NET é instanciar uma coleção e, em seguida, preenchê-la chamando o método Add uma vez para cada elemento:

Dim digits As New List(Of Integer)

dígitos.Adicionar(0)

dígitos.Adicionar(1)

dígitos.Adicionar(2)

dígitos.Adicionar(3)

dígitos.Adicionar(4)

dígitos.Adicionar(5)

dígitos. Adicionar (6)

dígitos.Adicionar(7)

dígitos.Adicionar(8)

dígitos.Adicionar(9)

Mas para um conceito fundamentalmente simples, há muita sobrecarga sintática. O Visual Basic 2010 introduziu inicializadores de coleção para facilitar a instanciação de coleções. Para este código:

Dim digits = New List(Of Integer) From {1, 2, 3, 4, 5, 6, 7, 8, 9, 0}

O compilador gerará automaticamente todas as chamadas para o método Add. Você também pode usar a funcionalidade de sintaxe As New do Visual Basic:

Dim digits As New List(Of Integer) From {1, 2, 3, 4, 5, 6, 7, 8, 9, 0}

Observe que na equipe do Visual Basic sempre recomendamos usar a segunda sintaxe (As New) em vez da anterior, pois ela torna o código mais resiliente a alterações na configuração de Option Infer.

Você pode usar um inicializador de coleção em qualquer tipo que atenda aos seguintes requisitos:

Você pode iterar sobre o tipo usando uma instrução For Each – ou seja, o tipo implementa IEnumerable. (Para obter uma definição mais precisa/detalhada dos tipos de coleção, consulte a Seção 10.9.3 da Especificação de Linguagem Visual Basic em msdn.microsoft.com/library/aa711986(VS.71).aspx).

O tipo possui um construtor sem parâmetros acessível (mas não necessariamente público).

O tipo possui uma instância acessível (mas não necessariamente pública) ou um método de extensão chamado Add.

Isso significa que você também pode usar inicializadores de coleção para tipos mais complexos, como dicionários:

Dim lookupTable As New Dictionary(Of Integer, String) From

{{1, Um},

{2, Dois},

{3, Três},

{4, Quatro}}

(Observe que mesmo que esta instrução ocupe cinco linhas, não há caracteres de sublinhado.) Nesse caso, o compilador gerará código equivalente à maneira antiga de inicializar um dicionário:

Dim lookupTable As New Dictionary(Of Integer, String)

lookupTable.Add(1, Um)

lookupTable.Add(2, Dois)

lookupTable.Add(3, Três)

lookupTable.Add(4, Quatro)

O compilador está chamando o método Add com dois parâmetros em vez de um. Ele sabe fazer isso porque o valor passado para o inicializador da coleção está entre colchetes aninhados, como este: {{1, One}, {2, Two},…}. Para cada conjunto de chaves aninhadas, o compilador tenta passar esses parâmetros para um método Add compatível.

Também é possível fornecer sua própria implementação Add personalizada usando métodos de extensão:

<Extension()>

Sub Add (fonte ByVal como IList (do cliente),

ByVal id como inteiro,

Nome ByVal como String,

ByVal cidade como String)

source.Add(Novo cliente com

{

.ID = identificação,

.Nome = nome,

.Cidade = cidade

})

Finalizar sub

(Veja todos aqueles caracteres de sublinhado faltando!) Este método estende qualquer tipo que implemente IList(Of Customer), que então permite que você use a nova sintaxe do inicializador de coleção, assim:

Dim list = New List(Of Customer) From

{

{1, Jon, Redmond},

{2, Bob, Seattle},

{3, Sally, Toronto}

}

(Adicione três clientes à lista). Você também pode usar inicializadores de coleção com propriedades implementadas automaticamente:

Property States As New List(Of String) From {AL, AK, AR, AZ, ...}

literal de matriz

Além de maneiras mais poderosas de trabalhar com tipos de coleção, o Visual Basic 2010 também oferece alguns aprimoramentos poderosos para trabalhar com matrizes. Suponha o seguinte código (funciona bem em versões mais antigas):

Dim numbers As Integer() = New Integer() {1, 2, 3, 4, 5}

Observando os elementos nesta matriz, é óbvio que cada elemento é um número inteiro, portanto, ter que imprimir o número inteiro duas vezes nesta linha não adiciona nenhum valor. Literais de array permitem que você crie um array colocando todos os elementos de um array entre chaves e deixando o compilador inferir automaticamente os tipos:

Dim numbers = {1, 2, 3, 4, 5}

O tipo de números não é Object, mas Integer() (desde que Option Infer esteja habilitada), a razão é que o array literal agora representa a si mesmo e tem seu próprio tipo. Vamos supor um exemplo mais complexo:

Dim numbers = {1, 2, 3, 4, 5.555}

Neste caso, o tipo de números será inferido como Double(). O compilador determina o tipo examinando cada elemento na matriz e calculando o tipo base, usando o mesmo algoritmo discutido anteriormente para inferir o tipo de retorno de uma instrução lambda. O que acontece se não houver tipo base? Por exemplo, conforme mostrado no código a seguir:

Dim numbers = {1, 2, 3, 4, 5}

Nesse caso, converter um número inteiro em uma string reduzirá o intervalo de conversão (ou seja, pode ocorrer perda de dados em tempo de execução) e, da mesma forma, converter uma string em um número inteiro também reduzirá o intervalo de conversão. O único tipo seguro para escolher é Object() (o compilador irá gerar um erro se Option Strict estiver habilitada).

Literais de array podem ser aninhados para formar arrays multidimensionais ou arrays irregulares:

'2-dimensional array

Matriz escura = {{1, 0}, {0, 1}}

'matriz irregular - os parênteses forçam a avaliação da matriz interna primeiro

Dim irregular = { ({1, 0}), ({0, 1}) }

tempo de execução de linguagem dinâmica

Embora o Visual Basic seja tecnicamente uma linguagem estática por natureza, ele sempre teve recursos dinâmicos muito poderosos, como ligação tardia. O Visual Studio 2010 vem com uma nova plataforma chamada Dynamic Language Runtime (DLR) que facilita a construção de linguagens dinâmicas – e a comunicação entre elas. O Visual Basic 2010 foi atualizado para oferecer suporte total ao DLR em seus últimos binders, permitindo que os desenvolvedores utilizem bibliotecas e frameworks desenvolvidos em outras linguagens (como IronPython/IronRuby).

Uma das grandes vantagens desse recurso é que sintaticamente nada mudou (na verdade, nem uma única linha de código foi modificada no compilador para suportar esse recurso). Os desenvolvedores ainda podem executar operações de ligação tardia como faziam nas versões anteriores do Visual Basic. O que mudou foi o código no tempo de execução do Visual Basic (Microsoft.VisualBasic.dll), que agora reconhece a interface IDynamicMetaObjectProvider fornecida pelo DLR. Se um objeto implementar essa interface, o tempo de execução do Visual Basic criará um DLR CallSite e permitirá que o objeto e a linguagem que o fornece injetem sua própria semântica na operação.

Por exemplo, a biblioteca padrão do Python contém um arquivo chamado random.py, que possui um método chamado shuffle que pode ser usado para reorganizar aleatoriamente os elementos de um array. Chamar esse método é simples:

Dim python As ScriptRuntime = Python.CreateRuntime()

Dim aleatório As Object = python.UseFile(random.py)

Itens escuros = {1, 2, 3, 4, 5, 6, 7}

random.shuffle(itens)

Em tempo de execução, o Visual Basic vê que o objeto implementa IDynamicMetaObjectProvider e, portanto, passa o controle para o DLR, que então se comunica com o Python e executa o método (passando o array definido no Visual Basic como parâmetro para o método).

Este é um exemplo de chamada de API habilitada para DLR, mas os desenvolvedores também podem criar suas próprias APIs que usam essa funcionalidade. A chave é implementar a interface IDynamicMetaObjectProvider; nesse caso, os compiladores Visual Basic e C# reconhecerão objetos com semântica dinâmica especial. Por favor, não implemente esta interface manualmente, é mais fácil herdar da classe System.Dynamic.DynamicObject (que já implementa esta interface) e substituir apenas alguns métodos. A Figura 3 mostra um exemplo completo de criação de um objeto dinâmico personalizado (um conjunto de propriedades que parece criar propriedades dinamicamente) e do uso da ligação tardia normal do Visual Basic para chamar o objeto. (Para obter mais informações sobre o uso do DynamicObject, leia o excelente artigo de Doug Rothaus em blogs.msdn.com/vbteam/archive/2010/01/20/fun-with-dynamic-objects-doug-rothaus.aspx .)

Figura 3 Crie um objeto dinâmico personalizado e chame o objeto usando ligação tardia do Visual Basic

Imports System.Dynamic

Módulo Módulo1

Subprincipal()

Dim p As Object = Novo PropertyBag

p.Um = 1

p.Dois = 2

p.Três = 3

Console.WriteLine(p.Um)

Console.WriteLine(p.Dois)

Console.WriteLine(p.Três)

Finalizar sub

Classe PropertyBag: herda DynamicObject

Valores privados como novo dicionário (de string, inteiro)

Função de substituição pública TrySetMember(

Fichário ByVal Como SetMemberBinder,

Valor ByVal como objeto) como booleano

valores(fichário.Nome) = valor

Retornar verdadeiro

Função final

Função de substituição pública TryGetMember(

Fichário ByVal Como GetMemberBinder,

Resultado ByRef como objeto) como booleano

Valores de retorno.TryGetValue(binder.Name, resultado)

Função final

Fim da aula

Módulo final

variação genérica

Esta é uma função que pode parecer complexa à primeira vista (com termos como covariância e contravariância), mas na verdade é bastante simples. Se você possui um objeto do tipo IEnumerable(Of Apple) e deseja atribuí-lo a IEnumerable(Of Fruit), isso deve ser legal porque toda Apple é uma Fruit (aplicada por herança). Infelizmente, antes do Visual Basic 2010, a variação genérica não era suportada no compilador, embora na verdade fosse suportada no Common Language Runtime (CLR).

Vejamos o exemplo na Figura 4. No Visual Basic 2008, o código na Figura 4 produzirá um erro de compilação na linha Dim enabledOnly (ou, se Option Strict estiver desabilitado, uma exceção de tempo de execução). A solução alternativa é chamar o método de extensão .Cast da seguinte maneira:

'Old way, the call to Cast(Of Control) is no longer necessary in VB 2010

Dim enabledOnly = FilterEnabledOnly(buttons.Cast(Of Control))

Isso não é mais necessário porque no Visual Basic 2010, a interface IEnumerable foi marcada como covariante usando o modificador Out:

Interface IEnumerable(Of Out T)

...

Interface final

Figura 4 Exemplo de variância genérica

Option Strict On

Formulário de aula pública1

Sub Form1_Load() manipula MyBase.Load

Escurecer botões como nova lista (de botão) de

{

Novo botão com

{

.Nome = btnOk,

.Ativado = Verdadeiro

},

Novo botão com

{

.Nome = btnCancelar,

.Ativado = Falso

}

}

Dim enabledOnly = FilterEnabledOnly(botões)

Finalizar sub

Função FilterEnabledOnly(

Controles ByVal como IEnumerable (de controle)

) Como IEnumerable (de controle)

Retorno dos controles c In

Onde c.Enabled = True

Função final

Fim da aula

Isso significa que o parâmetro genérico T agora é uma variável (ou seja, é adequado para herança), e o compilador garantirá que o parâmetro seja usado apenas onde o tipo vier de uma interface. Os parâmetros genéricos também podem ser variáveis ​​inversas, o que significa que só são usados ​​onde são inseridos. Na verdade, um tipo pode ter ambos. Por exemplo, o delegado Func discutido anteriormente tem parâmetros contravariantes (para o que é passado) e parâmetros covariantes (para o tipo de retorno):

Delegate Function Func(Of In T, Out R)(ByVal param As T) As R

Você pode usar modificadores In e Out em interfaces e delegados personalizados. Muitas interfaces e delegados comuns no .NET Framework 4 são marcados como variáveis; exemplos comuns incluem todos os delegados Action/Func, IEnumerable(Of T), IComparer(Of T), IQueryable(Of T), etc.

A grande vantagem da variação genérica é que ela é um recurso com o qual você não precisa se preocupar - se estiver fazendo seu trabalho, você nunca notará. Situações que antes resultavam em erros do compilador ou exigiam a chamada de .Cast(Of T) funcionam bem no Visual Basic 2010.

Parâmetros opcionais aprimorados

Parâmetros opcionais fornecem um recurso de eficiência útil que permite aos desenvolvedores construir métodos mais flexíveis e evitar sobrecarregar uma classe com muitas sobrecargas de métodos. No passado havia uma pequena restrição de que parâmetros opcionais não poderiam ser nulos (ou mesmo de qualquer tipo de estrutura não interna). O Visual Basic 2010 agora permite definir parâmetros opcionais de qualquer tipo de valor:

Sub DisplayOrder(ByVal customer As Customer,

ByVal orderID Como inteiro,

Unidades ByVal opcionais Como inteiro?

Opcional ByVal backgroundColor As Color = Nada)

Finalizar sub

Neste exemplo, as unidades são do tipo Nullable(Of Integer) e backgroundColor é um tipo de estrutura sem conteúdo, mas ainda são usadas como parâmetros opcionais. O Visual Basic 2010 também oferece melhor suporte para parâmetros opcionais genéricos.

Tipos de interoperabilidade incorporada

Um ponto fraco comum para aplicativos que executam interoperabilidade COM é a necessidade de usar um Primary Interop Assembly (PIA). Um PIA é um assembly .NET que atua como um RCW (runtime callable wrapper) em um componente COM e possui um GUID exclusivo que o identifica. O assembly .NET se comunica com o PIA, que então executa qualquer empacotamento necessário para mover dados entre COM e .NET.

Infelizmente, os PIAs podem complicar a implantação porque são DLLs adicionais que precisam ser implantadas nos computadores dos usuários finais. Eles também podem causar problemas de versão – por exemplo, se você quiser que seu aplicativo funcione tanto no Excel 2003 quanto no Excel 2007, você precisará implantar ambos os PIAs com seu aplicativo.

O recurso de tipo de interoperabilidade incorporado é incorporado diretamente no aplicativo, mas apenas os tipos e membros da PIA que são absolutamente necessários, portanto, não há necessidade de implantar a PIA no computador do usuário final.

Para habilitar esse recurso para um objeto existente (ele é habilitado por padrão para novas referências), selecione a referência no Solution Explorer e altere a opção Embed Interop Types na janela Properties (veja a Figura 5). Alternativamente, se estiver compilando com o compilador de linha de comando ming, use a opção /l (ou /link) em vez de /r e /reference.

Figura 5 Habilitando tipos de interoperabilidade incorporados no Solution Explorer

Depois de ativar esse recurso, o aplicativo não dependerá mais da PIA. Na verdade, se você abrir a montagem no Reflector ou no ildasm, notará que na verdade não há nenhuma referência ao PIA.

Múltiplos objetivos

A melhor parte de todos os recursos do Visual Basic 2010 é que você pode usá-los mesmo em projetos direcionados ao .NET Framework 2.0 até o .NET Framework 3.5. Isso significa que recursos como caracteres implícitos de continuação de linha, literais de array, inicializadores de coleção, lambdas de instrução, propriedades implementadas automaticamente etc. estarão todos disponíveis em projetos existentes sem a necessidade de redirecionar o .NET Framework 4 .

A exceção são os tipos de interoperabilidade incorporados, que dependem de tipos que estão disponíveis apenas no .NET Framework 4, portanto, se você tiver como destino as versões 2.0 a 3.5 do .NET Framework, não poderá usar esse recurso; Além disso, os tipos marcados como variáveis ​​são marcados apenas como estavam no .NET Framework 4, portanto, no exemplo anterior, se você tiver como destino as versões 2.0 a 3.5, ainda precisará chamar .Cast(Of T). No entanto, se você tiver como alvo essas versões anteriores, poderá criar seus próprios tipos de variáveis ​​(usando os modificadores In/Out).

Para alterar a estrutura de destino atual do seu aplicativo, clique duas vezes em Meus Projetos, clique na guia Compilar, clique em Opções Avançadas de Compilação e selecione na caixa de combinação na parte inferior.

Na verdade, não há opção de linha de comando ming para ativar esse recurso ao compilar a partir da linha de comando ming. Na verdade, o compilador verifica qual assembly fornece a definição de System.Object (geralmente mscorlib) e para qual estrutura o assembly é direcionado e, em seguida, marca esse valor no assembly de saída. (O compilador usa esse mesmo mecanismo ao gerar assemblies do Silverlight.) Ao usar um IDE, tudo isso acontece de forma transparente, então você geralmente não precisa se preocupar com nada.

Bem-vindo a tentar

Como você pode ver, o Visual Basic 2010 possui muitos recursos poderosos que permitem que você seja mais produtivo enquanto escreve menos linhas de código e permite que o compilador faça mais trabalho. Neste artigo, discuti apenas os recursos da linguagem, mas há inúmeras melhorias excelentes no IDE do Visual Basic 2010. Algumas melhorias estão listadas abaixo:

Navegue até

Destacar citações

gerado a partir do uso

Melhor IntelliSense (correspondência de substring, pesquisa de camelcase, padrões de sugestão – útil para testar primeiro seu estilo de desenvolvimento)

Suporte a vários monitores

Zoom

A equipe do Visual Basic está ansiosa para ouvir seus comentários sobre nossos esforços para melhorar o Visual Basic, portanto, envie-nos seus comentários e perguntas sobre o Microsoft Connect. Para saber mais sobre a linguagem e os recursos do IDE, confira o conteúdo em msdn.com/vbasic, que inclui artigos, exemplos e vídeos de instruções. Claro, a melhor maneira de aprender é se aprofundar e usar o produto, então é hora de instalá-lo e testá-lo.