Visual Basic .NET Language
Introducción a la sintaxis

Comentarios

Lo primero que se debe saber es cómo escribir comentarios.

En VB .NET, escribe un comentario escribiendo un apóstrofe o escribiendo REM . Esto significa que el resto de la línea no será tomada en cuenta por el compilador.

'This entire line is a comment
Dim x As Integer = 0 'This comment is here to say we give 0 value to x

REM There are no such things as multiline comments
'So we have to start everyline with the apostrophe or REM

Ayudante Intellisense

Una cosa interesante es la posibilidad de agregar sus propios comentarios en Visual Studio Intellisense. Para que pueda hacer que sus propias funciones y clases escritas se expliquen por sí mismas. Para hacerlo, debe escribir el símbolo de comentario tres veces la línea sobre su función.

Una vez hecho esto, Visual Studio agregará automáticamente una documentación XML:

''' <summary>
''' This function returns a hello to your name
''' </summary>
''' <param name="Name">Your Name</param>
''' <returns></returns>
''' <remarks></remarks>
Public Function Test(Name As String) As String
    Return "Hello " & Name
End Function

Después de eso, si escribe su función de Prueba en algún lugar de su código, aparecerá esta pequeña ayuda:

Declarar una variable

En VB.NET, todas las variables deben declararse antes de ser utilizadas (si Option Explicit está establecido en On ). Hay dos formas de declarar variables:

• Dentro de una Function o un Sub :

Dim w 'Declares a variable named w of type Object (invalid if Option Strict is On)
Dim x As String 'Declares a variable named x of type String
Dim y As Long = 45 'Declares a variable named y of type Long and assigns it the value 45
Dim z = 45 'Declares a variable named z whose type is inferred
           'from the type of the assigned value (Integer here) (if Option Infer is On)
           'otherwise the type is Object (invalid if Option Strict is On)
           'and assigns that value (45) to it 

Consulte esta respuesta para obtener detalles completos sobre Option Explicit , Strict and Infer .

• Dentro de una Class o un Module :

Estas variables (también llamadas campos en este contexto) serán accesibles para cada instancia de la Class que se declaren. Podrían ser accesibles desde fuera de la Class declarada en función del modificador ( Public , Private , Protected , Protected Friend o Friend Protected Friend )

Private x 'Declares a private field named x of type Object (invalid if Option Strict is On)
Public y As String 'Declares a public field named y of type String
Friend z As Integer = 45 'Declares a friend field named z of type Integer and assigns it the value 45

Estos campos también se pueden declarar con Dim pero el significado cambia según el tipo adjunto:

Class SomeClass
    Dim z As Integer = 45 ' Same meaning as Private z As Integer = 45
End Class

Structure SomeStructure
    Dim y As String ' Same meaning as Public y As String
End Structure

Modificadores

Los modificadores son una forma de indicar cómo los objetos externos pueden acceder a los datos de un objeto.

• Público

Significa que cualquier objeto puede acceder a esto sin restricciones.

• Privado

Significa que solo el objeto declarante puede acceder y ver esto

• Protegido

Significa que solo el objeto declarante y cualquier objeto que se hereda de él pueden acceder y ver esto.

• Amigo

Significa solo que el objeto delecado, cualquier objeto que se herede de él y cualquier objeto en el mismo espacio de nombres puede acceder y ver esto.

Public Class MyClass
    Private x As Integer

    Friend Property Hello As String
  
    Public Sub New()
    End Sub

    Protected Function Test() As Integer
        Return 0
    End Function
End Class

Escribiendo una función

Una función es un bloque de código que se llamará varias veces durante la ejecución. En lugar de escribir el mismo fragmento de código una y otra vez, uno puede escribir este código dentro de una función y llamar a esa función cuando sea necesario.

Una función :

• Debe ser declarado en una clase o en un módulo.
• Devuelve un valor (especificado por el tipo de retorno)
• Tiene un modificador
• Puede tomar parámetros para hacer su procesamiento.

Private Function AddNumbers(X As Integer, Y As Integer) As Integer
    Return X + Y
End Function

Un Nombre de Función, podría ser usado como la declaración de retorno

Function sealBarTypeValidation() as Boolean
    Dim err As Boolean = False

    If rbSealBarType.SelectedValue = "" Then
        err = True
    End If

    Return err
End Function

es lo mismo que

Function sealBarTypeValidation() as Boolean
    sealBarTypeValidation = False        

    If rbSealBarType.SelectedValue = "" Then
        sealBarTypeValidation = True
    End If

End Function

Inicializadores de objetos

• Tipos nombrados

   Dim someInstance As New SomeClass(argument) With {
       .Member1 = value1,
       .Member2 = value2
       '...
   }
  

  Es equivalente a

   Dim someInstance As New SomeClass(argument)
   someInstance.Member1 = value1
   someInstance.Member2 = value2
   '...
  

