Nyheter för Visual Basic

Artikel
01/27/2024

Det här avsnittet innehåller viktiga funktionsnamn för varje version av Visual Basic, med detaljerade beskrivningar av de nya och förbättrade funktionerna i de senaste versionerna av språket.

Aktuell version

Visual Basic 16.9 / Visual Studio 2019 version 16.9
Nya funktioner finns i Visual Basic 16.9.

Du kan ladda ned den senaste .NET SDK:en från nedladdningssidan för .NET.

Tidigare versioner

Visual Basic 16.0 /Visual Studio 2019 version 16.0
Nya funktioner finns i Visual Basic 16.0.

Visual Basic 15.5 /Visual Studio 2017 version 15.5
Nya funktioner finns i Visual Basic 15.5.

Visual Basic 15.3 /Visual Studio 2017 version 15.3
Nya funktioner finns i Visual Basic 15.3.

Visual Basic 15 /Visual Studio 2017
Nya funktioner finns i Visual Basic 2017.

Visual Basic/Visual Studio 2015
Nya funktioner finns i Visual Basic 14.

Visual Basic/Visual Studio 2013
Förhandsversioner av .NET Compiler Platform ("Roslyn")

Visual Basic/Visual Studio 2012
Async och await nyckelord, iteratorer, anroparinformationsattribut

Visual Basic, Visual Studio 2010
Automatiskt implementerade egenskaper, insamlingsinitierare, implicit radfortsättning, dynamisk, allmän co/contra-avvikelse, global namnområdesåtkomst

Visual Basic/Visual Studio 2008
Språkintegrerad fråga (LINQ), XML-literaler, slutsatsdragning av lokal typ, objektinitierare, anonyma typer, tilläggsmetoder, lokal var typinferens, lambda-uttryck, if operator, partiella metoder, nullbara värdetyper

Visual Basic/Visual Studio 2005
Typ My och hjälptyper (åtkomst till app, dator, filsystem, nätverk)

Visual Basic/Visual Studio .NET 2003
Bitskiftoperatorer, loopvariabeldeklaration

Visual Basic/Visual Studio .NET 2002
Den första versionen av Visual Basic .NET

Visual Basic 16,9

Visual Basic 16.9 möjliggör förbrukning av init-only-egenskaper.

Visual Basic 16,0

Visual Basic 16.0 fokuserar på att tillhandahålla fler av funktionerna i Visual Basic Runtime (microsoft.visualbasic.dll) till .NET Core och är den första versionen av Visual Basic som fokuserar på .NET Core. Många delar av Visual Basic Runtime är beroende av WinForms och dessa läggs till i en senare version av Visual Basic.

Kommentarer tillåts på fler platser i instruktioner

I Visual Basic 15.8 och tidigare versioner tillåts kommentarer endast på tomma rader, i slutet av en instruktion eller på specifika platser inom en -instruktion där en implicit radfortsättning tillåts. Från och med Visual Basic 16.0 tillåts kommentarer också efter explicita radfortsättningar och inom en instruktion på en rad som börjar med ett blanksteg följt av ett understreck.

Public Sub Main()
    cmd.CommandText = ' Comment is allowed here without _
        "SELECT * FROM Titles JOIN Publishers " _ ' This is a comment
        & "ON Publishers.PubId = Titles.PubID " _
 _ ' This is a comment on a line without code
        & "WHERE Publishers.State = 'CA'"
End Sub

Optimerad flyttal till heltalskonvertering

I tidigare versioner av Visual Basic gav konvertering av dubbla och enskilda värden till heltal relativt dåliga prestanda. Visual Basic 15.8 förbättrar avsevärt prestandan för flyttalskonverteringar till heltal när du skickar värdet som returneras av någon av följande metoder till någon av de inbyggda Visual Basic heltalskonverteringsfunktionerna (CByte, CShort, CInt, CLng, CSByte, CUShort, CUInt, CULng) eller när värdet som returneras av någon av följande metoder implicit omvandlas till en integrerad typ när Alternativet Strikt är inställt på Off:

Den här optimeringen gör att kod kan köras snabbare – upp till dubbelt så snabbt för kod som utför ett stort antal konverteringar till heltalstyper. I följande exempel visas några enkla metodanrop som påverkas av den här optimeringen:

Dim s As Single = 173.7619
Dim d As Double = s

