Este artigo foi traduzido por máquina.

Visual Basic 2010

O que há de novo no Visual Basic 2010

Jonathan Aneja

De sua concepção em 1991, a linguagem Visual Basic sempre foi uma ferramenta de produtividade fenomenal para a criação de aplicativos. Quase 20 anos mais tarde, ele continua a fornecer acesso fácil para o Microsoft .NET Framework, permitindo que os desenvolvedores escrevam aplicativos que abrangem áreas de trabalho, telefones, navegadores e até mesmo a nuvem.

Microsoft neste mês vêm Visual Studio 2010, que incorpora a versão 10 do Visual Basic (às vezes chamado 2010 VB ou VB10). Nesta versão, mais eficiente ainda, contém tempo vários - salvar recursos que get de desenvolvedores de ajuda mais com menos linhas de código. Aqui está tudo o que você precisa saber para atingir o início com o Visual Basic no Visual Studio 2010.

Coevolution

No passado, Visual Basic e translation from VPE for Csharp foram desenvolvidas pelas equipes separadas, que freqüentemente resultaram em recursos que aparece em um idioma antes do outro. Por exemplo, translation from VPE for Csharp tinha propriedades implementadas automaticamente e os inicializadores de coleção, que não estavam no Visual Basic e Visual Basic possuía recursos, como ligação tardia e parâmetros opcionais que não estavam em translation from VPE for Csharp. Mas sempre que um recurso apareceu um dos idiomas, muitos clientes poderiam solicitar que o recurso adicionado a outra também.

Para resolver esse feedback, Microsoft mescladas as equipes de Visual Basic e translation from VPE for Csharp, adotando uma estratégia de coevolution. O objetivo é tornar os idiomas Avançar juntos. Quando sérios de funcionalidade é introduzida em um idioma, ele deverá aparecer no outro também. Isso não significa que cada recurso será em ambos os idiomas e funcionam da mesma forma; na verdade, cada idioma tem seu próprio histórico spirit e acha — características são importantes para manter. Coevolution significa que qualquer tarefa que você pode fazer em um idioma deve ser tão simples no outro.

No .NET Framework 4, Visual Basic e translation from VPE for Csharp tomaram progressos gigantes para essa meta, cada adição de um número de recursos já tinha outra. Coevolution não trata apenas do passado, porém; também é a estratégia para a inovação futura nos idiomas. Permitindo nesse espírito, .NET Framework 4 apresenta novos recursos poderosos, como o Dynamic Language Runtime, incorporar tipos de interoperabilidade e variação genérica, em ambos os idiomas simultaneamente, que os desenvolvedores de Visual Basic e translation from VPE for Csharp aproveite ao máximo o .NET Framework.

Novos recursos do Visual Basic 2010

Os recursos novos no Visual Basic 2010 são projetados para ajudá-lo a fazer mais em menos linhas de código. (Equipe de design do Visual Basic) examinamos locais onde os desenvolvedores geralmente tem de escrever muito código clichê entediante e investigado maneiras de obter o compilador para realizar o trabalho em vez disso. Essa é uma visão geral; agora let’s investigar em alguns recursos individualmente.

Continuação de linha implícita

Visual Basic é uma linguagem orientada a linha que use sintaxe clara, como inglês para melhorar a legibilidade. Mas que normalmente resulta em código que executa até o limite de 80 caracteres por linha, forçando os desenvolvedores muito rolar. Você pode usar o caractere sublinhado para informar ao compilador que ele deve manter processando a próxima linha como parte da atual (ou seja, tratar várias linhas físicas como uma linha lógica, única). Mas ter que digitar sublinhados repetidas vezes sempre foi irritante e, na verdade, há anos como no. solicitação de recurso 1 foi para o compilador “ apenas descobrir. ”

Bem, no Visual Basic 2010, o compilador pode. Agora sabe quais símbolos (como vírgulas, parênteses e operadores) tendem a ocorrer logo antes do caractere de continuação de linha e insere o caractere para que os desenvolvedores não precisam. Por exemplo, encerrar uma instrução do Visual Basic com uma vírgula nunca é legal; o compilador sabe disso, portanto, quando ele vê um fluxo de token que se parece com {ponto-e-vírgula, digite}, ele infere a presença de caractere de continuação de linha, como o exemplo em Figura 1 mostra.

