Cambios problemáticos en Visual Basic 2008

Artículo
10/07/2008

Actualización: Julio de 2008

En la tabla siguiente se enumeran todos los cambios que pueden impedir la compilación en Visual Studio 2008 de una aplicación creada en Visual Studio 2005 o que pueden cambiar su comportamiento en tiempo de ejecución.

Category	Problema	Descripción
Tipos que aceptan valores NULL	La ampliación de T a T? es una conversión predefinida en Visual Studio 2008.	En Visual Studio 2005, puede crear una conversión definida por el usuario para permitir la ampliación de T a Nullable(Of T). Como parte de la mayor compatibilidad con los tipos que aceptan valores NULL en Visual Studio 2008, esta conversión está predefinida. Dado que la resolución de sobrecarga tiene en cuenta las conversiones predefinidas y las conversiones definidas por el usuario, se puede producir una ambigüedad si existen ambas. Por tanto, el código que contiene una conversión de ampliación definida por el usuario de T a T? es potencialmente ambiguo en Visual Studio 2008. Por ejemplo, en el código siguiente, la llamada a c3.Sub1 funciona en Visual Studio 2005 pero genera un error del compilador en Visual Studio 2008. Module Module1 Sub Main() Dim c3 As New Class3 Dim sh As Short = 2 ' The following statement compiles in Visual Studio 2005, ' but causes an error in Visual Studio 2008. 'c3.Sub1(sh) End Sub End Module Class Class1 Public Shared Widening Operator CType(ByVal s As _ Nullable(Of Short)) As Class1 Return New Class1() End Operator End Class Class Class2 Public Shared Widening Operator CType(ByVal n As Integer) As Class2 Return New Class2() End Operator End Class Class Class3 Sub Sub1(ByVal c As Class1) End Sub Sub Sub1(ByVal c As Class2) End Sub End Class Para resolver este problema, puede quitar la conversión definida por el usuario o puede convertir explícitamente a Class1 o Class2: `c3.Sub1(CType(sh, Class1))`
Resolución de sobrecarga	Se han corregido las diferencias en la resolución de sobrecarga entre las clases genéricas y no genéricas.	Un error en Visual Studio 2005 puede hacer que el comportamiento de la resolución de sobrecarga en las clases genéricas sea diferente del comportamiento en las clases no genéricas. En el ejemplo siguiente, Class1 y Class2 son idénticos salvo en que Class2 incluye un parámetro genérico definido. La llamada a c1.Sub1 en Main es ambigua porque el argumento pasado puede enlazar a cualquier sobrecarga de Sub1 en Class1. La ambigüedad produce un error del compilador en Visual Studio 2005 y Visual Studio 2008. La llamada a c2.Sub1 debe generar el mismo error, pero en Visual Studio 2005 no lo hace. En su lugar, el método enlaza a la sobrecarga sin restricciones de Sub1 en Class2. Este problema se ha corregido en Visual Studio 2008. Ambas llamadas generan errores del compilador debido a la ambigüedad. Esto queda reflejado en el ejemplo de código siguiente: Module Module1 Sub Main() Dim c1 As New Class1 Dim c2 As New Class2(Of String) ' The following statement causes a compiler error in both ' Visual Studio 2005 and Visual Studio 2008. 'c1.Sub1(New Nullable(Of Integer)) ' The following statement causes a compiler error only ' in Visual Studio 2008. 'c2.Sub1(New Nullable(Of Integer)) End Sub End Module Class Class1 Sub Sub1(Of T)(ByVal arg As T) Console.WriteLine("Unconstrained Sub1 in Class1") End Sub Sub Sub1(Of T As Structure)(ByVal arg As Nullable(Of T)) Console.WriteLine("Constrained Sub1 in Class1") End Sub End Class Class Class2(Of U) Sub Sub1(Of T)(ByVal arg As T) Console.WriteLine("Unconstrained Sub1 in Class2") End Sub Sub Sub1(Of T As Structure)(ByVal arg As Nullable(Of T)) Console.WriteLine("Constrained Sub1 in Class2") End Sub End Class Para resolver este problema, puede cambiar las sobrecargas para que no sean ambiguos o puede especificar explícitamente los argumentos de tipo: `c1.Sub1(Of Integer?)(New Nullable(Of Integer)) c2.Sub1(Of Integer?)(New Nullable(Of Integer))`
Resolución de sobrecarga	La resolución de sobrecarga con parámetros genéricos y parámetros ParamArray genera diferentes resultados en Visual Studio 2008.	El objetivo de la resolución de sobrecarga consiste en intentar seleccionar el método candidato cuyos parámetros coinciden más estrechamente con los tipos de argumentos que se pasan al método. En el ejemplo de esta sección, Sub1 se sobrecarga en una jerarquía de herencia y se llama con argumentos de tipo Integer y Short. Las reglas de resolución de sobrecarga en Visual Studio 2005 y Visual Studio 2008 especifican que las coincidencias directas son mejores coincidencias que las que requieren parámetros ParamArray. Sin embargo, al utilizar las reglas de resolución de sobrecarga de Visual Studio 2005, se produce un error en la inferencia de tipos para el candidato de sobrecarga en la clase derivada, Class2, porque Y no puede ser Integer y Short a la vez y se requieren coincidencias exactas. Si los argumentos sh y n fuesen del mismo tipo, se preferiría Sub1 de Class2 antes que el candidato de Class1, que tiene un parámetro ParamArray. Sin embargo, dado que ambos argumentos tienen tipos diferentes, se selecciona la sobrecarga de clase base de Class1. T se infiere como Integery Short se amplía en el parámetro ParamArrayp. Visual Studio 2008 utiliza un nuevo algoritmo que selecciona las mismas sobrecargas que Visual Studio 2005, excepto en este caso concreto. En Visual Studio 2008, el algoritmo determina que Integer es el tipo dominante en este ejemplo, porque Short se amplía a Integer. El parámetro de tipo Y de la clase derivada se infiere como Integer y Short se amplía a Integer. Como resultado, se llama a Sub1 en la clase derivada. `Module Module1 Sub Main() Dim c2 As New Class2 Dim n As Integer Dim sh As Short c2.Sub1(n, sh) End Sub Class Class1 Sub Sub1(Of T)(ByVal arg1 As T, ByVal ParamArray p() As Integer) Console.WriteLine("Visual Studio 2005 calls Sub1 " & _ "in the base class.") End Sub End Class Class Class2 : Inherits Class1 Overloads Sub Sub1(Of Y)(ByVal arg1 As Y, ByVal arg2 As Y) Console.WriteLine("Visual Studio 2008 calls Sub1 " & _ "in the derived class.") End Sub End Class End Module` Puede exigir el comportamiento de Visual Studio 2005 mediante la conversión de la variable c2 al tipo C1ass1 antes de llamar a Sub1 o mediante la transferencia del argumento sh como una matriz. `' You can cast variable c2 to Class1 in order to force Visual ' Studio 2005 behavior. CType(c2, Class1).Sub1(n, sh) ' Alternatively, you can pass sh as an array. c2.Sub1(n, New Integer() {sh})`

