Dela via

Nyheter för Visual Basic

Den här artikeln innehåller viktiga funktionsnamn för varje version av Visual Basic. Detaljerade beskrivningar av de nya och förbättrade funktionerna i de senaste språkversionerna finns i de länkade avsnitten.

Aktuell version

Visual Basic 17.13 /Visual Studio 2026
Nya funktioner finns i Visual Basic 17.13.

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

Tidigare versioner

Visual Basic 17.0 /Visual Studio 2022
Nya funktioner finns i Visual Basic 17.0.

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

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
Teknikförhandsversioner av .NET Compiler Platform ("Roslyn")

Visual Basic/Visual Studio 2012
Async och await nyckelord, iteratorer, informationsattribut för anropare

Visual Basic, Visual Studio 2010
Automatiskt implementerade egenskaper, insamlingsinitierare, implicit radfortsättning, dynamisk, allmän co/contra-varians, 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
Bit-shift-operatorer, loopvariabeldeklaration

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

Visual Basic 17.13

Visual Basic 17.13 identifierar den allmänna begränsningen unmanaged . Visual Basic 17.13 identifierar System.Runtime.CompilerServices.OverloadResolutionPriorityAttribute för metodupplösning.

Visual Basic 17.0

Visual Basic 17.0 aktiverar System.Runtime.CompilerServices.CallerArgumentExpressionAttribute.

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. Det är den första versionen av Visual Basic som fokuserar på .NET Core. .NET Core 3.0 lägger till de delar av Visual Basic Runtime som är beroende av Windows Forms.

Kommentarer tillåts på fler platser i -instruktioner

I Visual Basic 15.5 och tidigare versioner kan du bara lägga till kommentarer 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 kan du också lägga till kommentarer efter explicita radfortsättningar och i 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 enkla värden till heltal relativt dåliga prestanda. Visual Basic 16.0 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 och CULng), eller när värdet som returneras av någon av följande metoder implicit omvandlas till en integrerad typ och Alternativet Strikt är inställt på Off:

Den här optimeringen gör att koden 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 optimeringen påverkar:

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

Den här optimeringen 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 innehöll argument både efter position och efter namn, var du tvungen att placera positionsargument före namngivna argument. Från och med Visual Basic 15.5 kan du blanda positionella och namngivna argument i valfri ordning så länge alla argument fram till det sista positionsargumentet är i rätt position. Den här flexibiliteten är särskilt användbar när namngivna argument gör 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 alla medlemmar i dess innehållande klass kan komma åt, samt typer som härleds från den innehållande klassen, men bara om de också finns i den innehållande sammansättningen. Eftersom strukturer inte kan ärvas kan du bara tillämpa Private Protected på medlemmarna i en klass.

Inledande 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 en inledande avgränsare måste du lägga till följande element i visual basic-projektfilen (*.vbproj):

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

Visual Basic 15.3

Namngiven tuppelns slutsatsdragning

När du tilldelar värdena för tupelelement från variabler härleder Visual Basic namnen på tupelelementen från de motsvarande variabelnamnen. Du behöver inte uttryckligen namnge ett tupppelelement. I följande exempel används slutsatsdragning för att skapa en tuppeln med två namngivna element: state och stateName.

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

Visual Basic-kommandoradskompilatorn stöder nu kompilatoralternativen -refout och -refonly för att styra utdata från referenssammansättningar. Använd -refout för att definiera utdatakatalogen för referenssammansättningen. Använd -refonly för att ange att kompilering endast matar ut en referenssammansättning.

Visual Basic 15

Tupler

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

  • Definiera en anpassad typ (en Class eller en Structure). Det här alternativet är en tungviktslösning.

  • Definiera en eller flera ByRef parametrar, förutom att returnera ett värde från metoden.

Med Visual Basics 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 i följande exempel.

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

C# stöder referensreturvärden. När anropande metoden 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 anroparen förutom att läsa det returnerade värdet även kan ändra det och att ä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 den enklaste formen kan du ändra ordet som finns i meningen med hjälp av kod som i följande exempel. 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 det här problemet genom att det första ordet ersätts med sig själv 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. Den här metoden håller koden korrekt vid refaktorisering. Den här funktionen är också användbar för att ansluta MVC-länkar för model-view-controller och aktivera ändrade händelser för egenskapen.

Stränginterpolation

Använd 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å när det gäller 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 nya radsekvenser. Du behöver inte längre den gamla lösningen med att använda <xml><![CDATA[...text with newlines...]]></xml>.Value.

Comments

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

Smartare fullständigt kvalificerad namnmatchning

Med kod som Threading.Thread.Sleep(1000) brukade Visual Basic slå upp namnområdet "Threading", upptäcka att det var tvetydigt mellan System.Threading och System.Windows.Threading, och sedan rapportera ett fel. Visual Basic tar nu hänsyn till båda möjliga namnområden 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#.

Readonly-gränssnittsegenskaper

Du kan implementera readonly-gränssnittsegenskaper med hjälp av en skrivbar 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 stöd för smart redigerare och bygge för validering av parameternamn, korrekt hantering av crefs (till exempel generiska objekt och operatorer), färgläggning och refaktorisering.

Partiella modul- och gränssnittsdefinitioner

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

#Region direktiv inuti metodorgan

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

Åsidosättningar är implicit överbelastningar

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

Du kan nu använda CObj(...) i attributargument. Tidigare returnerade kompilatorn ett fel om att det inte var en konstant.

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

Tidigare returnerade följande kod fel som hindrade dig från att IMock deklarera eller anropa GetDetails (om dessa metoder deklarerades 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 normala regler för överbelastningsmatchning för att välja den lämpligaste GetDetails metoden att anropa. Du kan deklarera gränssnittsrelationer i Visual Basic som de som visas i exemplet.

Se även

  • Last updated on