Figura 1 Inferir continuação de linha

<Extension()>
Function FilterByCountry(
  ByVal customers As IEnumerable(Of Customer),
  ByVal country As String) As IEnumerable(Of Customer)
    Dim query =
      From c In customers
      Where c.Country = country
      Select <Customer>
        <%=
          c.Name &
          "," &
          c.Country
        %>
      </Customer>
    Return query
  End Function

No Visual Basic 2008, o código em Figura 1 seria necessário nove sublinhados. Em cada um desses casos, no entanto, o compilador inferido quando o sublinhado era necessário e permitido para ser omitido:

  • Após o <Extension()> atributo
  • Depois de ((parêntese de abertura) na declaração do método
  • Depois, (vírgula) para o primeiro parâmetro
  • Antes de) (Fechar parêntese) na declaração do método
  • Após a = (sinal de igual)
  • Após o < % = (marca de abertura de uma expressão incorporada)
  • Depois de cada & (e comercial) no literal XML
  • Antes do %> (marca de fechamento para uma expressão incorporada)

Esse novo recurso do compilador é especialmente útil para a assinatura do método, deve ir muito além de 80 caracteres no exemplo mostrado se cada parte estivessem na mesma linha. In Figura 2 você verá todas as combinações de tokens e posições em que o caractere de continuação de linha está implícito.

Figura 2 Onde estão implícita continuação caracteres

Token Antes de Depois de
, (vírgula).  (ponto), > (atributos) ({(open colchetes), < % = (começar a expressão incorporada (literais))   X
),},] (feche colchetes), %> (expressão incorporada feche) X  

Todas as palavras-chave LINQ:

Agregar, distintos de grupo por grupo Join, Join, Let, Order By, Select, ignorar, Skip While, dê Take While, onde, dentro, ativado, crescente, decrescente

X X

Operadores:

+ ,   - ,   * ,   / ,   \ ,   ^ ,   >> ,   << ,   Mod,   & ,   += ,   -= ,   *= ,   /= ,   \= ,   ^= ,   >>= ,   <<= ,   &= ,   < ,   <= ,   > ,   >= ,   <> ,   Is,  IsNot,  Like,  And,   Or,  Xor,  AndAlso,  OrElse

  X
Com (em um inicializador de objeto)   X

Como você pode ver, há mais de 60 locais em que o idioma não requer sublinhados. (Na verdade, nenhum dos exemplos de código neste artigo obrigatório o caractere de continuação de linha.) Obviamente, você ainda pode usar o sublinhado para que o código de versões anteriores do Visual Basic ainda irá compilar conforme o esperado.

Instrução lambdas

Lambda termo pode parecer intimidating em primeiro lugar, mas um lambda é simplesmente uma função definida dentro de outra função. Visual Basic 2008 introduziu as expressões lambda com a palavra-chave Function:

Dim customers As Customer() = ...

 Array.FindAll(customers, Function(c) c.Country = "Canada")

As expressões lambda oferecem um bom modo compacto de expressar lógica localmente sem ter de dividi-lo em vários métodos. Por exemplo, eis como o código anterior seria procurou no Visual Basic 2005 (que não oferecem suporte a expressões lambda):

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

    ...

Function Filter(ByVal c As customer) As Boolean
  Return c.Country = "Canada"
End Function

Infelizmente, as expressões lambda do Visual Basic 2008 necessárias expressões retornam um valor, portanto, este:

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

causaria isso:

'Compile error: "Expression does not produce a value."

Console.WriteLine é um procedimento Sub (void, em translation from VPE for Csharp), portanto, ele não retorna um valor, por isso, o compilador dá um erro. Para lidar com isso, Visual Basic 2010 introduz suporte para lambdas de instrução, que são lambdas que podem conter uma ou mais instruções:

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

Porque console.WriteLine não retorna um valor, podemos simplesmente criar um sub lambda em vez de uma função lambda. Aqui está outro exemplo que usa várias instruções:

Array.ForEach(customers, Sub(c)
                           Console.WriteLine("Country Name:")
                           Console.WriteLine(c.Country)
                         End Sub)

