Visual Basic .NET Language
Visual Basic 14.0-functies

Invoering

Null voorwaardelijke operator

Om uitgebreide null-controle te voorkomen, de ?. operator is geïntroduceerd in de taal.

De oude uitgebreide syntaxis:

If myObject IsNot Nothing AndAlso myObject.Value >= 10 Then

Kan nu worden vervangen door de beknopte:

If myObject?.Value >= 10 Then

De ? operator is bijzonder krachtig wanneer u een reeks eigenschappen hebt. Stel je de volgende situatie voor:

Dim fooInstance As Foo = Nothing
Dim s As String

Normaal gesproken zou je zoiets moeten schrijven:

If fooInstance IsNot Nothing AndAlso fooInstance.BarInstance IsNot Nothing Then
    s = fooInstance.BarInstance.Baz
Else
    s = Nothing
End If

Maar met de ? operator kan dit worden vervangen door:

s = fooInstance?.BarInstance?.Baz

Naam van operator

De operator NameOf lost tijdens het compileren naamruimten, typen, variabelen en NameOf op en vervangt deze door het tekenreeksequivalent.

Een van de use cases:

Sub MySub(variable As String)
    If variable Is Nothing Then Throw New ArgumentNullException("variable")
End Sub

De oude syntaxis zal het risico blootleggen van het hernoemen van de variabele en het laten van de hard-gecodeerde string naar de verkeerde waarde.

Sub MySub(variable As String)
    If variable Is Nothing Then Throw New ArgumentNullException(NameOf(variable))
End Sub

Met NameOf zal het hernoemen van alleen de variabele een compilerfout veroorzaken. Hierdoor kan het hernoemen ook beide met een enkele inspanning hernoemen.

De operator NameOf gebruikt alleen het laatste onderdeel van de referentie tussen haakjes. Dit is belangrijk bij het verwerken van zoiets als naamruimten in de NameOf operator.

Imports System

Module Module1
    Sub WriteIO()
        Console.WriteLine(NameOf(IO)) 'displays "IO"
        Console.WriteLine(NameOf(System.IO)) 'displays "IO"
    End Sub
End Module

De operator gebruikt ook de naam van de ingevoerde referentie zonder de invoer van naam te wijzigen. Bijvoorbeeld:

Imports OldList = System.Collections.ArrayList

Module Module1
    Sub WriteList()
        Console.WriteLine(NameOf(OldList)) 'displays "OldList"
        Console.WriteLine(NameOf(System.Collections.ArrayList)) 'displays "ArrayList"
    End Sub
End Module

Stringinterpolatie

Deze nieuwe functie maakt de stringconcentratie leesbaarder. Deze syntaxis wordt gecompileerd naar de overeenkomstige String.Format aanroep.

Zonder stringinterpolatie:

String.Format("Hello, {0}", name)

Met stringinterpolatie:

$"Hello, {name}"

De twee lijnen zijn equivalent en beide worden gecompileerd tot een aanroep van String.Format .

Net als in String.Format kunnen de haakjes elke expressie bevatten (aanroep naar een methode, eigenschap, een nulcoalescente-operator enzovoort).

String.Format is de voorkeursmethode boven String.Format omdat het voorkomt dat er runtime-fouten optreden. Beschouw de volgende String.Format regel:

String.Format("The number of people is {0}/{1}", numPeople)

Dit compileert, maar veroorzaakt een runtime-fout omdat de compiler niet controleert of het aantal argumenten overeenkomt met de tijdelijke aanduidingen.

Alleen-lezen automatische eigenschappen

Alleen-lezen eigenschappen waren altijd mogelijk in VB.NET in deze indeling:

Public Class Foo

  Private _MyProperty As String = "Bar"

  Public ReadOnly Property MyProperty As String
    Get
      Return _MyProperty
    End Get
  End Property

End Class

De nieuwe versie van Visual Basic staat een korte hand toe voor de eigenschapsverklaring als volgt:

Public Class Foo

  Public ReadOnly Property MyProperty As String = "Bar"

End Class

De daadwerkelijke implementatie die door de compiler wordt gegenereerd, is voor beide voorbeelden exact hetzelfde. De nieuwe methode om het te schrijven is slechts een korte hand. De compiler genereert nog steeds een privéveld met de indeling: _<PropertyName> om de alleen-lezen eigenschap te ondersteunen.

Gedeeltelijke modules en interfaces

Net als bij gedeeltelijke klassen kan de nieuwe versie van Visual Basic nu gedeeltelijke modules en gedeeltelijke interfaces verwerken. De syntaxis en het gedrag is precies hetzelfde als voor gedeeltelijke klassen.

Een voorbeeld van een gedeeltelijke module:

Partial Module Module1
  Sub Main()
    Console.Write("Ping -> ")
    TestFunktion()
  End Sub
End Module

Partial Module Module1
  Private Sub TestFunktion()
    Console.WriteLine("Pong")
  End Sub
End Module

En een gedeeltelijke interface:

Partial Interface Interface1
  Sub Methode1()
End Interface

Partial Interface Interface1
  Sub Methode2()
End Interface

Public Class Class1
  Implements Interface1
  Public Sub Methode1() Implements Interface1.Methode1
    Throw New NotImplementedException()
  End Sub

  Public Sub Methode2() Implements Interface1.Methode2
    Throw New NotImplementedException()
  End Sub
End Class

Net als voor gedeeltelijke klassen moeten de definities voor de gedeeltelijke modules en interfaces zich in dezelfde naamruimte en dezelfde assembly bevinden. Dit komt omdat de gedeeltelijke delen van de modules en interfaces tijdens de compilatie zijn samengevoegd en de gecompileerde assemblage geen enkele aanwijzing bevat dat de oorspronkelijke definitie van de module of interface is gesplitst.

Multiline string literals

VB staat nu stringliterals toe die over meerdere lijnen worden verdeeld.

Oude syntaxis:

Dim text As String = "Line1" & Environment.NewLine & "Line2"

Nieuwe syntaxis:

Dim text As String = "Line 1
Line 2"

#Regio richtlijn verbeteringen

#Regio-richtlijn kan nu in methoden worden geplaatst en kan zelfs methoden, klassen en modules omvatten.

#Region "A Region Spanning A Class and Ending Inside Of A Method In A Module"
   Public Class FakeClass
    'Nothing to see here, just a fake class.
   End Class

   Module Extensions

    ''' <summary>
    ''' Checks the path of files or directories and returns [TRUE] if it exists.
    ''' </summary>
    ''' <param name="Path">[Sting] Path of file or directory to check.</param>
    ''' <returns>[Boolean]</returns>
    <Extension>
    Public Function PathExists(ByVal Path As String) As Boolean
        If My.Computer.FileSystem.FileExists(Path) Then Return True
        If My.Computer.FileSystem.DirectoryExists(Path) Then Return True
        Return False
    End Function

    ''' <summary>
    ''' Returns the version number from the specified assembly using the assembly's strong name.
    ''' </summary>
    ''' <param name="Assy">[Assembly] Assembly to get the version info from.</param>
    ''' <returns>[String]</returns>
    <Extension>
    Friend Function GetVersionFromAssembly(ByVal Assy As Assembly) As String
#End Region
        Return Split(Split(Assy.FullName, ",")(1), "=")(1)
    End Function
End Module

Opmerkingen na impliciete voortzetting van de lijn

VB 14.0 introduceert de mogelijkheid om opmerkingen toe te voegen na impliciete lijnvervolging.

Dim number =
    From c As Char 'Comment
    In "dj58kwd92n4" 'Comment
    Where Char.IsNumber(c) 'Comment
    Select c 'Comment

Uitzondering afhandeling

Tijdens het coderen treden er vaak genoeg onverwachte fouten op, waarvoor fouten moeten worden opgelost en getest. Maar soms worden de fouten inderdaad verwacht en om het te omzeilen, is er het Try..Catch..Throw..Finally..End Try blok.

Om een fout correct te beheren, wordt de code in een blok Try..Catch , waarbij de Catch , zoals de naam al aangeeft, alle uitzonderingen Try..Catch die zich in dit blok voordoen.

En in geval van uitzondering hebben we de mogelijkheid om de fout te Throw , dat wil zeggen deze terug te sturen naar de gebruiker of het intern in de code zelf te beheren.

Het Finally deel is de laatste code die, ongeacht de uitkomst zijn, als er een uitzondering is of niet, zal de code uit te voeren alvorens uit te gaan van het blok.

In het geval dat we uit de klok moeten springen, is er de Exit Try instructie die kan worden gebruikt. Maar ook hier wordt de code in de sectie Finally uitgevoerd voordat deze eindigt.

De syntaxis is eenvoudig;

Try
    [ tryStatements ]
    [ Exit Try ]
[ Catch [ exception [ As type ] ] [ When expression ]
    [ catchStatements ]
    [ Exit Try ] ]
[ Catch ... ]
[ Finally
    [ finallyStatements ] ]
End Try

waarbij alleen de Try and End Try verplicht is. De rest kan worden genegeerd, maar voeg als een goede gewoonte het gedeelte Finally , zelfs als dit leeg zou blijven.

Op de uitzondering na, zijn er verschillende soorten uitzonderingen die kunnen worden gevangen. Het zijn kant-en-klare uitzonderingen die beschikbaar zijn via het .Net Framework, zoals hieronder;