Visual Basic .NET Language => Introduktion till syntax

kommentarer

Det första intressanta att veta är hur man skriver kommentarer.

I VB .NET skriver du en kommentar genom att skriva en apostrof eller skriva REM . Detta betyder att resten av linjen inte kommer att beaktas av kompilatorn.

'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

En intressant sak är förmågan att lägga till egna kommentarer i Visual Studio Intellisense. Så du kan göra dina egna skriftliga funktioner och klasser självförklarande. För att göra det måste du skriva kommentarsymbolen tre gånger raden ovanför din funktion.

När detta är gjort kommer Visual Studio automatiskt att lägga till en XML-dokumentation:

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

Efter det, om du skriver in din testfunktion någonstans i din kod, kommer denna lilla hjälp att dyka upp:

Förklara en variabel

I VB.NET måste varje variabel deklareras innan den används (Om Option Explicit är inställd på On ). Det finns två sätt att deklarera variabler:

Inuti en Function eller en 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

Se det här svaret för fullständig information om Option Explicit , Strict and Infer .

Inne i en Class eller en Module :

Dessa variabler (även kallade fält i detta sammanhang) kommer att vara tillgängliga för varje instans av den Class de deklareras i. De kan vara tillgängliga utanför den deklarerade Class beroende på modifieraren ( Public , Private , Protected , Protected Friend or 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

Dessa fält kan också deklareras med Dim men betydelsen ändras beroende på den bifogade typen:

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

modifierare

Modifierare är ett sätt att indikera hur externa objekt kan komma åt ett objekts data.

offentlig

Betyder att alla objekt kan komma åt detta utan begränsningar

Privat

Innebär att endast det deklarerande objektet kan komma åt och se detta

Skyddade

Menar bara det deklarerande objektet och alla objekt som ärver från det kan komma åt och se detta.

vän

Avser bara det delcaring-objektet, alla objekt som ärver från det och alla objekt i samma namnområde kan komma åt och se detta.

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

Att skriva en funktion

En funktion är ett kodblock som kommer att anropas flera gånger under exekveringen. Istället för att skriva samma kod igen och igen, kan man skriva den här koden i en funktion och ringa den funktionen när den behövs.

En funktion :

Måste deklareras i en klass eller en modul
Returnerar ett värde (specificerat av returtypen)
Har en modifierare
Kan ta parametrar för att göra dess bearbetning

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

Ett funktionsnamn kan användas som returrätt

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

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

    Return err
End Function

är precis samma som

Function sealBarTypeValidation() as Boolean
    sealBarTypeValidation = False        

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

End Function

Objektinitierare

Namngivna typer

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

Är ekvivalent med

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

Anonyma typer (alternativet måste vara på)

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

Även om liknande anonymousInstance inte har samma typ som someInstance

Medlemsnamnet måste vara unikt i den anonyma typen och kan tas från en variabel eller ett annat objektmedlemsnamn

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

Varje medlem kan föregås av nyckelordet Key . Dessa medlemmar kommer att vara ReadOnly egenskaper, de utan kommer att läsa / skriva egenskaper

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

Två anonyma instanser definierade med samma medlemmar (namn, typ, närvaro av Key och ordning) kommer att ha samma anonyma typ.

  Dim anon1 = New With { Key .Value = 10 }
  Dim anon2 = New With { Key .Value = 20 }

  anon1.GetType Is anon2.GetType ' True

Anonyma typer är strukturellt jämställda. Två instanser av samma anonyma typer som har minst en Key egenskap med samma Key kommer att vara lika. Du måste använda Equals metoden för att testa den, använda = will not compile och Is kommer att jämföra objektreferensen.

  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

Både namngivna och anonyma typer initialisering kan kapslas och blandas

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

Insamlingsinitierare

arrayer

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

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

Är ekvivalent med

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

Objekt kan vara resultatet av en konstruktör, ett metodsamtal, en tillgång till egendom. Det kan också blandas med Objektinitierare.

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

Det är inte möjligt att använda syntax för objektinitierare OCH samlingsinitieringssyntax för samma objekt på samma gång. Till exempel fungerar dessa inte

 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
 }

Anpassad typ

Vi kan också tillåta samlingsinitieringssyntax genom att tillhandahålla en anpassad typ.
Det måste implementera IEnumerable och ha en tillgänglig och kompatibel med överbelastningsregler Add metod (instans, delad eller till och med förlängningsmetod)

Frivilligt exempel:

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

Om vi ville lägga till Person-objekt i en List(Of Person) genom att bara sätta namnet i samlingsinitieraren (men vi kan inte ändra klassen Lista (av person)) kan vi använda en förlängningsmetod

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

Modified text is an extract of the original Stack Overflow Documentation

Licensierat under CC BY-SA 3.0

Inte anslutet till Stack Overflow

Visual Basic .NET Language
Introduktion till syntax

Sök…