Category

Problema

Descripción

Tipos que aceptan valores NULL

La ampliación de T a T? es una conversión predefinida en Visual Studio 2008.

En Visual Studio 2005, puede crear una conversión definida por el usuario para permitir la ampliación de T a Nullable(Of T). Como parte de la mayor compatibilidad con los tipos que aceptan valores NULL en Visual Studio 2008, esta conversión está predefinida.

Dado que la resolución de sobrecarga tiene en cuenta las conversiones predefinidas y las conversiones definidas por el usuario, se puede producir una ambigüedad si existen ambas. Por tanto, el código que contiene una conversión de ampliación definida por el usuario de T a T? es potencialmente ambiguo en Visual Studio 2008.

Por ejemplo, en el código siguiente, la llamada a c3.Sub1 funciona en Visual Studio 2005 pero genera un error del compilador en Visual Studio 2008.

Module Module1

    Sub Main()
        Dim c3 As New Class3
        Dim sh As Short = 2
        ' The following statement compiles in Visual Studio 2005,
        ' but causes an error in Visual Studio 2008.
        'c3.Sub1(sh)
    End Sub

End Module

Class Class1
    Public Shared Widening Operator CType(ByVal s As  _
                                          Nullable(Of Short)) As Class1
        Return New Class1()
    End Operator
End Class

Class Class2
    Public Shared Widening Operator CType(ByVal n As Integer) As Class2
        Return New Class2()
    End Operator
End Class

Class Class3
    Sub Sub1(ByVal c As Class1)
    End Sub

    Sub Sub1(ByVal c As Class2)
    End Sub
End Class

Para resolver este problema, puede quitar la conversión definida por el usuario o puede convertir explícitamente a Class1 o Class2:

c3.Sub1(CType(sh, Class1))

Resolución de sobrecarga

Se han corregido las diferencias en la resolución de sobrecarga entre las clases genéricas y no genéricas.

Un error en Visual Studio 2005 puede hacer que el comportamiento de la resolución de sobrecarga en las clases genéricas sea diferente del comportamiento en las clases no genéricas. En el ejemplo siguiente, Class1 y Class2 son idénticos salvo en que Class2 incluye un parámetro genérico definido. La llamada a c1.Sub1 en Main es ambigua porque el argumento pasado puede enlazar a cualquier sobrecarga de Sub1 en Class1. La ambigüedad produce un error del compilador en Visual Studio 2005 y Visual Studio 2008.

