Visual Basic .NET Language
Visual Basic 14.0-funktioner

Introduktion

Null villkorad operatör

För att undvika fullständig nollkontroll ?. operatören har introducerats på språket.

Den gamla verbosyntaxen:

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

Kan nu ersättas av den kortfattade:

If myObject?.Value >= 10 Then

? operatören är särskilt kraftfull när du har en kedja av egenskaper. Tänk på följande:

Dim fooInstance As Foo = Nothing
Dim s As String

Normalt måste du skriva något liknande:

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

Men med ? operatör kan detta ersättas med bara:

s = fooInstance?.BarInstance?.Baz

NameOf operatör

Operatören NameOf löser namnutrymmen, typer, variabler och medlemsnamn vid sammanställningstiden och ersätter dem med strängekvivalenten.

Ett av användningsfallen:

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

Den gamla syntaxen utsätter risken för att byta namn på variabeln och lämna den hårdkodade strängen till fel värde.

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

Med NameOf kommer bara att byta namn på variabeln en kompilatorfel. Detta gör det också möjligt att byta namn på båda med en enda ansträngning.

Operatören NameOf använder endast den sista komponenten i referensen i parenteserna. Detta är viktigt när du hanterar något liknande namnutrymmen i NameOf operatören.

Imports System

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

Operatören använder också namnet på referensen som skrivs in utan att lösa något namnbyte av import. Till exempel:

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

Stränginterpolering

Den här nya funktionen gör strängen sammankoppling mer läsbar. Denna syntax kommer att sammanställas till dess motsvarande String.Format samtal.

Utan stränginterpolation:

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

Med stränginterpolation:

$"Hello, {name}"

De två linjerna är likvärdiga och båda sammanställs till ett samtal till String.Format .

Liksom i String.Format kan parenteserna innehålla valfritt enskilt uttryck (uppmaning till en metod, egenskap, en null coalescing operator et cetera).

String Interpolation är den föredragna metoden framför String.Format eftersom det förhindrar att vissa runtime-fel uppstår. Tänk på följande String.Format linje:

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

Detta kommer att kompilera men kommer att orsaka ett runtime-fel eftersom kompilatorn inte kontrollerar att antalet argument matchar platshållarna.

Auto-egenskaper för skrivskydd

Skrivskyddsegenskaper var alltid möjliga i VB.NET i detta format:

Public Class Foo

  Private _MyProperty As String = "Bar"

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

End Class

Den nya versionen av Visual Basic tillåter en kort hand för fastighetsdeklarationen så:

Public Class Foo

  Public ReadOnly Property MyProperty As String = "Bar"

End Class

Den faktiska implementeringen som genereras av kompilatorn är exakt densamma för båda exemplen. Den nya metoden att skriva det är bara en kort hand. Kompilatorn genererar fortfarande ett privat fält med formatet: _<PropertyName> att säkerhetskopiera den skrivskyddade egenskapen.

Partiella moduler och gränssnitt

I likhet med delklasser kan den nya versionen av Visual Basic nu hantera delmoduler och delgränssnitt. Syntaxen och beteendet är exakt samma som för delklasser.

Ett delmodulsexempel:

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

Och ett partiellt gränssnitt:

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

Precis som för delklasser måste definitionerna för delmoduler och gränssnitt placeras i samma namnutrymme och samma enhet. Detta beror på att delens delar av modulerna och gränssnitten slås samman under sammanställningen och den sammanställda enheten innehåller ingen indikation på att den ursprungliga definitionen av modulen eller gränssnittet delades.

Multiline strängbokstäver

VB tillåter nu strängbokstäver som delas över flera rader.

Gammal syntax:

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

Ny syntax:

Dim text As String = "Line 1
Line 2"

# Förbättringar av regiondirektivet

#Regionsdirektiv kan nu placeras i metoder och kan till och med sträcka sig över metoder, klasser och moduler.

#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

Kommentarer efter implicit linjefortsättning

VB 14.0 introducerar förmågan att lägga till kommentarer efter implicit linjefortsättning.

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

Undantagshantering

Under kodning uppstår oväntade fel tillräckligt ofta, vilket kräver felsökning och testning. Men ibland förväntas felen verkligen och för att kringgå det finns det Try..Catch..Throw..Finally..End Try block.

För att hantera ett fel korrekt läggs koden i ett Try..Catch block, varvid Catch , som namnet anger, kommer att fånga alla undantag som uppstår i detta block.

Och i undantagsfall har vi möjligheten att Throw felet, det vill säga returnera det för att meddela användaren eller hantera det internt i själva koden.

Den Finally del är den sista kod som, oavsett resultatet vara, om det finns ett undantag eller inte, kommer koden körs innan du går ut ur blocket.

Om vi behöver pop-out ur klockan, finns det Exit Try uttalandet som kan användas. Men även här kommer koden i avsnittet Finally att köras innan den slutar.

Syntaxen är enkel;

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

där endast Try and End Try är obligatoriskt. Resten kan ignoreras, men som en bra praxis, inkludera Finally delen, även om den skulle lämnas tom.

När det gäller undantaget finns det olika typer av undantag som kan fångas. De är färdiga undantag tillgängliga från .Net Framework, som nedan;