Quando esse código é executado, ele irá imprimir duas linhas de cada cliente. Observe também que, se você passar o mouse sobre o cquando estiver codificando, você verá que o compilador tem inferir o tipo de cliente (também é legal digitar c como cliente para declarar explicitamente o tipo). Fiação dinamicamente manipuladores de eventos é outro uso ótimo para lambdas instrução:

AddHandler b.Click, Sub(sender As Object, e As EventArgs)
                      MsgBox("Button Clicked")
                      'insert more complex logic here
                    End Sub

E, na verdade, você pode combinar lambdas declaração com um recurso introduzido no Visual Basic 2008: delegados relaxados. (Você pode usar representantes — type-safe ponteiros para funções — para executar várias funções ao mesmo tempo.) Essa combinação produz uma assinatura ainda mais simples:

AddHandler b.Click, Sub()
                      MsgBox("Button Clicked")
                     'insert more complex logic here
                    End Sub

Relaxamento de delegado permite que você omita os parâmetros do manipulador de eventos completamente — uma vantagem interessante, dada que freqüentemente eles não utilizados, portanto, eles apenas adicionarem ruído visual.

Além de linha única sub lambdas e várias linhas lambdas sub que vimos até agora, o Visual Basic 2010 suporta lambdas função várias linhas:

Dim query = customers.Where(Function(c)
                              'Return only customers that have not been saved
                              'insert more complex logic here
                              Return c.ID = -1
                            End Function)

Outro aspecto interessante da instrução lambdas é a maneira que eles fazem interseção com os delegados anônimos introduzido do Visual Basic 2008. Pessoas freqüentemente confundem com métodos anônimos do translation from VPE for Csharp, embora tecnicamente não são iguais. Delegados anônimos ocorrem quando o compilador do Visual Basic infere um tipo de delegado com base na assinatura do método de um lambda:

Dim method = Function(product As String)
               If product = "Paper" Then
                 Return 4.5 'units in stock
               Else
                 Return 10 '10 of everything else
               End If
             End Function

MsgBox(method("Paper"))

Se você executar esse código, você verá o valor 4,5 exibida na caixa de mensagem. Além disso, se você passar o mouse sobre o método, você verá o texto Método Dim como < Function(String) Como Double >. Como é não fornecido nenhum tipo de delegado real, o compilador gerará um automaticamente, como este:

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

Isso é chamado de um delegado anônimo, porque ela aparece somente no código gerado por compilador, não no código escrito. Observe que o compilador inferir o tipo de retorno como Double, quando na verdade há não foi como cláusula fornecido para especificar o tipo de retorno do lambda. O compilador examina todas as instruções return dentro de lambda e vê os tipos (4,5) Double e Integer (10):

'Notice the "As Single"
Dim method = Function(product As String) As Single
               If product = "Paper" Then
                 Return 4.5 'units in stock
               Else
                 Return 10 '10 of everything else
               End If
             End Function

Em seguida, executa seu algoritmo de tipo dominante e determina que ele pode converter com segurança 10 em Double, mas não é possível converter com segurança 4.5 em inteiro, portanto Double é a melhor escolha.

Você também pode controlar o tipo de retorno explicitamente, caso em que o compilador não tenta inferir o tipo. Em vez de confiar no compilador para inferir o tipo de delegado, é muito comum para atribuir um lambda a uma variável que possui um tipo delegado explícita:

Dim method As Func(Of String, Single) =
  Function(product)
    If product = "Paper" Then
      Return 4.5 'units in stock
    Else
      Return 10 '10 of everything else
    End If
  End Function

Como um tipo de destino explícito foi fornecido, não é preciso dizer que Como string orComo Single; o compilador pode inferir sua presença com base no tipo delegado do lado esquerdo da instrução. Portanto, se você passar o mouse sobre o produto você descobrirá que o tipo inferido é String. Especificando Como único não é mais necessário, porque o tipo de delegado já fornece essas informações. No exemplo anterior, a assinatura do delegado Func (que inclui o .NET Framework) tem esta aparência:

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

com uma exceção secundária, como nós será consulte posteriormente na variação genérico seção.

Propriedades implementado automática

No Visual Basic, propriedades são membros de classe que usam para expor o estado do objeto para o mundo exterior. Uma declaração de propriedade típicas semelhante a este:

Private _Country As String

