Novedades de Visual Basic 2010

Lenguaje y Compilador Visual Basic 2010:

1. Propiedades Auto Implementadas:
   • Public Property Nombre As String = “Jorge Pedraza“
2. Inicializadores de Colección:
   • Dim Nombres As New List(Of String) From {“Jorge“,”Mario“,”Pedro“}
3. Continuación de Linea Implícita:
   • En la actualidad con Visual Basic 2008 o inferior permite la continuación de una sentencia en varias líneas usando el caracter underscore “_“.
     Dim NombreVar As String
     NombreVar = “Jorge“
     MsgBox(“Hola ” & NombreVar _
             & “. Como esta tú?“).
   • Ahora en Visual Basic 2010 encontramos “Continuación de Línea Implícita” el cual maneja el mismo principio representado arriba, pero con opción de otros caracteres especificos:
     • Despues de la Coma “,“
     • Despues de Abrir un Paréntesis “(” o antes de cerrar un Paréntesis “)”
     • Despues de Abrir una llave “{“ o antes de cerrar un llave “}“
     • Despues del operador de Concatenación “&“
     • Despues de los operadores de asignación “=” , “&=” , “:=“ , ”+=” , ”-=” , “*=” , “/=” , “\=” , “^=” , “<<=” , “>>=“
     • Despues de los operadores Binarios “+“, “-” , “/” , “*” , “Mod” , “<>” , “<” , ”>” , “<=” , “>=” , “^” , “>>” , “<<” , ” And” , ”AndAlso” , “Or” , “OrElse” , “Like” , “Xor” dentro de una expresión.
     • Despues del operador Is y IsNot.
     • Dentro de la sentencia With …. End With, cuando inicialice un valor para un tipo; se puede usar despues del “=“
     • Despues de un calificador de propiedad eje de  XML “.“ 0 “.@” o “…” sin embargo debe incluir el caracter “_” cuando especifique un miembro calificador, cuando use la palabra With.
     • Despues del Caracter menor “<” o antes del mayor “>” cuando especifique un atributo, sin embargo debe incluir en la línea de continuación el caracter “_”  cuando especifique el nivel del ensamblado o nivel del modulo de un atributo.
     • Antes y Despues del operador de consulta Aggregate, Distinct, From, Group By, Group Join, Join, Let, Order By, Select, Skip, Skip While, Take, Take While,  Where, In, Into, On, Ascending, y Descending.  No puede Interrupir una línea en medio de palabras de operador de consulta que este compuesta por varias palabras Order By, Group Join, Take While y Skip While.
     • Despues de la palabra In en un sentencia For Each
     • Despues de la palabra From en la inicialización de una colección
4. Expresiones Lambda de Varias Líneas y Subrutinas: 

Función:

Dim incremento1 = Function(x) x + 1

Dim incremento2 = Function(x)   ‘Aquí se observa la novedad
                          Return x + 2
                          End Function

Console.WriteLine(incremento1(1)) ‘Escribe el Valor 2
Console.WriteLine(incremento2(2)) ‘Escribe el valor 4
Subrutina:
Dim escribirlinea1 = Sub(x) Console.WriteLine(x)

Dim escribirlinea2 = Sub(x)  ‘Aquí se observa la novedad
                           Console.WriteLine(x)
                           End Sub
escribirlinea1(“Hola”)       ‘Escribe “Hola”
escribirliena2(“Mundo”)  ‘Escribe “Mundo”

5. Nueva Opción de línea de comando para especificar una versión de lenguaje (/Langversion):
   •  Hace que el compilador solo acepte sintaxis de una versión de lenguaje visual basic especificado.
     • vbc /langversion:9.0 Ejemplo.vb 
6. Soporte de Equivalencia de Tipos:
   • Ahora puede implimentar una aplicación que ha incrustado información de tipo en vez de información de tipo que están importada desde un ensamblado de Interoperabilidad Primaria (PIA). Con información de tipos incrustada, su aplicación puede usar tipos en un tiempo de ejecución sin necesidad de una referencia  a ensamblado en tiempo de ejecución.
