Visual Basic .NET Language
Wprowadzenie do składni

Komentarze

Pierwszą interesującą rzeczą, jaką należy wiedzieć, jest pisanie komentarzy.

W VB .NET piszesz komentarz pisząc apostrof lub pisząc REM . Oznacza to, że reszta wiersza nie zostanie uwzględniona przez kompilator.

'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

Jedną interesującą rzeczą jest możliwość dodawania własnych komentarzy do programu Visual Studio Intellisense. Możesz więc tworzyć własne, zrozumiałe dla siebie funkcje i klasy. Aby to zrobić, musisz wpisać symbol komentarza trzy razy w linii nad funkcją.

Po zakończeniu Visual Studio automatycznie doda dokumentację 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

Następnie, jeśli wpiszesz funkcję Test gdzieś w kodzie, pojawi się ta mała pomoc:

Deklarowanie zmiennej

W VB.NET każda zmienna musi zostać zadeklarowana przed użyciem (jeśli opcja Jawna opcja jest ustawiona na Wł .). Istnieją dwa sposoby deklarowania zmiennych:

• Wewnątrz Function lub 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 

Zobacz tę odpowiedź, aby uzyskać szczegółowe informacje na temat Option Explicit , Strict i Infer .

• Wewnątrz Class lub Module :

Te zmienne (w tym kontekście zwane również polami) będą dostępne dla każdej instancji Class której są zadeklarowane. Mogą być dostępne spoza deklarowanej Class zależności od modyfikatora ( Public , Private , Protected , Protected Friend lub 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

Te pola można również zadeklarować za pomocą Dim ale znaczenie zmienia się w zależności od typu załączającego:

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

Modyfikatory

Modyfikatory są sposobem wskazania, w jaki sposób obiekty zewnętrzne mogą uzyskać dostęp do danych obiektu.

• Publiczny

Oznacza, że dowolny obiekt może uzyskać do niego dostęp bez ograniczeń

• Prywatny

Oznacza, że tylko obiekt deklarujący może uzyskać do niego dostęp i go wyświetlić

• Chroniony

Oznacza tylko obiekt deklarujący i każdy obiekt, który z niego dziedziczy, może uzyskać do niego dostęp i go wyświetlić.

• Przyjaciel

Oznacza tylko obiekt usuwania, każdy obiekt, który z niego dziedziczy, i każdy obiekt w tej samej przestrzeni nazw może uzyskać do niego dostęp i go wyświetlić.

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

Pisanie funkcji

Funkcja to blok kodu, który będzie wywoływany kilka razy podczas wykonywania. Zamiast wielokrotnie pisać ten sam fragment kodu, można napisać ten kod wewnątrz funkcji i wywołać tę funkcję, gdy zajdzie taka potrzeba.

Funkcja :

• Musi być zadeklarowany w klasie lub module
• Zwraca wartość (określoną przez typ zwracany)
• Ma modyfikator
• Może przyjmować parametry w celu przetworzenia

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

Nazwa funkcji może być użyta jako instrukcja return

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

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

    Return err
End Function

jest taki sam jak

Function sealBarTypeValidation() as Boolean
    sealBarTypeValidation = False        

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

End Function

Inicjatory obiektów

• Nazwane typy

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

  Jest równa

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

• Typy anonimowe (opcja wnioskowania musi być włączona)

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

  Chociaż podobny anonymousInstance nie ma tego samego typu co someInstance

  Nazwa elementu musi być unikalna w typie anonimowym i może być pobrana ze zmiennej lub nazwy innego elementu obiektu

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

  Każdy członek może być poprzedzony Key hasła. Ci członkowie będą właściwościami ReadOnly , ci bez nich będą właściwościami odczytu / zapisu

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

  Dwie anonimowe instancje zdefiniowane z tymi samymi członkami (nazwa, typ, obecność Key i kolejność) będą miały ten sam anonimowy typ.

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

  Anonimowe typy są strukturalnie porównywalne. Dwie instancje tych samych anonimowych typów posiadające co najmniej jedną właściwość Key z tymi samymi wartościami Key będą równe. Aby go przetestować, musisz użyć metody Equals , używając = nie skompiluje się, a Is porówna odwołanie do obiektu.

    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
  

Inicjator typów nazwanych i anonimowych można zagnieżdżać i mieszać

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

Inicjator kolekcji

• Tablice

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

• Kontenery ( List(Of T) , Dictionary(Of TKey, TValue) itp.)

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

  Jest równa

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

  Elementy mogą być wynikiem działania konstruktora, wywołania metody, dostępu do właściwości. Można go również mieszać z inicjatorem obiektu.

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

  Nie można używać składni inicjalizującej obiekt ORAZ składni inicjalizującej kolekcję dla tego samego obiektu w tym samym czasie. Na przykład nie będą działać

   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
   }
  

• Typ niestandardowy

  Możemy również zezwolić na składnię inicjatora kolekcji, podając niestandardowy typ.
  Musi implementować IEnumerable oraz mieć dostępną i zgodną z regułami przeciążenia metodę Add (instancja, Shared lub nawet metoda rozszerzenia)

  Opracowany przykład:

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

  Jeśli chcemy dodać obiekt Person do List(Of Person) po prostu umieszczając nazwę w inicjalizatorze kolekcji (ale nie możemy zmodyfikować klasy listy (osoby)), możemy użyć metody rozszerzenia

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