Property Country As String
  Get
    Return _Country
  End Get
  Set(ByVal value As String)
    _Country = value
  End Set
End Property

Isso é 10 linhas de código para o que é realmente um conceito muito simples.  Considerando que objetos típicos geralmente têm dezenas de propriedades, você acaba incluindo muito código clichê em definições de classe. Para facilitar tarefas como, por exemplo, Visual Basic 2010 introduz propriedades implementadas automaticamente, que permitem que você defina uma propriedade simples usando apenas uma linha de código:

Property Country As String

Nesse caso, o compilador irá vá em frente e gerar o getter, o setter e o backup campos automaticamente. O nome do campo existente será sempre um sublinhado seguido do nome da propriedade: _Country neste caso. Essa convenção de nomenclatura garante a compatibilidade de serialização binária uma propriedade implementada automaticamente deve ser alterada para um regular. Desde que o nome do campo como fazer o mesmo, serialização binária continuarão a funcionar.

Uma da frio coisas que você pode fazer com as propriedades implementadas automaticamente é especificar os inicializadores de definir o valor da propriedade padrão quando o construtor é executado. Por exemplo, um cenário comum com as classes de entidade, define a chave primária para algo como -1 para indicar que ele está em um estado que não foram salvo. É aqui que o código como seria:

Property ID As Integer = -1

Quando o construtor é executado, o campo backup (_ID) será definido automaticamente para 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)

A linha de código anterior não pode achar muito “ Visual Basic-ish, ” dado que inserir o nome do tipo duas vezes é redundante. A boa notícia é que há uma sintaxe ainda mais curta que é consistente com o nas declarações de variável regulares Visual Basic permite:

Property OrderList As New List(Of Order)

Você ainda pode combinar isso com inicializadores de objeto para permitir a definição de propriedades adicionais:

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

Obviamente, para propriedades mais complexas, a sintaxe expandida é ainda necessária.  Você ainda pode digitar Propriedade {TAB} para ativar o trecho de código propriedade antigo. Como alternativa, depois de digitar a primeira linha da propriedade, você pode simplesmente inserir Obtenha {Insira} e o IDE irão gerar a propriedade de estilo antigo:

Property Name As String
  Get

  End Get
  Set(ByVal value As String)

  End Set
End Property

As pessoas geralmente comentário de que a nova sintaxe da propriedade é quase idêntica à sintaxe para um campo público, por que não use um campo público em vez disso? Bem, por alguns motivos:

  • Grande parte da infra-estrutura de ligação de dados .NET funciona em Propriedades, mas não campos.
  • Uma interface não pode impor a existência de um campo; ele pode garantir que uma propriedade.
  • Propriedades fornecem flexibilidade mais longo prazo para alterar as regras de negócios. Por exemplo, suponha que alguém apresenta a regra que um número de telefone deve ser de 10 dígitos. Não é possível executar essa validação quando atribuir a um campo público. Alterar um campo público para uma propriedade é uma alteração significativa para cenários como a serialização binária e reflexão.

Inicializadores de coleção

Uma prática comum do .NET é criar uma instância de uma coleção e, em seguida, preenchê-lo chamando o método Add de uma vez para cada elemento:

Dim digits As New List(Of Integer)
digits.Add(0)
digits.Add(1)
digits.Add(2)
digits.Add(3)
digits.Add(4)
digits.Add(5)
digits.Add(6)
digits.Add(7)
digits.Add(8)
digits.Add(9)

Mas o resultado é muita sobrecarga sintática para o que é basicamente um conceito muito simples. Visual Basic 2010 introduz inicializadores de coleção para informá-lo mais fácil criar uma instância de coleções. Com 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 o recurso com 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 recomendável usando a sintaxe da segunda (As New) sobre ao primeiro, porque torna código resistentes contra alterações à configuração Option Infer.

Você pode usar a coleção inicializadores contra qualquer tipo que atende aos seguintes requisitos:

  • Você pode iterar sobre ele usando um for each instrução — ou seja, ele implementa IEnumerable. (Para obter uma definição mais precisa/de detalhadas de um tipo de coleção, consulte a seção 10.9.3 
Specification a linguagem Visual Basic em msdn.microsoft.com/library/aa711986(VS.71).aspx).
  • Ele tem um construtor sem parâmetros (não necessariamente público) acessível.
  • lt tem um acessível (não necessariamente) instância ou a extensão do método público chamado adicionar.

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