• Tipos anónimos (la opción Inferir debe estar activada)

    Dim anonymousInstance = New With {
        .Member1 = value1,
        .Member2 = value2
        '...
    }
  

  Aunque una anonymousInstance similar no tiene el mismo tipo que someInstance

  El nombre de miembro debe ser único en el tipo anónimo y se puede tomar de una variable u otro nombre de miembro de objeto

    Dim anonymousInstance = New With {
        value1,
        value2,
        foo.value3
        '...
    }
    ' usage : anonymousInstance.value1 or anonymousInstance.value3
  

  Cada miembro puede ir precedido por la palabra Key clave. Esos miembros serán ReadOnly propiedades, los que no se leerá propiedades / escritura

    Dim anonymousInstance = New With {
        Key value1,
        .Member2 = value2,
        Key .Member3 = value3
        '...
    }
  

  Dos instancias anónimas definidas con los mismos miembros (nombre, tipo, presencia de Key y orden) tendrán el mismo tipo anónimo.

    Dim anon1 = New With { Key .Value = 10 }
    Dim anon2 = New With { Key .Value = 20 }
  
    anon1.GetType Is anon2.GetType ' True
  

  Los tipos anónimos son estructuralmente comparables. Dos instancias de los mismos tipos anónimos que tengan al menos una propiedad de Key con los mismos valores de Key serán iguales. Tienes que usar el método Equals para probarlo, usando = no compilará y Is comparará la referencia del objeto.

    Dim anon1 = New With { Key .Name = "Foo", Key .Age = 10, .Salary = 0 }
    Dim anon2 = New With { Key .Name = "Bar", Key .Age = 20, .Salary = 0 }
    Dim anon3 = New With { Key .Name = "Foo", Key .Age = 10, .Salary = 10000 }
  
    anon1.Equals(anon2) ' False
    anon1.Equals(anon3) ' True although non-Key Salary isn't the same
  

Tanto el inicializador de tipos anónimo como el anónimo se pueden anidar y mezclar

    Dim anonymousInstance = New With {
        value,
        Key .someInstance = New SomeClass(argument) With {
            .Member1 = value1,
            .Member2 = value2
            '...
        }
        '...
    }

Inicializador de colección

• Arrays

   Dim names = {"Foo", "Bar"} ' Inferred as String()
   Dim numbers = {1, 5, 42} ' Inferred as Integer()
  

• Contenedores ( List(Of T) , Dictionary(Of TKey, TValue) , etc.)

   Dim names As New List(Of String) From {
       "Foo",
       "Bar"
       '...
   }
  
   Dim indexedDays As New Dictionary(Of Integer, String) From {
       {0, "Sun"},
       {1, "Mon"}
       '...
   }
  

  Es equivalente a

   Dim indexedDays As New Dictionary(Of Integer, String)
   indexedDays.Add(0, "Sun")
   indexedDays.Add(1, "Mon")
   '...
  

  Los elementos pueden ser el resultado de un constructor, una llamada de método, un acceso de propiedad. También se puede mezclar con inicializador de objetos.

   Dim someList As New List(Of SomeClass) From {
       New SomeClass(argument),
       New SomeClass With { .Member = value },
       otherClass.PropertyReturningSomeClass,
       FunctionReturningSomeClass(arguments)
       '...
   }
  

  No es posible utilizar la sintaxis del inicializador de objetos Y la sintaxis del inicializador de colecciones para el mismo objeto al mismo tiempo. Por ejemplo, estos no funcionarán.

   Dim numbers As New List(Of Integer) With {.Capacity = 10} _
                                       From { 1, 5, 42 }
  
   Dim numbers As New List(Of Integer) From {
       .Capacity = 10,
       1, 5, 42
   }
  
   Dim numbers As New List(Of Integer) With {
       .Capacity = 10,
       1, 5, 42
   }
  

• Tipo personalizado

  También podemos permitir la sintaxis de inicialización de colección proporcionando un tipo personalizado.
  Debe implementar IEnumerable y tener un método Add (método de instancia, compartido o incluso extensión) accesible y compatible mediante reglas de sobrecarga.

  Ejemplo elaborado:

   Class Person
       Implements IEnumerable(Of Person) ' Inherits from IEnumerable
  
       Private ReadOnly relationships As List(Of Person)
  
       Public Sub New(name As String)
           relationships = New List(Of Person)
       End Sub
  
       Public Sub Add(relationName As String)
           relationships.Add(New Person(relationName))
       End Sub
  
       Public Iterator Function GetEnumerator() As IEnumerator(Of Person) _
           Implements IEnumerable(Of Person).GetEnumerator
  
           For Each relation In relationships
               Yield relation
           Next
       End Function
  
       Private Function IEnumerable_GetEnumerator() As IEnumerator _ 
           Implements IEnumerable.GetEnumerator
  
           Return GetEnumerator()
       End Function
   End Class
  
   ' Usage
   Dim somePerson As New Person("name") From {
       "FriendName",
       "CoWorkerName"
       '...
   }
  

  Si quisiéramos agregar un objeto Person a una List(Of Person) simplemente colocando el nombre en el inicializador de la colección (pero no podemos modificar la clase List (Of Person)) podemos usar un método de Extensión

   ' Inside a Module
   <Runtime.CompilerServices.Extension>
   Sub Add(target As List(Of Person), name As String)
       target.Add(New Person(name))
   End Sub
  
   ' Usage
   Dim people As New List(Of Person) From {
       "Name1", ' no need to create Person object here
       "Name2"
   }