Dim i1 As Integer = CInt(Fix(s))               ' Result: 173
Dim b1 As Byte = CByte(Int(d))                 ' Result: 173
Dim s1 AS Short = CShort(Math.Truncate(s))     ' Result: 173
Dim i2 As Integer = CInt(Math.Ceiling(d))      ' Result: 174
Dim i3 As Integer = CInt(Math.Round(s))        ' Result: 174

Observera att detta trunkerar snarare än avrundar flyttalsvärden.

Visual Basic 15,5

Icke-avslutande namngivna argument

I Visual Basic 15.3 och tidigare versioner, när ett metodanrop inkluderade argument både efter position och efter namn, måste positionsargument föregå namngivna argument. Från och med Visual Basic 15.5 kan positionella och namngivna argument visas i valfri ordning så länge alla argument upp till det sista positionsargumentet är i rätt position. Detta är särskilt användbart när namngivna argument används för att göra koden mer läsbar.

Följande metodanrop har till exempel två positionsargument mellan ett namngivet argument. Det namngivna argumentet gör det tydligt att värdet 19 representerar en ålder.

StudentInfo.Display("Mary", age:=19, #9/21/1998#)

Private Protected medlemsåtkomstmodifierare

Den här nya nyckelordskombinationen definierar en medlem som är tillgänglig för alla medlemmar i dess innehållande klass samt av typer som härleds från den innehållande klassen, men endast om de också finns i den innehållande sammansättningen. Eftersom strukturer inte kan ärvas Private Protected kan endast tillämpas på medlemmar i en klass.

Ledande hex/binär/oktal avgränsare

Visual Basic 2017 lade till stöd för understreckstecknet (_) som en sifferavgränsare. Från och med Visual Basic 15.5 kan du använda understreckstecknet som en inledande avgränsare mellan prefixet och hexadecimala, binära eller oktala siffror. I följande exempel används en inledande sifferavgränsare för att definiera 3 271 948 384 som ett hexadecimalt tal:

Dim number As Integer = &H_C305_F860

Om du vill använda understreckstecknet som inledande avgränsare måste du lägga till följande element i filen Visual Basic projekt (*.vbproj):

<PropertyGroup>
  <LangVersion>15.5</LangVersion>
</PropertyGroup>

Visual Basic 15.3

Namn på tuppelns slutsatsdragning

När du tilldelar värdet för tupplar från variabler, Visual Basic härleder namnet på tuppelns element från motsvarande variabelnamn. Du behöver inte uttryckligen namnge ett tupplar. I följande exempel används slutsatsdragning för att skapa en tuppeln med tre namngivna element, state, stateNameoch capital.

Const state As String = "MI"
Const stateName As String = "Michigan"
Const capital As String = "Lansing"
Dim stateInfo = (state, stateName, capital)
Console.WriteLine($"{stateInfo.stateName}: 2-letter code: {stateInfo.State}, Capital {stateInfo.capital}")
' The example displays the following output:
'      Michigan: 2-letter code: MI, Capital Lansing

Ytterligare kompilatorväxlar

Den Visual Basic kommandoradskompilatorn stöder nu kompilatoralternativen -refout och -refonly för att styra utdata från referenssammansättningar. -refout definierar utdatakatalogen för referenssammansättningen och -refonly anger att endast en referenssammansättning ska matas ut genom kompilering.

Visual Basic 15

Tupplar

Tupplar är en enkel datastruktur som oftast används för att returnera flera värden från ett enda metodanrop. Vanligtvis måste du göra något av följande för att returnera flera värden från en metod:

Definiera en anpassad typ (en Class eller en Structure). Det här är en tungviktslösning.
Definiera en eller flera ByRef parametrar, förutom att returnera ett värde från metoden.

Visual Basic stöd för tupplar kan du snabbt definiera en tupplar, tilldela semantiska namn till dess värden och snabbt hämta dess värden. I följande exempel omsluts ett anrop till TryParse metoden och en tupplar returneras.

Imports System.Globalization

Public Module NumericLibrary
    Public Function ParseInteger(value As String) As (Success As Boolean, Number As Integer)
        Dim number As Integer
        Return (Integer.TryParse(value, NumberStyles.Any, CultureInfo.InvariantCulture, number), number)
    End Function
End Module

Du kan sedan anropa metoden och hantera den returnerade tuppeln med kod som följande.

Dim numericString As String = "123,456"
Dim result = ParseInteger(numericString)
Console.WriteLine($"{If(result.Success, $"Success: {result.Number:N0}", "Failure")}")
Console.ReadLine()
'      Output: Success: 123,456

Binära literaler och sifferavgränsare

Du kan definiera en binär literal med hjälp av prefixet &B eller &b. Dessutom kan du använda understreckstecknet , _som en sifferavgränsare för att förbättra läsbarheten. I följande exempel används båda funktionerna för att tilldela ett Byte värde och för att visa det som ett decimaltal, hexadecimalt och binärt tal.

Dim value As Byte = &B0110_1110
Console.WriteLine($"{NameOf(value)}  = {value} (hex: 0x{value:X2}) " +
                  $"(binary: {Convert.ToString(value, 2)})")
' The example displays the following output:
'      value  = 110 (hex: 0x6E) (binary: 1101110)

Mer information finns i avsnittet "Literal assignments" i datatyperna Byte, Integer, Long, Short, SByte, UInteger, ULong och UShort .

Stöd för C#-referensreturvärden

Från och med C# 7.0 stöder C# referensreturvärden. När anropande metod tar emot ett värde som returneras med referens kan det alltså ändra värdet för referensen. Visual Basic tillåter inte att du skapar metoder med referensreturvärden, men det gör att du kan använda och ändra referensreturvärdena.

Följande Sentence klass som skrivits i C# innehåller till exempel en FindNext metod som hittar nästa ord i en mening som börjar med en angiven delsträng. Strängen returneras som ett referensreturvärde och en Boolean variabel som skickas med referens till metoden anger om sökningen lyckades. Det innebär att förutom att läsa det returnerade värdet kan anroparen också ändra det, och den ändringen återspeglas i Sentence klassen.

using System;

public class Sentence
{
    private string[] words;
    private int currentSearchPointer;

    public Sentence(string sentence)
    {
        words = sentence.Split(' ');
        currentSearchPointer = -1;
    }

    public ref string FindNext(string startWithString, ref bool found)
    {
        for (int count = currentSearchPointer + 1; count < words.Length; count++)
        {
            if (words[count].StartsWith(startWithString))
            {
                currentSearchPointer = count;
                found = true;
                return ref words[currentSearchPointer];
            }
        }
        currentSearchPointer = -1;
        found = false;
        return ref words[0];
    }

    public string GetSentence()
    {
        string stringToReturn = null;
        foreach (var word in words)
            stringToReturn += $"{word} ";

        return stringToReturn.Trim();
    }
}

I dess enklaste form kan du ändra ordet som finns i meningen med hjälp av kod som följande. Observera att du inte tilldelar ett värde till metoden, utan snarare till uttrycket som metoden returnerar, vilket är referensreturvärdet.

Dim sentence As New Sentence("A time to see the world is now.")
Dim found = False
sentence.FindNext("A", found) = "A good" 
Console.WriteLine(sentence.GetSentence()) 
' The example displays the following output:
'      A good time to see the world is now.

Ett problem med den här koden är dock att om en matchning inte hittas returnerar metoden det första ordet. Eftersom exemplet inte undersöker värdet för Boolean argumentet för att avgöra om en matchning hittas ändrar det första ordet om det inte finns någon matchning. I följande exempel korrigeras detta genom att ersätta det första ordet med sig självt om det inte finns någon matchning.

Dim sentence As New Sentence("A time to see the world is now.")
Dim found = False
sentence.FindNext("A", found) = IIf(found, "A good", sentence.FindNext("B", found)) 
Console.WriteLine(sentence.GetSentence()) 
' The example displays the following output:
'      A good time to see the world is now.

En bättre lösning är att använda en hjälpmetod som referensreturvärdet skickas med referens till. Hjälpmetoden kan sedan ändra argumentet som skickas till den med referens. Följande exempel gör det.

Module Example
   Public Sub Main()
      Dim sentence As New Sentence("A time to see the world is now.")
      Dim found = False
      Dim returns = RefHelper(sentence.FindNext("A", found), "A good", found) 
      Console.WriteLine(sentence.GetSentence()) 
   End Sub
   
   Private Function RefHelper(ByRef stringFound As String, replacement As String, success As Boolean) _ 
                    As (originalString As String, found As Boolean) 
      Dim originalString = stringFound
      If found Then stringFound = replacement
      Return (originalString, found)   
   End Function
End Module
' The example displays the following output:
'      A good time to see the world is now.

Mer information finns i Referensreturvärden.

Visual Basic 14

NameOf

Du kan hämta det okvalificerade strängnamnet för en typ eller medlem för användning i ett felmeddelande utan att hårdkoda en sträng. På så sätt kan koden förbli korrekt vid refaktorisering. Den här funktionen är också användbar för att ansluta MVC-länkar för model-view-controller och starta egenskapsändringshändelser.

Stränginterpolation

Du kan använda stränginterpolationsuttryck för att konstruera strängar. Ett interpolerat stränguttryck ser ut som en mallsträng som innehåller uttryck. En interpolerad sträng är lättare att förstå med avseende på argument än sammansatt formatering.

Åtkomst och indexering för null-villkorlig medlem

Du kan testa null på ett mycket lätt syntaktiskt sätt innan du utför en åtgärd för medlemsåtkomst (?.) eller index (?[]). De här operatorerna hjälper dig att skriva mindre kod för att hantera null-kontroller, särskilt för fallande datastrukturer. Om den vänstra operanden eller objektreferensen är null returnerar åtgärderna null.

Strängliteraler med flera rader

Strängliteraler kan innehålla sekvenser med ny rad. Du behöver inte längre det gamla arbetet med att använda <xml><![CDATA[...text with newlines...]]></xml>.Value

Kommentarer

Du kan lägga kommentarer efter implicita radfortsättningar, inuti initieringsuttryck och bland LINQ-uttryckstermer.

Smartare fullständigt kvalificerad namnmatchning

Med kod som Threading.Thread.Sleep(1000), Visual Basic används för att leta upp namnområdet "Threading" upptäcker du att det var tvetydigt mellan System.Threading och System.Windows. Trådning och rapportera sedan ett fel. Visual Basic överväger nu båda möjliga namnrymder tillsammans. Om du visar slutförandelistan visar Visual Studio-redigeraren medlemmar från båda typerna i slutförandelistan.

Datumliteraler för första året

Du kan ha datumliteraler i yyyy-mm-dd-format, #2015-03-17 16:10 PM#.

Skrivskyddade gränssnittsegenskaper

Du kan implementera skrivskyddade gränssnittsegenskaper med hjälp av en skrivskyddad egenskap. Gränssnittet garanterar minsta funktionalitet och hindrar inte en implementeringsklass från att tillåta att egenskapen anges.

TypeOf <expr> IsNot-typ <>

Om du vill ha mer läsbarhet för din kod kan du nu använda TypeOf med IsNot.

#Disable varnings-ID <> och #Enable varnings-ID <>

Du kan inaktivera och aktivera specifika varningar för regioner i en källfil.

Förbättringar av XML-dokumentkommentar

När du skriver dokumentkommenterar får du smart redigeringsprogram och stöd för validering av parameternamn, korrekt hantering av crefs (generiska objekt, operatorer osv.), färgläggning och refaktorisering.

Partiella modul- och gränssnittsdefinitioner

Förutom klasser och strukturer kan du deklarera partiella moduler och gränssnitt.

#Region direktiv inuti metodorgan

Du kan placera #Region...#End områdesavgränsare var som helst i en fil, inuti funktioner och till och med sträcka sig över funktionskroppar.

Åsidosättningsdefinitioner är implicit överlagringar

Om du lägger till Overrides modifieraren i en definition lägger kompilatorn implicit till Overloads så att du kan skriva mindre kod i vanliga fall.

CObj tillåts i attributargument

Kompilatorn som används för att ge ett fel om att CObj(...) inte var en konstant när den användes i attributkonstruktioner.

Deklarera och använda tvetydiga metoder från olika gränssnitt

Tidigare gav följande kod fel som hindrade dig från att IMock deklarera eller anropa GetDetails (om dessa hade deklarerats i C#):

Interface ICustomer
  Sub GetDetails(x As Integer)
End Interface

Interface ITime
  Sub GetDetails(x As String)
End Interface

Interface IMock : Inherits ICustomer, ITime
  Overloads Sub GetDetails(x As Char)
End Interface

Interface IMock2 : Inherits ICustomer, ITime
End Interface

Nu använder kompilatorn vanliga regler för överbelastningsmatchning för att välja det lämpligaste GetDetails att anropa, och du kan deklarera gränssnittsrelationer i Visual Basic som de som visas i exemplet.