Visual Basic .NET Language
Introduzione alla sintassi

Commenti

La prima cosa interessante da sapere è come scrivere commenti.

In VB .NET, scrivi un commento scrivendo un apostrofo 'o scrivendo REM . Ciò significa che il resto della linea non verrà preso in considerazione dal compilatore.

'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

Helper Intellisense

Una cosa interessante è la possibilità di aggiungere i propri commenti in Visual Studio Intellisense. In questo modo puoi rendere le tue funzioni e classi scritte autoesplicative. Per fare ciò, è necessario digitare il simbolo di commento tre volte la riga sopra la funzione.

Una volta terminato, Visual Studio aggiungerà automaticamente una documentazione 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

Dopodiché, se digiti la funzione Test da qualche parte nel tuo codice, questo piccolo aiuto apparirà:

Dichiarazione di una variabile

In VB.NET, ogni variabile deve essere dichiarata prima di essere utilizzata (se Option Explicit è impostata su On ). Esistono due modi per dichiarare le variabili:

• All'interno di una Function o di una 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 

Vedi questa risposta per tutti i dettagli su Option Explicit , Strict e Infer .

• All'interno di una Class o di un Module :

Queste variabili (chiamate anche campi in questo contesto) saranno accessibili per ogni istanza della Class cui sono dichiarate. Potrebbero essere accessibili dall'esterno della Class dichiarata a seconda del modificatore ( Public , Private , Protected , Protected Friend , Protected Friend o 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

Questi campi possono anche essere dichiarati con Dim ma il significato cambia in base al tipo di allegato:

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

modificatori

I modificatori sono un modo per indicare come gli oggetti esterni possono accedere ai dati di un oggetto.

• Pubblico

Significa che qualsiasi oggetto può accedere a questo senza restrizioni

• Privato

Significa che solo l'oggetto dichiarante può accedere e visualizzarlo

• protetta

Significa che solo l'oggetto dichiarante e qualsiasi oggetto che ne eredita possono accedere e visualizzare questo.

• Amico

Indica solo l'oggetto delcaring, qualsiasi oggetto che ne eredita e qualsiasi oggetto nello stesso spazio dei nomi può accedere e visualizzarlo.

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

Scrivere una funzione

Una funzione è un blocco di codice che verrà chiamato più volte durante l'esecuzione. Invece di scrivere sempre lo stesso pezzo di codice, si può scrivere questo codice all'interno di una funzione e chiamare quella funzione ogni volta che è necessario.

Una funzione :

• Deve essere dichiarato in una classe o in un modulo
• Restituisce un valore (specificato dal tipo di reso)
• Ha un modificatore
• Può prendere parametri per fare la sua elaborazione

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

Un nome funzione, potrebbe essere usato come dichiarazione di ritorno

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

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

    Return err
End Function

è proprio come

Function sealBarTypeValidation() as Boolean
    sealBarTypeValidation = False        

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

End Function

Inizializzatori di oggetti

• Tipi nominati

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

  È equivalente a

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

• Tipi anonimi (opzione Inferente deve essere attiva)

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

  Sebbene anonymousInstance simile non abbia lo stesso tipo di someInstance

  Il nome del membro deve essere univoco nel tipo anonimo e può essere preso da una variabile o da un altro nome membro dell'oggetto

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

  Ogni membro può essere preceduto dalla parola chiave Key . Questi membri saranno proprietà ReadOnly , quelli senza proprietà di lettura / scrittura

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

  Due istanze anonime definite con gli stessi membri (nome, tipo, presenza di Key e ordine) avranno lo stesso tipo anonimo.

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

  I tipi anonimi sono strutturalmente equi Due istanze degli stessi tipi anonimi con almeno una proprietà Key con gli stessi valori Key saranno uguali. Devi usare il metodo Equals per testarlo, usando = non verrà compilato e Is confronterà il riferimento all'oggetto.

    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
  

Sia l'inizializzatore Named che i tipi Anonymous possono essere nidificati e misti

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

Inizializzatore di raccolta

• Array

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

• Contenitori ( List(Of T) , Dictionary(Of TKey, TValue) , ecc.)

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

  È equivalente a

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

  Gli articoli possono essere il risultato di un costruttore, una chiamata al metodo, un accesso alla proprietà. Può anche essere mescolato con l'inizializzatore di oggetti.

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

  Non è possibile utilizzare la sintassi dell'inizializzatore dell'oggetto E la sintassi di inizializzazione della raccolta per lo stesso oggetto allo stesso tempo. Ad esempio, questi non funzioneranno

   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 personalizzato

  Possiamo anche consentire la sintassi di inizializzazione della raccolta fornendo un tipo personalizzato.
  Deve implementare IEnumerable e avere un accesso accessibile e compatibile con regole di overload Add metodo (istanza, metodo di estensione condiviso o pari)

  Esempio di esempio

   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"
       '...
   }
  

  Se volessimo aggiungere l'oggetto Person ad una List(Of Person) semplicemente inserendo il nome nell'inizializzatore della raccolta (ma non possiamo modificare la classe List (Of Person)) possiamo usare un metodo Extension

   ' 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"
   }