Visual Basic .NET Language
Inleiding tot syntaxis

Comments

Het eerste interessante wat u moet weten, is hoe u opmerkingen kunt schrijven.

In VB .NET schrijf je een opmerking door een apostrof te schrijven of door REM schrijven. Dit betekent dat de rest van de regel niet in aanmerking wordt genomen door de compiler.

'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

Intellisense Helper

Een interessant ding is de mogelijkheid om eigen opmerkingen toe te voegen aan Visual Studio Intellisense. Zo kunt u uw eigen geschreven functies en klassen voor zichzelf spreken. Om dit te doen, moet u het opmerkingensymbool drie keer de lijn boven uw functie typen.

Eenmaal gedaan, zal Visual Studio automatisch een XML-documentatie toevoegen:

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

Als u daarna uw testfunctie ergens in uw code typt, verschijnt deze kleine hulp:

Een variabele declareren

In VB.NET moet elke variabele worden gedeclareerd voordat deze wordt gebruikt (als Option Explicit is ingesteld op On ). Er zijn twee manieren om variabelen te declareren:

• Binnen een Function of een 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 

Zie dit antwoord voor volledige informatie over Option Explicit , Strict en Infer .

• Binnen een Class of een Module :

Deze variabelen (in deze context ook wel velden genoemd) zijn toegankelijk voor elke instantie van de Class ze zijn gedeclareerd. Ze kunnen toegankelijk zijn van buiten de gedeclareerde Class afhankelijk van de modificator ( Public , Private , Protected , Protected Friend of 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

Deze velden kunnen ook worden gedeclareerd met Dim maar de betekenis verandert afhankelijk van het omhullende type:

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

modifiers

Modifiers zijn een manier om aan te geven hoe externe objecten toegang kunnen krijgen tot de gegevens van een object.

• Openbaar

Betekent dat elk object hier zonder beperking toegang toe heeft

• Privaat

Betekent dat alleen het declarerende object hier toegang toe heeft en dit kan bekijken

• beschermde

Betekent alleen het declarerende object en elk object dat ervan ervaart, heeft toegang en kan dit bekijken.

• vriend

Betekent alleen het delcaring-object, elk object dat ervan erveert en elk object in dezelfde naamruimte heeft hier toegang toe en kan dit bekijken.

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

Functie schrijven

Een functie is een codeblok dat tijdens de uitvoering verschillende keren wordt aangeroepen. In plaats van steeds opnieuw hetzelfde stuk code te schrijven, kan men deze code in een functie schrijven en die functie aanroepen wanneer dat nodig is.

Een functie :

• Moet worden aangegeven in een klasse of een module
• Retourneert een waarde (opgegeven door het retourtype)
• Heeft een modifier
• Kan parameters gebruiken om de verwerking ervan uit te voeren

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

Een functienaam, kan worden gebruikt als retourverklaring

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

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

    Return err
End Function

is precies hetzelfde als

Function sealBarTypeValidation() as Boolean
    sealBarTypeValidation = False        

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

End Function

Initializers van objecten

• Benoemde typen

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

  Is gelijk aan

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

• Anonieme typen (optie-conclusie moet zijn ingeschakeld)

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

  Hoewel vergelijkbare anonymousInstance niet hetzelfde type heeft als someInstance

  De naam van het lid moet uniek zijn in het anonieme type en kan worden ontleend aan een variabele of een andere lidnaam van een object

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

  Elk lid kan worden voorafgegaan door het Key sleutelwoord. Die leden zijn ReadOnly eigenschappen, die zonder zijn read / write-eigenschappen

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

  Twee anonieme instanties gedefinieerd met dezelfde leden (naam, type, aanwezigheid van Key en volgorde) hebben hetzelfde anonieme type.

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

  Anonieme typen zijn structureel vergelijkbaar. Twee exemplaren van dezelfde anonieme typen met ten minste één Key met dezelfde Key zijn gelijk. U moet de methode Equals gebruiken om het te testen, met = wordt niet gecompileerd en zal Is de objectreferentie vergelijken.

    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
  

Zowel Initialized als Anonymous-initialisatietypes kunnen worden genest en gemengd

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

Initializer voor verzameling

• arrays

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

• Containers ( List(Of T) , Dictionary(Of TKey, TValue) , enz.)

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

  Is gelijk aan

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

  Items kunnen het resultaat zijn van een constructor, een methodeaanroep, een eigenschapstoegang. Het kan ook worden gemengd met Object-initialisatie.

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

  Het is niet mogelijk om de syntaxis van de initialisatie van het object EN de syntaxis van de initialisatie van het object voor hetzelfde object tegelijkertijd te gebruiken. Deze werken bijvoorbeeld niet

   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
   }
  

• Aangepast type

  We kunnen ook syntaxis van de initialisatie van de verzameling toestaan door te voorzien in een aangepast type.
  Het moet IEnumerable implementeren en moet toegankelijk en compatibel zijn door overbelastingsregels Methode Add (instantie, gedeelde of zelfs uitbreidingsmethode)

  Geconciteerd voorbeeld:

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

  Als we het Person-object aan een List(Of Person) wilden toevoegen door de naam gewoon in de initialisatie van de collectie te plaatsen (maar we kunnen de klasse List (van persoon) niet wijzigen), kunnen we een uitbreidingsmethode gebruiken

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