Visual Basic .NET Language
Características de Visual Basic 14.0

Introducción

Operador condicional nulo

Para evitar verificaciones nulas, el ?. El operador ha sido introducido en el idioma.

La vieja sintaxis verbosa:

If myObject IsNot Nothing AndAlso myObject.Value >= 10 Then

Puede ahora ser reemplazado por el conciso:

If myObject?.Value >= 10 Then

El ? El operador es particularmente poderoso cuando tienes una cadena de propiedades. Considera lo siguiente:

Dim fooInstance As Foo = Nothing
Dim s As String

Normalmente tendrías que escribir algo como esto:

If fooInstance IsNot Nothing AndAlso fooInstance.BarInstance IsNot Nothing Then
    s = fooInstance.BarInstance.Baz
Else
    s = Nothing
End If

Pero con el ? operador esto puede ser reemplazado con solo:

s = fooInstance?.BarInstance?.Baz

Operador NameOf

El operador NameOf resuelve espacios de nombres, tipos, variables y nombres de miembros en tiempo de compilación y los reemplaza con el equivalente de cadena.

Uno de los casos de uso:

Sub MySub(variable As String)
    If variable Is Nothing Then Throw New ArgumentNullException("variable")
End Sub

La sintaxis anterior expondrá el riesgo de cambiar el nombre de la variable y dejar la cadena codificada en el valor incorrecto.

Sub MySub(variable As String)
    If variable Is Nothing Then Throw New ArgumentNullException(NameOf(variable))
End Sub

Con NameOf , cambiar el nombre de la variable solo generará un error de compilación. Esto también permitirá que la herramienta de cambio de nombre cambie el nombre de ambos con un solo esfuerzo.

El operador NameOf solo usa el último componente de la referencia entre paréntesis. Esto es importante cuando se maneja algo así como espacios de nombres en el operador NameOf .

Imports System

Module Module1
    Sub WriteIO()
        Console.WriteLine(NameOf(IO)) 'displays "IO"
        Console.WriteLine(NameOf(System.IO)) 'displays "IO"
    End Sub
End Module

El operador también utiliza el nombre de la referencia que se ingresa sin resolver ningún cambio de nombre de importación. Por ejemplo:

Imports OldList = System.Collections.ArrayList

Module Module1
    Sub WriteList()
        Console.WriteLine(NameOf(OldList)) 'displays "OldList"
        Console.WriteLine(NameOf(System.Collections.ArrayList)) 'displays "ArrayList"
    End Sub
End Module

Interpolación de cuerdas

Esta nueva característica hace que la concatenación de cadenas sea más legible. Esta sintaxis se compilará a su llamada String.Format equivalente.

Sin interpolación de cuerdas:

String.Format("Hello, {0}", name)

Con interpolación de cuerdas:

$"Hello, {name}"

Las dos líneas son equivalentes y ambas se compilan en una llamada a String.Format .

Al igual que en String.Format , los corchetes pueden contener cualquier expresión (llamada a un método, propiedad, un operador de unión nula, etc.).

La interpolación de cadenas es el método preferido sobre String.Format porque evita que String.Format algunos errores de tiempo de ejecución. Considere la siguiente línea String.Format :

String.Format("The number of people is {0}/{1}", numPeople)

Esto se compilará, pero causará un error de tiempo de ejecución ya que el compilador no verifica que la cantidad de argumentos coincida con los marcadores de posición.

Propiedades automáticas de solo lectura

Las propiedades de solo lectura siempre fueron posibles en VB.NET en este formato:

Public Class Foo

  Private _MyProperty As String = "Bar"

  Public ReadOnly Property MyProperty As String
    Get
      Return _MyProperty
    End Get
  End Property

End Class

La nueva versión de Visual Basic permite una mano corta para la declaración de propiedad así:

Public Class Foo

  Public ReadOnly Property MyProperty As String = "Bar"

End Class

La implementación real que genera el compilador es exactamente la misma para ambos ejemplos. El nuevo método para escribirlo es solo una mano corta. El compilador seguirá generando un campo privado con el formato: _<PropertyName> para respaldar la propiedad de solo lectura.

Módulos parciales e interfaces

Similar a las clases parciales, la nueva versión de Visual Basic ahora puede manejar módulos parciales e interfaces parciales. La sintaxis y el comportamiento son exactamente los mismos que para las clases parciales.

Un ejemplo de módulo parcial:

Partial Module Module1
  Sub Main()
    Console.Write("Ping -> ")
    TestFunktion()
  End Sub
End Module

Partial Module Module1
  Private Sub TestFunktion()
    Console.WriteLine("Pong")
  End Sub
End Module

Y una interfaz parcial:

Partial Interface Interface1
  Sub Methode1()
End Interface

Partial Interface Interface1
  Sub Methode2()
End Interface

Public Class Class1
  Implements Interface1
  Public Sub Methode1() Implements Interface1.Methode1
    Throw New NotImplementedException()
  End Sub

  Public Sub Methode2() Implements Interface1.Methode2
    Throw New NotImplementedException()
  End Sub
End Class

Al igual que para las clases parciales, las definiciones de los módulos e interfaces parciales deben ubicarse en el mismo espacio de nombres y el mismo ensamblado. Esto se debe a que las partes parciales de los módulos e interfaces se combinan durante la compilación y el ensamblaje compilado no contiene ninguna indicación de que la definición original del módulo o la interfaz se dividió.

Literales multilínea de cuerda

VB ahora permite cadenas literales que se dividen en varias líneas.

Sintaxis antigua:

Dim text As String = "Line1" & Environment.NewLine & "Line2"

Nueva sintaxis:

Dim text As String = "Line 1
Line 2"

# # Mejoras directivas regionales

La directiva #Region ahora se puede colocar dentro de los métodos e incluso puede abarcar métodos, clases y módulos.

#Region "A Region Spanning A Class and Ending Inside Of A Method In A Module"
   Public Class FakeClass
    'Nothing to see here, just a fake class.
   End Class

   Module Extensions

    ''' <summary>
    ''' Checks the path of files or directories and returns [TRUE] if it exists.
    ''' </summary>
    ''' <param name="Path">[Sting] Path of file or directory to check.</param>
    ''' <returns>[Boolean]</returns>
    <Extension>
    Public Function PathExists(ByVal Path As String) As Boolean
        If My.Computer.FileSystem.FileExists(Path) Then Return True
        If My.Computer.FileSystem.DirectoryExists(Path) Then Return True
        Return False
    End Function

    ''' <summary>
    ''' Returns the version number from the specified assembly using the assembly's strong name.
    ''' </summary>
    ''' <param name="Assy">[Assembly] Assembly to get the version info from.</param>
    ''' <returns>[String]</returns>
    <Extension>
    Friend Function GetVersionFromAssembly(ByVal Assy As Assembly) As String
#End Region
        Return Split(Split(Assy.FullName, ",")(1), "=")(1)
    End Function
End Module

Comentarios después de la continuación de la línea implícita

VB 14.0 introduce la posibilidad de agregar comentarios después de la continuación de línea implícita.

Dim number =
    From c As Char 'Comment
    In "dj58kwd92n4" 'Comment
    Where Char.IsNumber(c) 'Comment
    Select c 'Comment

Manejo de excepciones

Durante la codificación, los errores inesperados surgen con la frecuencia suficiente, lo que requiere depuración y pruebas. Pero a veces los errores son realmente esperados y, para evitarlo, está el bloque Try..Catch..Throw..Finally..End Try .

Para administrar un error correctamente, el código se coloca en un bloque Try..Catch , por lo que el Catch , como su nombre indica, detectará todas las excepciones que surjan en este bloque.

Y en caso de excepción, tenemos la posibilidad de Throw el error, es decir, devolverlo para notificarlo al usuario o administrarlo internamente en el propio código.

El Finally parte es el código final que, cualquiera que sea el resultado, si hay una excepción o no, el código se ejecutará antes de salir del bloque.

En caso de que tengamos que salir del reloj, existe la instrucción Exit Try que se puede usar. Pero aquí también, el código en la sección Finally se ejecutará antes de terminar.

La sintaxis es simple;

Try
    [ tryStatements ]
    [ Exit Try ]
[ Catch [ exception [ As type ] ] [ When expression ]
    [ catchStatements ]
    [ Exit Try ] ]
[ Catch ... ]
[ Finally
    [ finallyStatements ] ]
End Try

donde solo es obligatorio el Try y el End Try . El resto se puede ignorar, pero como buena práctica, incluya la parte Finally , incluso si se deja en blanco.

Llegando a la excepción, hay diferentes tipos de excepción que pueden ser capturados. Están listas las excepciones disponibles desde .Net Framework, como se muestra a continuación;