Dim lookupTable As New Dictionary(Of Integer, String) From
  {{1, "One"},
   {2, "Two"},
   {3, "Three"},
   {4, "Four"}}

(Observe que, mesmo que essa instrução abrange cinco linhas, não há nenhum sublinhados.) Nesse caso, o compilador irá gerar o código que é equivalente a forma antiga de inicializar o dicionário:

Dim lookupTable As New Dictionary(Of Integer, String)
lookupTable.Add(1, "One")
lookupTable.Add(2, "Two")
lookupTable.Add(3, "Three")
lookupTable.Add(4, "Four")

O compilador está chamando um método Add com dois parâmetros em vez de um. Ele sabe para fazer isso porque os valores passados para o inicializador de coleção estavam em chaves aninhadas, como este: {{1, “ Única ”}, {2, “ duas ”}, …}. Para cada conjunto de chaves aninhadas, o compilador tenta passar esses parâmetros para um método compatível.

Você também pode fornecer sua própria implementação de Add personalizada utilizando um método de extensão:

<Extension()>
  Sub Add(ByVal source As IList(Of Customer),
          ByVal id As Integer,
          ByVal name As String,
          ByVal city As String)

      source.Add(New Customer With
                 {
                    .ID = id,
                    .Name = name,
                    .City = city
                 })
  End Sub

(Veja os sublinhados ausentes!) Esse método amplia qualquer tipo que implementa IList(Of Customer) e, em seguida, permite que você use a nova sintaxe do inicializador de coleção como este:

Dim list = New List(Of Customer) From
            {
              {1, "Jon", "Redmond"},
              {2, "Bob", "Seattle"},
              {3, "Sally", "Toronto"}
            }

(adicionando três clientes lista). Você também pode usar a coleção inicializadores em conjunto com as propriedades implementadas automaticamente:

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

Literais de matriz

Além de mais eficientes maneiras de trabalhar com tipos de coleção, 2010 do Visual Basic também fornece algumas melhorias excelentes para trabalhar com matrizes. Considere o seguinte código (que funciona bem em versões anteriores):

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

É óbvio observando os elementos da matriz que cada um é um inteiro, assim, ter que digitar, na verdade, out inteiro duas vezes nessa linha realmente não adiciona qualquer valor. Literais de matriz permite a criação de uma matriz, colocando todos os seus elementos entre chaves e, em seguida, tendo o compilador inferir o tipo automaticamente:

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

O tipo de números não é objeto, mas em vez disso Integer() (contanto que Option Infer está ativado), porque agora pode estar sozinha e tem seu próprio tipo de array literal. Considere um exemplo mais complicado:

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

Nesse caso, o tipo de números será inferido como Double(). O compilador determina o tipo examinando cada elemento na matriz e calculando o tipo dominante (usando o mesmo algoritmo discutido anteriormente para inferir o tipo de retorno de uma declaração de lambda). O que acontece se há nenhum tipo dominante, como no código a seguir:

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

Nesse caso, convertendo um Integer em uma string seja uma conversão de restrição (isto é, há potencial perda de dados em tempo de execução), e da mesma forma, conversão de uma string em um Integer também seria uma conversão de restrição. O tipo de seguro apenas a escolha é Object() (e o compilador fornecerá um erro quando Option Strict está ativada).

Literais de matriz podem ser aninhados para formar matrizes multidimensionais ou denteadas arrays:

'2-dimensional array
Dim matrix = {{1, 0}, {0, 1}} 

'jagged array - the parentheses force evaluation of the inner array first
Dim jagged = { ({1, 0}), ({0, 1}) }

Dinâmico Language Runtime

Enquanto tecnicamente uma linguagem estática coração, Visual Basic sempre teve extremamente poderosos recursos dinâmicos, tais como ligação tardia. Visual Studio 2010 vem com uma nova plataforma chamada o DLR (Dynamic Language Runtime), que torna mais fácil criar — e se comunicar entre — linguagens dinâmicas. 2010 Do Visual Basic foi atualizado para suportar totalmente o DLR no seu latebinder permitindo aos desenvolvedores usar bibliotecas e estruturas desenvolvidas em outras linguagens, como a IronPython/IronRuby.

