Partilhar via

Alterações mais recentes de 2010 Visual Basic

  • Artigo

A tabela a seguir lista todas as alterações que podem impedir que um aplicativo que foi criado em Visual Basic 2008 de compilação em Visual Basic 2010, ou que pode alterar o comportamento de tempo de execução.

<strong>Categoria</strong>

Assunto

Descrição

Inferência de tipo em matriz

As regras para inferência para inicializadores de matrizes foram alteradas.

Por exemplo, Dim x() = {1, 2, 3} infere como tipo de Integer.

Dim x() = {1, 2.2, "3"}causa um erro do compilador quando Option Strict é definida como On.

Em Visual Basic 2008, quando você declara uma variável de matriz, mas omite o tipo de elemento, o compilador pressupõe que o tipo de elemento a ser Object. Visual Basic 2010apresenta a inferência de tipos de elemento de matriz e infere o tipo de elemento para ser do tipo dominante da matriz literal.

Se não houver nenhum tipo dominante, digite Object é assumido. Nesse caso, se Option Strict for definido como On, ocorre um erro do compilador.

Para obter mais informações, consulte Matrizes no Visual Basic.

Conflitos de nomes

Tipos em namespaces importados em nível de arquivo têm prioridade sobre tipos em namespaces importados no nível do projeto.

Se dois namespaces contêm um tipo com o mesmo nome, se um tipo que está localizado em um namespace importado no nível do projeto e o outro tipo com o mesmo nome está localizado em um namespace importado no nível de arquivo, Visual Basic 2010 vincula-se ao tipo no namespace importado no nível de arquivo. Versões anteriores vincula o tipo do namespace importado no nível do projeto. Para obter mais informações, consulte Declaração Imports (Tipo e Namespace .NET).

Consulta palavras-chave como identificadores

Usando uma palavra-chave de consulta como um identificador pode produzir resultados inesperados.

O Visual Basic compilador aceita palavras-chave como nomes de identificador em vários contextos. Devido as novas regras de continuação de linha de implícito adicionado no Visual Basic 2010, você pode encontrar um erro se você usar uma palavra-chave como um nome de elemento em uma consulta LINQ que omite caracteres de continuação de linha.

Por exemplo, o exemplo a seguir usa a Aggregate palavra-chave como um nome de identificador. Se o aggregate identificador imediatamente segue uma consulta, ele é considerado parte dessa consulta devido às regras de continuação de linha implícita para cláusulas de consulta. Neste exemplo,  é gerado um error de compilador.

Dim aggregate = 0
Dim numbers = {1, 2, 3, 4, 5}
Dim query As IEnumerable(Of Integer)

While aggregate < 5

    query = From i In numbers
            Skip aggregate
            Take 1
            Select i
    aggregate += 1

End While

Para certificar-se de que uma linha não está implicitamente incluída na linha anterior do código, adicione uma quebra de linha extra antes da linha de código, conforme mostrado no exemplo a seguir.

    query = From i In numbers
            Skip aggregate
            Take 1
            Select i

    aggregate += 1

Para obter mais informações sobre a continuação de linha implícito, consulte Instruções no Visual Basic.

Módulos

Módulos são compilados como MustInherit.

Agora, módulos são compilados como MustInherit. Isso não afeta o comportam dos módulos, mas ele pode afetar o código que usa a reflexão para examinar os tipos criados pela Visual Basic Module instrução. Para obter mais informações, consulte Declaração de Módulo.

Expressões Lamdba

As expressões lambda anônimo geram tipos exclusivos.

Os tipos delegate anônimo gerados para expressões lambda agora são garantidos como exclusivo. Isso pode afetar o código que avalia os tipos delegate anônimos por igualdade, tal como o código no exemplo a seguir.

Dim x = Function(a As Integer) a + 1
Dim y = Function(b As Integer) b + 1

' Returns True in Visual Basic 2008. Returns False in Visual Basic 2010.
Dim t = x.GetType().Equals(y.GetType())

Para obter mais informações, consulte Expressões Lambda (Visual Basic).

Variação em interfaces genéricas

Ambigüidade pode ser introduzida com interfaces genéricas.

Visual Basic 2010suporta a variação (covariância e/contravariância) em interfaces genéricas. Quando você implementar várias interfaces e uma interface é derivada do outro, você poderá encontrar um erro de aviso sobre interfaces ambíguos.