La llamada a c2.Sub1 debe generar el mismo error, pero en Visual Studio 2005 no lo hace. En su lugar, el método enlaza a la sobrecarga sin restricciones de Sub1 en Class2.

Este problema se ha corregido en Visual Studio 2008. Ambas llamadas generan errores del compilador debido a la ambigüedad. Esto queda reflejado en el ejemplo de código siguiente:

Module Module1

    Sub Main()
        Dim c1 As New Class1
        Dim c2 As New Class2(Of String)
        ' The following statement causes a compiler error in both 
        ' Visual Studio 2005 and Visual Studio 2008.
        'c1.Sub1(New Nullable(Of Integer))

        ' The following statement causes a compiler error only
        ' in Visual Studio 2008.
        'c2.Sub1(New Nullable(Of Integer))
    End Sub

End Module

Class Class1
    Sub Sub1(Of T)(ByVal arg As T)
        Console.WriteLine("Unconstrained Sub1 in Class1")
    End Sub

    Sub Sub1(Of T As Structure)(ByVal arg As Nullable(Of T))
        Console.WriteLine("Constrained Sub1 in Class1")
    End Sub
End Class

Class Class2(Of U)
    Sub Sub1(Of T)(ByVal arg As T)
        Console.WriteLine("Unconstrained Sub1 in Class2")
    End Sub

    Sub Sub1(Of T As Structure)(ByVal arg As Nullable(Of T))
        Console.WriteLine("Constrained Sub1 in Class2")
    End Sub
End Class

Para resolver este problema, puede cambiar las sobrecargas para que no sean ambiguos o puede especificar explícitamente los argumentos de tipo:

c1.Sub1(Of Integer?)(New Nullable(Of Integer))
c2.Sub1(Of Integer?)(New Nullable(Of Integer))

Resolución de sobrecarga

La resolución de sobrecarga con parámetros genéricos y parámetros ParamArray genera diferentes resultados en Visual Studio 2008.

El objetivo de la resolución de sobrecarga consiste en intentar seleccionar el método candidato cuyos parámetros coinciden más estrechamente con los tipos de argumentos que se pasan al método. En el ejemplo de esta sección, Sub1 se sobrecarga en una jerarquía de herencia y se llama con argumentos de tipo Integer y Short.

Las reglas de resolución de sobrecarga en Visual Studio 2005 y Visual Studio 2008 especifican que las coincidencias directas son mejores coincidencias que las que requieren parámetros ParamArray. Sin embargo, al utilizar las reglas de resolución de sobrecarga de Visual Studio 2005, se produce un error en la inferencia de tipos para el candidato de sobrecarga en la clase derivada, Class2, porque Y no puede ser Integer y Short a la vez y se requieren coincidencias exactas. Si los argumentos sh y n fuesen del mismo tipo, se preferiría Sub1 de Class2 antes que el candidato de Class1, que tiene un parámetro ParamArray. Sin embargo, dado que ambos argumentos tienen tipos diferentes, se selecciona la sobrecarga de clase base de Class1. T se infiere como Integery Short se amplía en el parámetro ParamArrayp.

Visual Studio 2008 utiliza un nuevo algoritmo que selecciona las mismas sobrecargas que Visual Studio 2005, excepto en este caso concreto. En Visual Studio 2008, el algoritmo determina que Integer es el tipo dominante en este ejemplo, porque Short se amplía a Integer. El parámetro de tipo Y de la clase derivada se infiere como Integer y Short se amplía a Integer. Como resultado, se llama a Sub1 en la clase derivada.

Module Module1

    Sub Main()
        Dim c2 As New Class2
        Dim n As Integer
        Dim sh As Short
        c2.Sub1(n, sh)
    End Sub

    Class Class1
        Sub Sub1(Of T)(ByVal arg1 As T, ByVal ParamArray p() As Integer)
            Console.WriteLine("Visual Studio 2005 calls Sub1 " & _
                              "in the *base* class.")
        End Sub
    End Class

    Class Class2 : Inherits Class1
        Overloads Sub Sub1(Of Y)(ByVal arg1 As Y, ByVal arg2 As Y)
            Console.WriteLine("Visual Studio 2008 calls Sub1 " & _
                              "in the *derived* class.")
        End Sub
    End Class

End Module

Puede exigir el comportamiento de Visual Studio 2005 mediante la conversión de la variable c2 al tipo C1ass1 antes de llamar a Sub1 o mediante la transferencia del argumento sh como una matriz.

' You can cast variable c2 to Class1 in order to force Visual
' Studio 2005 behavior.
CType(c2, Class1).Sub1(n, sh)
' Alternatively, you can pass sh as an array.
c2.Sub1(n, New Integer() {sh})