A coisa interessante sobre esse recurso é que nada seja alterado sintaticamente (na verdade, não uma única linha de código foi modificada no compilador para oferecer suporte a esse recurso). Os desenvolvedores ainda podem fazer operações de ligação tardia da mesma maneira que nas versões anteriores do Visual Basic. O que mudou é o código no Visual Basic Runtime (Microsoft.VisualBasic.dll), que agora reconhece a interface IDynamicMetaObjectProvider que fornece o DLR. Se um objeto implementa essa interface, o tempo de execução do Visual Basic será construir um CallSite DLR e o objeto e sua linguagem fornecendo inserir seu próprios semântica na operação.

Por exemplo, as bibliotecas padrão do Python contém um arquivo chamado random.py com um método chamado ordem aleatória que pode ser usada para reorganizar os elementos em uma matriz aleatoriamente. Chamá-lo é simples:

Dim python As ScriptRuntime = Python.CreateRuntime()
Dim random As Object = python.UseFile("random.py")

Dim items = {1, 2, 3, 4, 5, 6, 7}
random.shuffle(items)

Em tempo de execução, o Visual Basic vê que o objeto implementa IDynamicMetaObjectProvider e, portanto, passa o controle para o DLR, que se comunica com o Python e executa o método (passagem junto a matriz que foi definida no Visual Basic como um argumento para o método).

Que é um exemplo de chamar uma API habilitado DLR, mas também é possível que os desenvolvedores criem suas próprias APIs que utilizam esse recurso. A chave é implementar a interface IDynamicMetaObjectProvider, caso em que os compiladores do Visual Basic e translation from VPE for Csharp reconhecerá o objeto tiver semântica dinâmica especial. Em vez de implementar a interface manualmente, é mais fácil herdar da classe System.Dynamic.DynamicObject (que já implementa esta interface) e substituir apenas alguns métodos. Figura 3 mostra um exemplo completo de criação de um objeto personalizado dinâmico (um recipiente de propriedades “ ” que aparece criar propriedades sem interrupções) e chamando-o usando normal ligação tardia do Visual Basic. (Para obter mais informações sobre como trabalhar com DynamicObject, leia excelente artigo ’ Doug Rothaus em blogs.msdn.com/vbteam/Archive/2010/01/20/fun-with-Dynamic-Objects-Doug-rothaus.aspx.)

Figura 3 Criar um objeto dinâmico personalizado e chamada IT com o Visual Basic ligação atrasada

Imports System.Dynamic
  Module Module1
    Sub Main()
      Dim p As Object = New PropertyBag
        p.One = 1
        p.Two = 2
        p.Three = 3
      Console.WriteLine(p.One)
      Console.WriteLine(p.Two)
      Console.WriteLine(p.Three)
    End Sub
      Class PropertyBag : Inherits DynamicObject
        Private values As New Dictionary(Of String, Integer)
        Public Overrides Function TrySetMember(
          ByVal binder As SetMemberBinder,
          ByVal value As Object) As Boolean
            values(binder.Name) = value
          Return True
        End Function
        Public Overrides Function TryGetMember(
          ByVal binder As GetMemberBinder,
          ByRef result As Object) As Boolean
          Return values.TryGetValue(binder.Name, result)
        End Function
      End Class
  End Module

Variação genérica

Esse é um recurso pode parecer complicado realmente (com termos como covariância e contravariance) em primeiro lugar, mas é realmente muito simples. Se você tiver um objeto do tipo IEnumerable(Of Apple) e deseja atribuí-la a um IEnumerable(Of Fruit), que deve ser legais, porque cada Apple é uma Fruta (imposta por um relacionamento de herança). Infelizmente, antes de 2010 do Visual Basic, variação genérica não havia suporte para no compilador, embora na verdade, era suportado no CLR (Common Language Runtime).

Considere o exemplo em Let’s Figura 4. No Visual Basic 2008, o código em Figura 4 geraria um erro de compilação (ou se Option Strict está desativado, uma exceção em tempo de execução) na linha enabledOnly Dim. A solução alternativa foi chamar o método de extensão .Cast, conforme mostrado aqui:

'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 é necessário, porque 2010 do Visual Basic, a interface IEnumerable foi marcada como covariant, usando o modificador de saída:

Interface IEnumerable(Of Out T)
  ...
End Interface

Figura 4 Exemplo de variação genérico

Option Strict On
Public Class Form1
  Sub Form1_Load() Handles MyBase.Load
    Dim buttons As New List(Of Button) From
      {
        New Button With
        {
          .Name = "btnOk",
          .Enabled = True
        },
        New Button With
        {
          .Name = "btnCancel",
          .Enabled = False
        }
      }

    Dim enabledOnly = FilterEnabledOnly(buttons)
  End Sub
  Function FilterEnabledOnly(
    ByVal controls As IEnumerable(Of Control)
    ) As IEnumerable(Of Control)
    Return From c In controls
    Where c.Enabled = True
  End Function
End Class

Isso significa que o parâmetro genérico T é agora variante (ou seja, ele funciona para as relações de herança) e o compilador irá garantir ele é usado somente nas posições de onde vem o tipo da interface de. Parâmetros genéricos também podem ser contravariant, o que significa que eles são usados apenas em entrada posições. Um tipo, na verdade, pode ter ambos. Por exemplo, o delegado Func discutido anteriormente tem os parâmetros covariant (para o tipo de retorno) e parâmetros contravariant (elementos obtém passados):

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

Você pode usar o in e out modificadores em suas interfaces personalizadas e delegados. Várias interfaces usados e delegados no .NET Framework 4 já foram marcados como variante; exemplos comuns incluem todos os ação/func delegados, IEnumerable (of t), IComparer (of t) e IQueryable(Of T), entre outros.

A coisa interessante sobre variação genérica é que ele é um recurso que você Don precisa se preocupar sobre realmente — se ele está fazendo seu trabalho, nunca verá-lo. Situações que usados para causar erros de compilação ou exigem que uma chamada para .Cast(Of T) deve funcionar muito bem no Visual Basic 2010.

Parâmetros opcionais aprimorados

Parâmetros opcionais fornecem um recurso de produtividade útil que permite aos desenvolvedores tornar métodos mais flexíveis e evitar que ele polua a uma classe com várias sobrecargas de um método. Uma limitação no passado era que parâmetros opcionais não podem ser anuláveis (ou, de fato, qualquer tipo de estrutura não intrínsecas). Visual Basic 2010 agora permite que você defina os parâmetros opcionais de qualquertipo de valor de :

Sub DisplayOrder(ByVal customer As Customer,
                 ByVal orderID As Integer,
                 Optional ByVal units As Integer? = 0,
                 Optional ByVal backgroundColor As Color = Nothing)
End Sub

Nesse caso, unidades é do tipo Nullable (Of Integer) e backgroundColor é um tipo de estrutura não intrínsecos, mas eles ainda podem ser usados como parâmetros opcionais.2010 Do Visual Basic também fornece melhor suporte para parâmetros opcionais que são genéricos.

Incorporar tipos de interoperabilidade

Para aplicativos que executam a interoperabilidade COM, um ponto problemático comum está tendo que trabalhar com assemblies de interoperabilidade primários (PIAs).Um PIA é um assembly .NET que serve como um Runtime Callable Wrapper RCW () em um componente COM e tem um GUID exclusivo para identificá-lo.Assemblies .NET se comunicar com um PIA, que realiza marshaling necessário para mover dados entre COM e. NET.

Infelizmente, PIAs podem complicar implantação porque eles são DLLs adicionais que precisam ser implantados em máquinas ’ os usuários finais.Eles também causem problemas para o controle de versão — por exemplo, se desejar que um aplicativo para ser capaz de trabalhar no Excel 2003 e Excel 2007, você precisará implantar ambos os PIAs com o aplicativo.

O recurso de incorporar tipos de interoperabilidade incorpora diretamente para o aplicativo, mas somente a tipos e membros do PIA que sejam absolutamente necessários, assim, eliminando a necessidade de PIAs a ser implantado para máquinas os usuários finais ’.

Para ativar esse recurso para um projeto existente (já estiver por padrão para novas referências), selecione a referência no Solution Explorer e altere a opção incorporar tipos de interoperabilidade na janela de propriedades (consulte Figura 5).Ou, se compilando usando o compilador de linha de comando, use a chave /l (ou /link) em vez de /r e /reference.