Para obter mais informações, consulte Variação em Interfaces genéricas (C# e Visual Basic).

Métodos de extensão

Métodos locais têm preferência sobre os métodos de extensão.

Se um método de extensão é definido com o mesmo nome e parâmetros como um método definido para um tipo, o compilador vincula-se ao método local em vez do método de extensão. Esse comportamento corrige o comportamento de vinculação incorreta no Visual Basic 2008. Para obter mais informações, consulte Métodos de extensão (Visual Basic).

Tipos de valor anulável

Teste de um tipo de valor nulo para Nothing usando o = operador, conforme mostrado no código a seguir produz um erro do compilador.

Dim i? As Integer
If i = Nothing Then
  ' ...
End If

Se você testar um tipo de valor nulo para Nothing usando o = operador, o resultado é False , mesmo se o tipo de valor nulo for Nothing, que é mais provável que não o pretendido resultado. Use o Is operador em vez disso, conforme mostrado no exemplo a seguir.

Dim i? As Integer
If i Is Nothing Then
  ' ...
End If

Invocação implícita de funções sem parâmetros ou propriedades

Se uma função ou propriedade retorna um valor indexável como, por exemplo, uma seqüência de caracteres ou uma matriz, você pode usar a sintaxe abreviada para se referir a um elemento de valor de retorno pelo índice somente se não houver nenhum sobrecargas para a função ou propriedade.

Considere uma função sem parâmetros ou propriedade que retorna um valor indexável, conforme mostrado no exemplo a seguir.

Class Sample

    Public Function GetValue() As String
        Return "Default Value"
    End Function

End Class

Você pode usar a sintaxe abreviada para se referir a um elemento de valor de retorno pelo índice, conforme mostrado no exemplo a seguir.

Dim o As Object = New Sample()
' Returns "D" if no overloads exist for the GetValue function.
Dim val = o.GetValue(0)

Visual Basic 2008permite que isso reduziu sintaxe para chamadas de ligação tardia, mesmo se existirem de sobrecargas para a função ou propriedade. Em Visual Basic 2010, você pode usar a sintaxe abreviada para se referir a um elemento de valor de retorno pelo índice somente se não houver nenhum sobrecargas para a função ou propriedade.

Classrestrições

O Class restrição não será considerada.

Visual Basic 2008infere o Class restrição para um parâmetro genérico se ele é restrito por um segundo parâmetro genérico que é restringido pela Class restrição. Visual Basic 2010Não há mais infere que um parâmetro genérico "inherits" o Class restrição. Isso ocorre porque o primeiro parâmetro genérico pode ser instanciado com um tipo que implementa uma interface, mas não é uma classe. Interfaces satisfazem a Class restrição.

Para certificar-se de que um parâmetro genérico é restrito como uma classe, adicione a Class restrição conforme mostrado no exemplo a seguir.

    ' The following code causes a compiler error.
    ' Function RefEquals(Of T1 As T2, T2 As Class)(ByVal x As T1, ByVal y As T2) As Boolean
    '     Return y Is x
    ' End Function

    ' The following code is valid in Visual Basic 2010.
    Function RefEquals(Of T1 As {T2, Class}, T2 As Class)(ByVal x As T1, ByVal y As T2) As Boolean
        Return y Is x
    End Function

Para obter mais informações, consulte Tipos genéricos no Visual Basic (Visual Basic).

Métodos de classe parcial

Se um método que foi restringido parâmetros genéricos é declarado em mais de uma classe parcial, todas as declarações do método devem ter restrições idênticas.

Você pode declarar um método que possui parâmetros genéricos em mais de uma classe parcial. Em Visual Basic 2008, o compilador nem sempre exigem as restrições de parâmetros genéricos para corresponder a todas as declarações de método. Visual Basic 2010requer que todas as declarações do método tem restrições idênticas.

Para obter mais informações, consulte Tipos genéricos no Visual Basic (Visual Basic).

Árvores de expressão de expressões lambda

Removida a conversão boxing desnecessário de instâncias de tipos de parâmetro genérico

Em Visual Basic 2008, dentro de uma árvore de expressão de uma expressão lambda, se o tipo de parâmetro genérico é restrito a uma interface, invocando um método em uma instância desse tipo sempre caixas instância. Em Visual Basic 2010, a instância é somente in a box quando necessário.

Para obter mais informações sobre a conversão boxing e unboxing, consulte Especificação da Linguagem Visual Basic.

As expressões lambda e árvores de expressão

Uma árvore de expressão de uma expressão lambda pode ser retornada de uma árvore de expressão de uma expressão lambda.

Em Visual Basic 2008, se uma expressão lambda projeta uma expressão lambda a uma árvore de expressão, o compilador não executa a conversão em alguns casos. O Visual Basic 2010 compilador corretamente projeta as expressões lambda como árvores de expressão, se a conversão ocorre dentro de uma expressão lambda.

Consulte também

Conceitos

O que há de novo no Visual Basic 2010

Outros recursos

Guia de Introdução ao Visual Basic