7. Soporte Dinámico:
   • Visual Basic 2010 se une a los objetos de lenguaje dinámico como IronPython y IronRuby (Previamente debe tener referenciadas las librerias).
     Dim py = Python.CreateRuntime()
     Dim matlib As Object = py.UseFile(“math.py“)
     Dim M1 = 2
     Dim M2 = 3
     matlib.PowerOf(M1,M2)
8. Covarianza y contra varianza:
   • Covarianza (Covariance) : Permite utilizar un tipo más derivado de lo especificado por el parámetro genérico. Un ejemplo de esto, son las Interfaz Genericas como : IEnumerable (Of (T)), IEnumerator (Of (T)), IQueryable (Of (T)), IGrouping (Of (TKey, TElement)) Donde T, Tkey, TElement son Convariante.
     Dim Cadenas As IEnumerable(Of String) = New List(Of String)
     Dim Objetos As IEnumerable(Of Object) = strings
     En versiones anteriores de .NET framework, este codigo causa error de compilación con Option Strict On. pero ahora puede usar strings en vez de Objects, como se muestra en el ejemplo previo, porque la interfaz IEnumerable (Of (T)) es covariante.  La varianción en tipo generico es soportado por solo tipo por referencia; o sea que los tipos de valor no soportar la varianción.
   • Contra Varianza (Contravariance) : Permite usar un tipo menos derivado. Un ejemplo de esto son las interfaz genericas como: IComparer (Of (T)), IEqualityComparer (Of (T)), IComparable (Of (T)). Para Mostrar la Contra varianza, asume que tiene creada una clase BaseComparer para comparar instancias de la clase BaseClass. La Clase BaseComparer implementa interfaz IEqualityComparer. Porque esta Interfaz es ahora contravariante:

‘ Simple Herencia de Clases.
Class BaseClass
End Class

Class DerivedClass
    Inherits BaseClass
End Class

Class BaseComparer ‘ Clase Comparar.
    Implements IEqualityComparer(Of BaseClass)

    Public Function Equals1(ByVal x As BaseClass,
                            ByVal y As BaseClass) As Boolean _
                            Implements IEqualityComparer(Of BaseClass).Equals
        Return (x.Equals(y))
    End Function

    Public Function GetHashCode1(ByVal obj As BaseClass) As Integer _
        Implements IEqualityComparer(Of BaseClass).GetHashCode
        Return obj.GetHashCode
    End Function
End Class
Sub Prueba()
    Dim baseComparer As IEqualityComparer(Of BaseClass) = New BaseComparer
    ‘ Conversion Implicita de IEqualityComparer(Of BaseClass) a 
    ‘ IEqualityComparer(Of DerivedClass).
    Dim childComparer As IEqualityComparer(Of DerivedClass) = baseComparer
End Sub

Entorno de Desarrollo Integrado:

1. Modo de Sugerencia de IntelliSense: IntelliSense ahora suministra dos alternativas para completación de sentencia intelliSense: Modo completación y Modo sugerencia.
   • Modo Completación:.  Modo Sugerencia:
2. Generar desde Uso: La característica generar desde uso, permite usar miembros y clases, antes de definirlas. Puede generar codigo auxiliar de una clase, constructor, metodo, propiedad, campo, o enumerado que desea utilizar, pero que no está definido previamente. Puede generar miembros y tipos sin dejar la ubicación actual en codigo.
   •  
3. Resaltador de Referencia: Esta mejora permite resaltar todas las instancias de un simbolo especifico en un documento haciendo click en este simbolo. Para navegar las referencias, puede usar CRTL+SHIFT+FLECHA ABAJO o CRTL+SHIFT+ FLECHA ARRIBA.
   • 
4. (Desplácese a) Navegate To: Puede usar la caracteristica Navegate To para buscar un simbolo o archivo de codigo fuente.
   •