image: Enabling the Embed Interop Types Feature in Solution Explorer

Figura 5 Ativando a incorporar recurso tipos de interoperabilidade no Solution Explorer

Depois que você tenha ativado esse recurso, o aplicativo não tem uma dependência no PIA.Na verdade, se você abrir o assembly em Reflector ou ildasm, você notará que há, na verdade, qualquer referência para o PIA em todos os.

Multi-direcionamento

A coisa mais interessantes sobre todos os recursos no Visual Basic 2010 é que você pode até mesmo usá-los em projetos de destino do .NET Framework 2.0 por meio do .NET Framework 3.5.Isso significa que continuação de linha implícito, literais de matriz, coleção inicializadores, lambdas de instrução, propriedades implementadas automaticamente e assim por diante tudo funcionará em projetos existentes sem a necessidade de redirecionamento para o .NET Framework 4.

A única exceção é tipos de interoperabilidade incorporar, que tem uma dependência em tipos que são somente no .NET Framework 4; assim você não pode usá-la ao direcionamento versões do .NET Framework 2.0 por meio de 3,5.Além disso, os tipos que são marcados como variante só são marcados dessa forma no .NET Framework 4, no exemplo anterior, você clicaria ainda precisará chamar .Cast(Of T) quando destinados a versões 2.0 por meio do 3.5.No entanto, você pode tornar seus próprios tipos de variantes (usando os modificadores de entrada/saída) quando a definição do público-alvo dessas versões anteriores.

Para alterar a estrutura de destino atual para um aplicativo, clique duas vezes em My Project, clique na guia Compile, clique em Advanced Compile Options e selecione na caixa de combinação na parte inferior.

Ao compilar na linha de comando, não existe realmente nenhuma opção de linha de comando para habilitar esse recurso.Em vez disso, o compilador examina o assembly fornecido a definição de System.Object (normalmente mscorlib) e qual estrutura que assembly está voltada e, em seguida, apresenta esse valor no seu assembly de saída.(Esse é o mesmo mecanismo, que o compilador usa ao criar assemblies do Silverlight). Ao usar o IDE, tudo isso acontece de forma transparente, portanto, em geral não é algo que você precisa se preocupar.

Experimente IT

Como você pode ver, 2010 do Visual Basic possui muitos recursos poderosos que permitem que sejam mais produtivos durante a gravação menos linhas de código, descarregamento mais trabalho para o compilador.Neste artigo, eu já observou apenas recursos de linguagem, mas o IDE do Visual Basic 2010 também tem uma tonelada de ótimos aprimoramentos.Aqui está uma lista parcial:

  • Navegar para
  • Realçar referências
  • Gerar de uso
  • Melhor IntelliSense (subseqüência de caracteres correspondente, caso a caixa pesquisa, o modo de sugestão — útil para “ primeiro testar ” estilos de desenvolvimento)
  • Suporte multi-Monitor
  • Aplicar zoom

A equipe do Visual Basic adoraria saber seu feedback sobre o que podemos fazer para tornar o Visual Basic ainda melhor, então, envie-nos seus comentários e perguntas no Microsoft Connect.Para obter mais informações sobre a linguagem e recursos do IDE, dar baixa no conteúdo em MSDN.com/vbasic, incluindo artigos, exemplos e como faço vídeos.Obviamente, a melhor maneira para saber é mergulhar e usando o produto, portanto, é hora de instalá-lo e experimentá-lo.

Quer mais Visual Basic? Adivinhou. MSDN Magazine *está retomando publicação mensal da coluna Instintos básicos, que se concentra no desenvolvedor de Visual Basic e tópicos relacionados e é escrita pela equipe do Visual Basic da Microsoft.        *

Jonathan Aneja* é gerente de programa na equipe do Estrutura de Entidade da Microsoft. Anteriormente, ele era o gerente do programa para o compilador do Visual Basic durante as versões do Visual Basic 2008 e do Visual Basic 2010. Ele está na Microsoft há quatro anos.*

Graças aos seguintes especialistas técnicos para revisar este artigo: Dustin Campbell, Jason Malinowski e Lucian Wischik