Este artigo foi traduzido por máquina.
Instintos básicos
Coleção e inicializadores de matriz no Visual Basic 2010
Adrian Spotty Bowles
Algumas das alterações idioma que ocorreram durante o ciclo do produto Microsoft Visual Studio (VS) 2010 tem sido direcionadas simplificar as tarefas que eram anteriormente possíveis somente através do uso de muito código clichê. Essa abordagem no Visual Studio 2010 melhora a experiência de codificação, fazendo você mais produtivo. Um dos recursos novos no Visual Studio para o lançamento de 2010 é inicializadores de coleção. Esse recurso estava disponível na translation from VPE for Csharp em 2008 e adoção como parte da filosofia paridade geral Microsoft. Algumas das alterações feitas em Visual Basic 2010 podem ser menos imediatamente óbvias e este artigo irá identificar alguns dos detalhes de implementação menos óbvios.
Coleções e matrizes são construções muito comuns em qualquer aplicativo moderno, e freqüentemente têm essas coleções ser inicializado. Antes para versões 2010, Visual Basic não pôde lidar com inicializadores de matriz básico com algumas limitações, mas coleções não puderam ser inicializados em uma declaração de uma linha semelhante, que freqüentemente resultava em código clichê semelhante ao seguinte:
Dim x As New List(Of String)
x.Add("Item1")
x.Add("Item2")
Ou ele necessário criar um construtor para a classe, usando algo como o seguinte:
Dim x as new list(of string)({"Item1","Item2"})
Nenhuma dessas abordagens foram particularmente elegante soluções.
Embora ambos trabalhou, eles envolvidos escrever código adicional para inicializar a coleção. Embora esse código geralmente seja código clichê simples, ele pode aumentarão o código de origem, que pode levar a custos de manutenção associado.
Se você procurar por meio de praticamente qualquer código que usa conjuntos, você verá código clichê semelhante. No exemplo anterior, está adicionando apenas dois elementos de seqüência de caracteres e está usando repetitivas chamadas para o método add para cada um das seqüências de caracteres. Se usássemos um personalizado "definido pelo usuário"coleção ou uma coleção de "definido pelo usuário"tipos, o código padrão aumentaria para fazer a mesma tarefa de inicialização da coleção.
Nova sintaxe
Com o Visual Studio 2010, estamos agora capaz de manipular esta tarefa de inicialização de coleção em um formulário mais conciso, reduzindo para baixo as várias linhas de código e chamadas de método de adicionar repetidas em uma única instrução:
Dim x As New List(Of String) From {"Item1", "Item2"}
Este é um exemplo simples usando tipos de coleção lista genérica da estrutura para fornecer uma coleção de tipo seguro. Esses tipos de coleção agora são mais usados que tipos de coleção programados, que foram usados no passado para implementar a segurança de tipos coleções.
A sintaxe permite que os membros da coleção a ser especificado como uma lista de itens contidos as chaves {}, e cada item é separado por vírgulas usando "FROM"palavra-chave para determinar o list.The membro inicial anterior exemplo funciona bem para um tipo de lista, mas para tipos de coleção mais complexos, como dicionários, onde pode haver um par chave-valor fornecido para cada membro, é necessário um conjunto adicional de chaves ao redor de cada par chave-valor, da seguinte maneira:
Dim x As New Dictionary(Of Integer, String)
From {{1, "Item1"}, {2, "Item2"}}
A sintaxe está limpo e consistente. Cada par chave-valor é determinado pela {} aninhados, e esses argumentos são usados quando é feita uma chamada para o método Add (dicionário) do tipo de coleção. Portanto, as linhas anteriores seriam equacionar os para:
Dim x As New Dictionary(Of Integer, String)
x.Add(1, "Item1")
x.Add(2, "Item2")
Implementação e uso em outros tipos de coleção
Os exemplos anteriores mostram como coleções inicializar uso para tipos de estrutura típicos. No entanto, você pode implementar seus próprios tipos de coleção ou talvez queira usar alguns tipos de onde você não é imediatamente capazes de usar o inicializador porque eles não têm um método Add (os exemplos incluem pilha, fila).
Para permitir a usar o recurso inicializador de coleção dois nesses cenários, é importante entender um pouco sobre o que está acontecendo nos bastidores e como esse recurso é implementado. Essa compreensão permitirá que nós expandir seu uso além exemplos simples de lista e dicionário.
Para usar a sintaxe do inicializador de coleção, Exigimos dois itens para serem verdadeiras. O tipo deve:
- Implemente o padrão de IEnumerable, que pode ser uma interface IEnumerable ou simplesmente tem um método GetEnumerator. Isso pode ser chamado de "pato"digitando: Se ele é semelhante a um pato e quacks como um pato, provavelmente é um pato.
No nosso caso, se ele contiver um método GetEnumerator com uma assinatura apropriada, em seguida, que é provavelmente Implementando comportamento semelhante para a interface IEnumerable. Esse comportamento digitação pato já é usado para permitir tipos a ser usado com para cada construção. - Conter pelo menos um método Add acessível com um parâmetro. Isso pode ser uma instância ou um método de extensão.
Se sua classe de coleção atender a ambas essas condições, você pode usar a sintaxe do inicializador de coleção.
Para inicializadores de coleção, não, na verdade, usamos o método IEnumerable para inicializar a coleção, mas podemos usá-lo como uma dica para determinar que esse tipo é, na verdade, um tipo de coleção. Se ele implementa o padrão de IEnumerable ou IEnumerable, em seguida, há uma alta probabilidade que você tem uma coleção, embora ele não é garantido.
O método Add é chamado para cada item na lista de inicializador para adicionar itens à coleção. O fato de que um método Add é presente não significa necessariamente a implementar a funcionalidade para adicionar itens à coleção. Mas chamadas para um método Add com os argumentos modificados da "lista de inicialização"será feita.
Para ilustrar esse ponto, o exemplo de código seguinte na do Figura 1 é válido e pode usar a sintaxe do inicializador de coleção, mas na verdade não adiciona os itens a uma coleção.
Outras classes do Framework — trabalhar com métodos de extensão
Alguns tipos de coleção de estrutura de não atendem a ambos esses requisitos. Pilhas e filas de implementam métodos como pop e envio em vez de adicionar. Para permitir que você usar o recurso inicializador de coleção conciso para esses tipos, você pode aproveitar o poder dos métodos de extensão. É simples criar um método de extensão Adicionar para esses tipos, em seguida, permitirá que você inicializar os métodos com sintaxe simples.
Imports System.Runtime.CompilerServices
Module Module1
Sub Main()
Dim st1 As New Stack(Of Integer) From {1, 2, 3}
End Sub
End Module
Module Extensions
<Extension()> Sub Add(Of t)(ByVal x As Stack(Of t), ByVal y As t)
x.Push(y)
End Sub
End Module
Ao usar os métodos de extensão, ele é geralmente boa prática para estender somente os tipos que você tem controle sobre. Uso livre de métodos de extensão pode levar a conflitos ou alterações no comportamento se os tipos forem atualizados, então, usá-las com cuidado.
Use com continuação de linha implícita
Visual Studio 2010 também contém outro recurso tão esperado muito: continuação de linha. Esse recurso permite que você eliminar os caracteres _ incômoda. Continuação de linha implícita é permitida para itens na "Inicializar lista de", portanto, é possível colocar cada um desses itens em suas próprias linhas por motivos de clareza.
Dim st1 As New Stack(Of Integer) From {1,
2,
3}
Sintaxe do inicializador de coleção da Figura 1
Module Module1
Sub Main()
Dim NC As New TestNonCollectionClass From {1, 2, 3}
End Sub
End Module
Class TestNonCollectionClass
Public Function GetEnumerator() As System.Collections.IEnumerator
'Does Nothing
End Function
Public Sub Add(ByVal x As Integer)
If x = 1 Then
Console.WriteLine("Add Item" & x.ToString)
End If
End Sub
End Class
Isso permite que você a produzir código limpo é simples para ler, não contém caracteres extras _ e evita a repetição. Você pode usá-lo para suas próprias coleções e os já na estrutura. Suporte a IntelliSense do editor permite que "FROM"suporte para todos os tipos que seguem anteriores duas regras, que significa que ele funcionará para seus tipos de coleção. Se você tiver código existente que utiliza o caractere _ e prefere permanecerão consistentes com sintaxe antiga, essa opção ainda suporte.
Comportamento de manipulação de exceção
Há alguns interessantes a serem destaque ao chamar o método Add para cada um dos "Lista de inicializador"membros.
Por exemplo, quando uma chamada para o método Add com o argumento fornecido dos resultados inicializar lista em uma exceção, a lista não será inicializada com todos os membros. O que isso significa que na realidade é que a coleção é inicializada com seu não inicializado ou todos os membros em todos os.
Isso significa que se sua lista tiver três itens e o terceiro quando chamado usando Adicionar método resulta em uma exceção, você obterá uma exceção lançada e uma coleção não inicializada. O followingexample intencionalmente gera uma exceção para demonstrar esse cenário exato e resulta em "Vazio"sendo escritos para o console. Entretanto, alterar a lista de inicializador para remover o valor três resultará em "Utilizando: elemento contagem 2"conforme mostrado no do Figura 2.
Figura 2 alterando a lista de inicializador
Imports System.Runtime.CompilerServices
Module Module1
Sub Main()
Dim l1 As Stack(Of Integer)
Try
l1 = New Stack(Of Integer) From {1, 2}
Catch ex As Exception
End Try
If l1 Is Nothing Then
Console.WriteLine("Blank")
Else
Console.WriteLine("Initialized - Element Count:" & l1.Count)
End If
End Sub
End Module
Module Extensions
<Extension()> Sub Add(Of t)(ByVal x As Stack(Of t), ByVal y As t)
If y.ToString = "3" Then
Throw New Exception("Intentional Exception")
Else
x.Push(y)
End If
End Sub
End Module
Se isso não acontecer, em seguida, ele exigiria criar código adicional para determinar se ocorreram sem exceções de inicialização e o estado da coleção estava em.
Usando métodos de extensão para encurtar a sintaxe
A sintaxe padrão para inicializar uma coleção de objetos complexos resulta em ter que repetir "New < tipo >"para cada um os itens na lista de inicializador.
Module Module1
Sub Main()
Dim CustomerList As New List(Of Customer)
From {New Customer With {.Name = "Spotty", .Age = 39},
New Customer With {.Name = "Karen", .Age = 37}}
End Sub
End Module
Class Customer
Public Property Name As String = ""
Public Property Age As Integer = 0
End Class
A sintaxe requer que cada item na lista de inicializador é instanciado. Através do uso de métodos de extensão, é possível reduzir ainda mais essa sintaxe. A funcionalidade depende do fato de que o tipo de coleção oferece suporte à interface IEnumerable e também tem um método Add, que fará com que os itens de lista de inicializador incluídos sendo mapeados para os parâmetros do método add, como mostrado na do Figura 3.
Figura 3 uso de métodos de extensão
Imports System.Runtime.CompilerServices
Module Module1
Sub Main()
'Shortend Syntax through the use of extension methods
Dim CustomerList As New List(Of Customer)
From {{"Spotty", 39}, {"Karen", 37}}
End Sub
End Module
Module Extension
<Extension()> Public Sub add(ByVal x As List(Of Customer), _
ByVal Name As String, ByVal Age As Integer)
x.add(New Customer With {.Name = Name, .Age = Age})
End Sub
End Module
Class Customer
Public Property Name As String = ""
Public Property Age As Integer = 0
End Class
Adicionar a sobrecarga de método
A condição do método Add é fundamental para esse recurso e pode ser sobrecarregada. Cada método irá chamar seu próprio sobrecarga com base em argumentos chamados. Não há nenhuma mágica aqui e a resolução de sobrecarga de método de adicionar funciona apenas como resolução funciona para qualquer método de sobrecarga.
Isso novamente é melhor demonstrado por um exemplo simples. do Figura 4, temos sobrecargas para diferentes tipos de dados — chamaremos o apropriado para o argumento de chamada.
Por que é o uso de sintaxe 'FROM' e não '='?
Uma pergunta comum solicitada da equipe do produto para esse recurso é o uso de "FROM"palavra-chave, porque os inicializadores de matriz já estão usando o "="para atribuição.
No Visual Basic, é possível instanciar uma classe de coleção de três maneiras diferentes:
Dim x1 As New List(Of Integer)
Dim x2 = New List(Of Integer)
Dim x3 As List(Of Integer) = New List(Of Integer)
Adicione a isso o fato que duas sintaxes para instanciar uma coleção já incluem um = caractere na sintaxe. Usando adicional = caractere resultaria em confusão na sintaxe entre de atribuição de uma nova instância do tipo de coleção e inicialização de membros à coleção.
Isso usando uma palavra-chave em vez de um caractere para determinar o resultado de uma ação de inicializador de coleção evita esse problema e permite que todos os convenções de sintaxe declarar e inicializar tipos de coleção existente =. Ainda a maneira de determinar a lista de inicializador permanece familiar para a sintaxe do inicializador de matriz existentes.
A palavra-chave FROM foi escolhida após muita discussão. Para esses familiarizado com consultas LINQ, pode parecer estranha uma opção que já haja uma palavra-chave FROM usada no LINQ. Pode parecer que essa opção pode levar a ambigüidades potenciais quando usado em consultas LINQ mas como veremos, isso não é o caso.
Não 'FROM'Conflitar com 'FROM'em consultas?
Mesmo em consultas que contêm os inicializadores de coleção, não há nenhuma ambigüidade da palavra-chave. Isso pode ser demonstrado pelo seguinte código:
Module Module1
Sub Main()
'The first from is the query,
'the second is the collection initializer.
'The parser can always successfully identify the difference
Dim x = From i In New List(Of Integer) From {1, 2, 3, 4}
Where i <= 3
Select i
For Each i In x
Console.WriteLine(i)
Next
Stop
End Sub
End Module
Limitações usando a coleção Initalizer com inicializador de objeto
Para o produto de 2008, a equipe do Visual Basic implementado inicializadores de objeto habilitado para o desenvolvedor ao inicializar objeto campos/propriedades quando eles foram instanciar uma instância de objeto:
Dim x As New List(Of Integer) With {.Capacity = 10}
No entanto, não é possível inicializar o objeto e a coleção na mesma declaração, portanto, a seguir produzirá um erro de sintaxe:
Dim x as New List(Of Integer) from {1,2,3} With {.Capacity = 10}
Há algumas outras alterações menos óbvias que ocorreram em 2010 relacionadas a matrizes que podem não ser imediatamente perceptível mas podem ter impacto no código usando matrizes.
Figura 4 Overloads para tipos de dados diferente
Imports System.Runtime.CompilerServices
Module Module1
Sub Main()
Dim l1 As New Stack(Of Integer) From {1, 2.2, "3"}
Console.WriteLine("Element Count:" & l1.Count)
Stop
End Sub
End Module
Module Extensions
<Extension()> Sub Add(ByVal X1 As Stack(Of Integer), _
ByVal x2 As Integer)
Console.WriteLine("Integer Add")
X1.Push(x2)
End Sub
<Extension()> Sub Add(ByVal X1 As Stack(Of Integer), _
ByVal x2 As Double)
Console.WriteLine("Double Add")
X1.Push(CInt(x2))
End Sub
<Extension()> Sub Add(ByVal X1 As Stack(Of Integer), _
ByVal x2 As String)
Console.WriteLine("String Add")
X1.Push(CInt(x2))
End Sub
End Module
Alterações de inicializador de matriz
Embora anteriores à versão 2010 foi possível inicializar matrizes simples, ainda havia algumas limitações. Uma das alterações recentes permite que tipos de matriz sejam inicializados e inferido de maneiras mais concisas.
Anteriormente identificar um item no Visual Basic como uma matriz exigia que você especificar um conjunto de parênteses no identificador:
Dim a() As Integer = {1, 2, 3}
Agora essas parênteses não são necessários e o tipo será inferido como um tipo de matriz com Option Infer On, resultando em uma sintaxe mais concisa:
Dim a = {1, 2, 3}
Inferência de tipo de matriz
Em 2008, foi implementado o recurso de inferência de tipo, tipos de dados a ser deduzido a partir seus valores de atribuição que habilitado. Isso funcionou para objetos únicos declarados dentro de corpos de método, mas não inferir um tipo de matrizes e, portanto, sempre foram matrizes de objetos.
Sub Main()
Dim a() = {1, 2, 3}
'Type would previously result in Object Array prior to 2010
End Sub
Isso foi aperfeiçoado e agora tipos de matriz são inferidos, da seguinte maneira:
Sub Main()
Dim a = {1, 2, 3} 'Type now infers Integer Array
End Sub
O tipo inferido da matriz é determinado pela funcionalidade tipo dominante adicionada em 2008. A inferência de tipo ainda funciona somente para código declarado dentro de corpos de método, para que campos ainda sejam matrizes de objeto, a menos que especificamente digitado.
É possível inicializar várias dimensões de matriz, mas todos os pares aninhados devem conter o mesmo número de membros. Portanto, dois-dimensão exemplos irão funcionar.
Os dois exemplos a seguir ambos irão criar uma matriz bidimensional inteiro:
Dim TwoDimension1(,) = {{1, 2}, {3, 4}}
Dim TwoDimension2 = {{1, 2}, {3, 4}}
Para matrizes de dimensão única, a sintaxe é muito semelhante ao código anterior e todos os códigos existentes continuarão a funcionar com algumas exceções.
Dim a() = {1, 2, 3}
A instrução anterior, o tipo de matriz será inferido da lista inicializador. Isso resultará em uma matriz de inteiros que estão sendo inferida. No passado, esses simplesmente seriam matrizes de objetos como nós não seria ter inferido qualquer tipo de matriz na lista inicializador. Se você estiver usando qualquer código que verifica o tipo, usa a reflexão ou que contenha várias sobrecargas incluindo tipos de matriz de objetos, isso pode produzir resultados diferentes agora. Isso pode exemplos de métodos de ligação tardia.
Matrizes multidimensionais
Para poder inicializar uma matriz multidimensional, as dimensões de devem corresponder à contagem item dentro da lista de inicializador. Se esses não são iguais e todos os itens aninhados na lista de inicialização não têm uma contagem de item consistente, e em seguida, ocorrerá um erro de sintaxe:
Dim TwoDimension2 = {{1, 2}, {3, 4}}
'Valid 2 dimension integer(,) array inferred
Dim TwoDimension2Invalid(,) = {{1}, {3}}
'Invalid – dimension and element count mismatch
Dim TwoDimension2Invalid1(,) = {{1, 2}, {3}}
'Invalid:element count not consistent in Initializer List
Isso significa que usando a sintaxe semelhante como antes, é possível inicializar padrão corrigidos matrizes dimensionais.
Inicialização de matriz denteada
No entanto, isso significa que para uma matriz denteada (uma matriz de matrizes), essa sintaxe não funcionará como está. Para permitir os inicializadores de matriz denteada, é necessário que você encapsular cada uma das listas de membros em parênteses:
Sub Main()
'Incorrect Jagged Array syntax
Dim JaggedDimensionIncorrect()() = {{1,2},{3,4,5}}
'Correct Jagged Array syntax
Dim JaggedDimension1()() = {({1,2}),({3,4,5})}
End Sub
O exemplo anterior resultará no seguinte:
- JaggedDimension1(0) que contém a matriz de inteiro com elementos 1,2
- JaggedDimension1(1) que contém a matriz de inteiro com elementos 3,4,5
A inferência de tipo matriz funcionará para os tipos de matriz aninhados. Aqui está um exemplo ligeiramente mais complexo:
Dim JaggedDimension1() = {({1, 2}), ({3.1, 4.2, 5.3})}
Isso resultará em JaggedDimension1 sendo inferido como Object() e os membros sendo do tipo Integer() e Double().
Inferência de matriz e o comportamento esperado
Portanto, você procurar na lista de inicializador como uma matriz inferida. Não! A lista de inicializador não é um tipo concreto como você pode pensar;Ele é uma representação sintática de uma lista de membros, que se torna um tipo específico, dependendo do contexto que é usado no.
O exemplo de código a seguir mostra que podemos usar o {,} sintaxe para:
1. Inferir e inicializar uma matriz de inteiros:
Dim a = {1, 2, 3} 'Infers Integer Array
Isso funciona como nenhum tipo de destino for especificado e ele infere o tipo com base no tipo dos membros de lista de inicializador dominante.
2. Inicialize uma matriz de tipo diferente:
Dim b As Single() = {1, 2, 3}
'Will convert each integer value into single
Isso funcionará como inicializamos uma única matriz com valores de um, dois e três. A lista de inicializador tem não tipo intrínseco por si só.
Mas o seguinte é esperado falha:
Dim a = {1, 2, 3} 'Infers Integer()
Dim c As Single() =
a 'No conversion between Single() and Integer()
Isso pode parecer um pouco estranho, mas variável um é inferido como uma matriz de inteiros e inicializado com valores um, dois e três. C variável é declarada como uma matriz simples. No entanto, não há nenhuma conversão entre uma matriz única e uma matriz de inteiro, que fará com que o erro de sintaxe.
Uso de inicializador de matriz autônomo
A matriz inicializador lista também pode ser usada em um contexto autônomo, nesse caso, ele terá não têm um tipo de destino especificado e funcionará como uma matriz do tipo dominante dos membros da lista de inicialização.
Isso permite que alguns cenários interessantes não disponíveis anteriormente. Um exemplo poderia ser um método que leva em uma matriz de itens que você deseja usar para inicializar uma estrutura de dados. Onde o método é chamado determina os valores padrão diferentes, que são usados como argumentos de chamada, conforme mostrado no do Figura 5.
Nesse caso, criamos uma matriz local para cada chamada, simplesmente para passar um tipo de matriz para o método. Com o novo recurso de uso autônomo, é possível evitar a criar locais desnecessários para este tipo de cenário e você pode simplesmente usar autônomo inicializador lista para passar os tipos de matriz.
A lista de inicializador no cenário de uso autônomo encaixa para um tipo de matriz inferido. Portanto, um cenário de uso autônomo, a lista de inicialização pode ser pensada como uma matriz literal. Isso evitará a declarar itens que só será usado em casos limitados, como chamadas de método individuais.
Figura 5 diferentes valores padrão usados como argumentos de chamada
Module Module1
Sub InitializeMethod(ByVal x As String())
'....
End Sub
Sub Main()
Dim i As Integer = 1
Select Case I
Case 1
Dim Array1 As String() = {"Item1", "Item2"}
InitializeMethod(Array1)
Case 2
Dim Array1 As String() = {"Item11", "Item12"}
InitializeMethod(Array1)
End Select
End Sub
End Module
Use com outros recursos 2010
Um dos recursos da versão 2010 do produto é multi-direcionamento. Embora esse recurso existia na versão 2008, alguns aprimoramentos foram feitos que permitem que muitos dos recursos de idioma da versão de produto a ser usado em versões direcionadas para baixo 2010 (2.0, 3.0 e 3.5 destinos). Portanto, você pode usar essa funcionalidade aprimorada para a coleta e inicializadores de matriz para seus aplicativos existentes se você estiver usando a versão 2010 do produto. Isso lhe permite simplificar o código-fonte existente e tirar proveito das novas funcionalidades idioma.
Portanto, quando você usa essa nova funcionalidade, há possíveis para a quebra código existente? A resposta é Sim, há alguns potencial de quebras de compatibilidade com versões anteriores, mas isso é limitado para alguns cenários onde os benefícios superam a alteração significativa original e a funcionalidade existente pode ser retida facilmente:
Dim x1() = {1, 2, 3}
Em versões anteriores, linha de código anterior causaria uma matriz Object, mas com Visual Studio 2010, isso será tipo inferido para o tipo dominante dos elementos — nesse caso, Integer(). Esse será o caso, independentemente de se você está direcionando 4.0 ou para baixo-direcionamento para uma versão anterior. Se você tiver o código que está esperando um tipo específico de matriz Object, esse código poderá falhar. Ele pode ser corrigido facilmente, explicitamente especificando o tipo de destino:
Dim x1() As Object = {1, 2, 3}
A exceção a esse comportamento é se não há nenhum tipo dominante para os elementos:
Dim x1() = {1, 2.2, "test"}
Isso manterá o comportamento anterior, resultando em 1 de x, sendo uma matriz de objeto.
Aplicativo de fácil
Inicializadores de coleção são uma ótima adição para o idioma. Eles permitem uma sintaxe mais concisa para inicializar a estrutura e tipos de coleção definida pelo usuário. Com mínimas alterações, essa sintaxe pode ser aplicada ao código existente facilmente.
A funcionalidade é ideal para poder usar outros recursos de idioma, como métodos de extensão, ativar a redução do uso da sintaxe para quaisquer tipos de coleção. Essa redução no código clichê usado anteriormente torna o código menor e mais fáceis de manter.
O comportamento de inicializador de matriz foi alterado um pouco, resultando na implementação de inferência de tipo de matriz e a funcionalidade aprimorada, permitindo que uso autônomo de matrizes e melhorou a capacidade de inicializar matrizes multidimensionais e irregulares sobre versões anteriores.
Praticamente todos os aplicativos usa matrizes ou coleções e esse recurso podem ser usado em praticamente qualquer projeto.
Adrian Spotty Bowles desenvolveu usando cada versão do Visual Basic e conseguiu encontrar seu caminho para Redmond, Wash., onde trabalha na equipe de produto do Visual Basic como um testador de engenheiro de design de software com foco no compilador do Visual Basic. Durante o lançamento do Visual Basic 2008, ele trabalhou em muitos dos recursos de linguagem, incluindo extensão Methods.You pode entrar Bowles em do Abowles@microsoft.com.