Visual Basic .NET Language
Visual Basic 14.0-Funktionen

Einführung

Null bedingter Operator

Um eine ausführliche Nullprüfung zu vermeiden, das ?. Operator wurde in der Sprache eingeführt.

Die alte verbose Syntax:

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

Kann jetzt durch die Kurzfassung ersetzt werden:

If myObject?.Value >= 10 Then

Die ? Operator ist besonders leistungsfähig, wenn Sie eine Kette von Eigenschaften haben. Folgendes berücksichtigen:

Dim fooInstance As Foo = Nothing
Dim s As String

Normalerweise müsste man so etwas schreiben:

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

Aber mit dem ? Operator kann durch nur ersetzt werden:

s = fooInstance?.BarInstance?.Baz

NameOf-Operator

Der NameOf Operator löst Namespaces, Typen, Variablen und NameOf zur Kompilierzeit auf und ersetzt sie durch die entsprechende Zeichenfolge.

Einer der Anwendungsfälle:

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

Die alte Syntax birgt das Risiko, dass die Variable umbenannt wird und der hartcodierte String den falschen Wert hat.

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

Bei NameOf führt das Umbenennen der Variablen nur zu einem Compiler-Fehler. Dadurch kann das Umbenennungstool beide mit einem einzigen Aufwand umbenennen.

Der NameOf Operator verwendet nur die letzte Komponente der Referenz in den Klammern. Dies ist wichtig, wenn Sie zum Beispiel Namespaces im NameOf Operator behandeln.

Imports System

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

Der Operator verwendet auch den Namen der eingegebenen Referenz, ohne dass Importe mit Namensänderungen aufgelöst werden. Zum Beispiel:

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

String-Interpolation

Diese neue Funktion macht die Verkettung von Strings lesbarer. Diese Syntax wird zu dem entsprechenden String.Format Aufruf kompiliert.

Ohne String Interpolation:

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

Mit Stringinterpolation:

$"Hello, {name}"

Die beiden Zeilen sind gleichwertig und beide werden zu einem Aufruf von String.Format .

Wie in String.Format können die Klammern jeden einzelnen Ausdruck enthalten (Aufruf einer Methode, Eigenschaft, eines Null-Koaleszenzoperators usw.).

String Interpolation ist die bevorzugte Methode gegenüber String.Format da einige Laufzeitfehler String.Format . Betrachten Sie die folgende String.Format Zeile:

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

Dies wird kompiliert, verursacht jedoch einen Laufzeitfehler, da der Compiler nicht überprüft, ob die Anzahl der Argumente mit den Platzhaltern übereinstimmt.

Schreibgeschützte Auto-Eigenschaften

Schreibgeschützte Eigenschaften waren in VB.NET immer in diesem Format möglich:

Public Class Foo

  Private _MyProperty As String = "Bar"

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

End Class

Die neue Version von Visual Basic erlaubt eine kurze Hand für die Eigenschaftsdeklaration wie folgt:

Public Class Foo

  Public ReadOnly Property MyProperty As String = "Bar"

End Class

Die tatsächliche Implementierung, die der Compiler generiert, ist für beide Beispiele identisch. Die neue Methode zum Schreiben ist nur eine kurze Hand. Der Compiler generiert weiterhin ein privates Feld mit dem Format: _<PropertyName> , um die schreibgeschützte Eigenschaft zu sichern.

Teilmodule und Schnittstellen

Ähnlich wie bei Teilklassen kann die neue Version von Visual Basic jetzt mit Teilmodulen und Teilschnittstellen umgehen. Die Syntax und das Verhalten sind genau dieselben wie für Teilklassen.

Ein Teilmodulbeispiel:

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

Und eine teilweise Schnittstelle:

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

Wie bei Teilklassen müssen die Definitionen für die Teilmodule und Schnittstellen im selben Namensraum und in derselben Assembly liegen. Dies liegt daran, dass die Teilkomponenten der Module und Schnittstellen während der Kompilierung zusammengeführt werden und die kompilierte Assembly keine Hinweise darauf enthält, dass die ursprüngliche Definition des Moduls oder der Schnittstelle aufgeteilt wurde.

Mehrzeilige String-Literale

VB erlaubt jetzt String-Literale, die sich über mehrere Zeilen aufteilen.

Alte Syntax:

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

Neue Syntax:

Dim text As String = "Line 1
Line 2"

#Region Direktive Verbesserungen

Die #Region-Direktive kann jetzt in Methoden platziert werden und kann sogar Methoden, Klassen und Module umfassen.

#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

Kommentare nach impliziter Zeilenfortsetzung

Mit VB 14.0 können Kommentare nach der impliziten Zeilenfortsetzung hinzugefügt werden.

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

Ausnahmebehandlung

Während der Codierung treten häufig unerwartete Fehler auf, die Debugging und Testen erfordern. Aber manchmal werden die Fehler tatsächlich erwartet und umgangen, gibt es den Try..Catch..Throw..Finally..End Try Block.

Um einen Fehler richtig zu behandeln, wird der Code in einen Try..Catch Block Try..Catch , wobei der Catch , wie der Name sagt, alle Ausnahmen fängt, die in diesem Block auftreten.

Und in Ausnahmefällen haben wir die Möglichkeit, den Fehler zu Throw , das heißt, den Benutzer zu benachrichtigen oder ihn intern im Code selbst zu verwalten.

Der Finally Teil ist der letzte Code, der , was auch immer das Ergebnis sein, wenn es eine Ausnahme ist oder nicht, wird der Code ausgeführt werden, bevor aus dem Block gehen.

Für den Fall, dass wir die Uhr herausspringen müssen, gibt es die Exit Try Anweisung, die verwendet werden kann. Aber auch hier ist der Code im Finally wird Abschnitt vor dem Ende ausgeführt werden.

Die Syntax ist einfach.

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

wo nur das Try and End Try obligatorisch ist. Der Rest kann ignoriert werden. Fügen Sie jedoch den Finally Teil hinzu, auch wenn er leer bleibt.

Bei der Ausnahme gibt es verschiedene Arten von Ausnahmen, die abgefangen werden können. Sie sind fertige Ausnahmen, die im .Net Framework verfügbar sind (siehe unten).