Dieser Artikel wurde maschinell übersetzt.

Basic Instincts

Auflistung und Array-Initialisierungen in Visual Basic 2010

Adrian Spotty Bowles

Einige der Sprachänderungen, die während der Microsoft Visual Studio (VS) 2010 Produktzyklus stattgefunden haben abzielt vereinfachen von Aufgaben, die nur mithilfe der viel Standardcode zuvor möglich waren. Diese Vorgehensweise in Visual Studio 2010 verbessert die Codierung Erfahrung machen Sie produktiver. Eines der neuen in Visual Studio für die Veröffentlichung 2010 Features ist Auflistung Initialisierungen. Dieses Feature war in 2008 in c# verfügbar und als Teil der allgemeinen Parität Philosophie werden Microsoft übernehmen. Einige Änderungen an Visual Basic 2010 möglicherweise weniger sofort offensichtlich und in diesem Artikel wird einiger weniger offensichtlich Implementierungsdetails identifizieren.

Sammlungen und Arrays sind sehr häufig Konstrukte in einer modernen Anwendung, und diese Auflistungen haben häufig initialisiert werden. Vor zu den Versionen 2010 Visual Basic war grundlegende Arrayinitialisierungen mit einigen Einschränkungen zu verarbeiten, jedoch Sammlungen konnten nicht in einer ähnlichen einzeilige-Anweisung initialisiert werden, die häufig Standardcode wie folgt geführt:

Dim x As New List(Of String)
        x.Add("Item1")
        x.Add("Item2")

Oder es für die Klasse einen Konstruktor erstellen, verwenden etwa Folgendes erforderlich:

Dim x as new list(of string)({"Item1","Item2"})

Keiner dieser Ansätze waren besonders Elegantes Lösungen.

Obwohl beide gearbeitet, diese beteiligt, zusätzlichen Code die Auflistung initialisiert werden. Obwohl dieser Code oft einfach Standardcode ist, können Sie den Quellcode Vergrößerung was zu zugeordneten Wartungskosten führen kann.

Wenn Sie über nahezu jeder Code, die Auflistungen verwendet ansehen, sehen Sie ähnlichen Standardcode. Im vorangehenden Beispiel wir sind nur zwei Zeichenfolgenelemente hinzufügen und sich wiederholende Aufrufe der Add-Methode für jede der Zeichenfolgen verwenden. Wenn wir eine benutzerdefinierte "benutzerdefinierte" verwendetAuflistung oder eine Auflistung "Benutzer definiert"Typen, würde der Standardcode erhöhen, um dieselbe Aufgabe die Auflistung zu initialisieren.

Neue Syntax

Mit Visual Studio 2010 sind wir jetzt diese Auflistung Initialisierung Aufgabe in einem Formular viel präziser verarbeiten um mehrere Zeilen von Code und wiederholte hinzufügen Methodenaufrufe in eine einzelne Anweisung nach unten verringern:

Dim x As New List(Of String) From {"Item1", "Item2"}

Dies ist eine einfache Beispiel verwenden das Framework generische Liste Auflistungstypen um eine typsichere Auflistung bereitzustellen.Diese Auflistungstypen sind jetzt mehrere häufig verwendete als handcrafted Auflistungstypen, die in der Vergangenheit für das Implementieren typsichere Auflistungen verwendet wurden.

Die Syntax ermöglicht die Auflistungsmember als eine Liste der in den Klammern {} enthaltenen Elemente angegeben werden, und jedes Element wird getrennt durch Semikola verwenden der "FROM"Schlüsselwort, um den ersten Member list. The Beispiel funktioniert gut vor, für einen Listentyp, aber für komplexere Auflistungstypen wie z. B. Wörterbücher, bestimmen, wo möglicherweise ein Schlüssel-Wert-Paar bereitgestellten für jedes Element wir eine Reihe von geschweiften Klammern, um jedes Schlüssel-Wert-Paar Weitere, wie folgt benötigen:

Dim x As New Dictionary(Of Integer, String)
          From {{1, "Item1"}, {2, "Item2"}}

Die Syntax ist sauber und konsistent. Jedes Schlüssel-Wert-Paar wird durch die geschachtelte {} bestimmt, und diese Argumente werden verwendet, wenn ein der Auflistungstyp (Dictionary)-Add-Methode Aufruf. So würde die vorhergehenden Positionen zu entsprechen:

Dim x As New Dictionary(Of Integer, String)
        x.Add(1, "Item1")
        x.Add(2, "Item2")

Implementierung und zur Verwendung in anderen Auflistungstypen

In den vorhergehenden Beispielen Initialisierung Verwendung für typische Framework-Typen von Auflistungen. Allerdings Sie möglicherweise eigene Auflistungstypen implementiert haben oder möglicherweise einige Typen verwenden, können Sie nicht sofort die Initialisierung verwenden, da Sie eine Add-Methode (Beispiele hierfür sind Stack, Queue).

Damit uns das Feature Auflistungsinitialisierer beide dieser Szenarios verwenden, ist es wichtig zu verstehen, etwas über was im Hintergrund geht und wie dieses Feature implementiert wird. Dieses Verständnis können dann uns, seine Verwendung außerhalb der einfache Beispiele zur Liste und Wörterbuch zu erweitern.

Auflistungsinitialisierer Syntax verwenden, benötigen wir zwei Elemente um wahr zu sein. Der Typ muss:

  1. Implementieren Sie dem IEnumerable-Muster entweder die IEnumerable-Schnittstelle oder einfach über eine GetEnumerator-Methode. Dies kann als "Duck" bezeichnet werdenEingabe: Wenn es wie eine Duck sieht und wie eine Duck quacks, ist es wahrscheinlich eine Duck.
    In unserem Fall enthält eine GetEnumerator-Methode mit entsprechender Signatur wird dann wahrscheinlich ähnliches Verhalten für die IEnumerable-Schnittstelle implementiert. Dieses Verhalten Duck eingeben wird bereits verwendet, um mit der For verwendet werden sollen ermöglichen jedes Konstrukt.
  2. Enthalten Sie mindestens eine zugängliche Add-Methode mit einem Parameter. Dies kann eine Instanz oder eine Erweiterungsmethode sein.

Wenn eine Auflistungsklasse beiden folgenden Bedingungen erfüllt, können Sie die Syntax die Auflistungsinitialisierer. 

Für Auflistung Initialisierungen wir nicht tatsächlich verwenden die IEnumerable-Methode zum Initialisieren der Auflistung, sondern wir verwenden es als einen Hinweis ermitteln, ob diese Art, in der Tat ein Auflistungstyp ist. Wenn es IEnumerable oder das Muster IEnumerable implementiert, besteht eine hohe Wahrscheinlichkeit, dass Sie eine Auflistung, verfügen jedoch nicht gewährleistet.

Die Add-Methode wird für jedes Element in der Initialisierungsliste der Auflistung Elemente hinzufügen aufgerufen. Die Tatsache, dass eine Add-Methode vorhanden ist bedeutet nicht zwangsläufig muss es Funktionen zum Hinzufügen von Elementen der Auflistung zu implementieren. Aber Aufrufe ein hinzufügen-Methode mit den Argumenten umgesetzt, aus der Liste"Initialize"erfolgen.

Beispiel zur Veranschaulichung dieser im folgenden Codebeispiel wird im Abbildung 1 ist gültig und kann Auflistungsinitialisierer Syntax verwenden, aber eigentlich keine Elemente einer Auflistung hinzufügen.

Andere Framework-Klassen – Verwendung mit Erweiterungsmethoden

Einige Framework-Auflistungstypen erfüllen nicht beide diese Anforderungen. Stacks und Warteschlangen implementieren Methoden wie POP und Push anstatt hinzufügen. Damit Sie die präzise Auflistungsinitialisierer-Funktion für diese Typen verwenden können, können Sie die Leistungsfähigkeit von Erweiterungsmethoden nutzen. Es ist einfach um eine Methode hinzufügen für diese Typen zu erstellen, die dann Sie die Methoden mit einfachen Syntax initialisieren ermöglichen.

Imports System.Runtime.CompilerServices

Module Module1
    Sub Main()
        Dim st1 As New Stack(Of Integer) From {1, 2, 3}
    End Sub
End Module

Module Extensions
    <Extension()> Sub Add(Of t)(ByVal x As Stack(Of t), ByVal y As t)
        x.Push(y)
    End Sub
End Module

Wenn Erweiterungsmethoden verwenden, ist es im Allgemeinen sollten Sie nur die Typen, die Sie steuern, über erweitern. Liberaler Verwendung von Erweiterungsmethoden kann zu Konflikten führen oder Änderungen im Verhalten Wenn die Typen aktualisiert werden, damit Sie mit Vorsicht.

Mit impliziten Zeile Fortsetzung

Visual Studio 2010 enthält auch ein weiteres wesentlich erwartete Feature: Zeilenfortsetzung. Dieses Feature können Sie die lästigen _ Zeichen zu vermeiden. Implizite Zeilenfortsetzung ist für Elemente in der "initialisieren List" zulässig, daher ist es möglich, jedes dieser Elemente auf eigenen Zeilen aus Gründen der Übersichtlichkeit platzieren.

Dim st1 As New Stack(Of Integer) From {1,
                                       2,
                                       3}

Abbildung 1 Initialisierer Auflistungssyntax

Module Module1
    Sub Main()
        Dim NC As New TestNonCollectionClass From {1, 2, 3}
    End Sub
End Module

Class TestNonCollectionClass
    Public Function GetEnumerator() As System.Collections.IEnumerator
        'Does Nothing
    End Function

    Public Sub Add(ByVal x As Integer)
        If x = 1 Then
            Console.WriteLine("Add Item" & x.ToString)
        End If
    End Sub
End Class

Dies können Sie fehlerfreien Code zu erzeugen, die einfach zu lesen, zusätzliche _ Zeichen nicht enthalten und vermeidet Wiederholung. Sie können für Ihre eigenen Sammlungen und die bereits im Framework verwenden. Der Editor IntelliSense-Unterstützung ermöglicht "FROM"Unterstützung für alle Typen, die die oben genannten zwei Regeln folgen, d. h. für Ihre Auflistungstypen funktioniert. Wenn Sie vorhandenen Code, der das Zeichen _ verwendet haben und es vorziehen, mit der alten Syntax konsistent bleiben, wird diese Option weiterhin unterstützt.

Ausnahmebehandlung Verhalten

Es gibt einige wenige interessante Punkte zu betonen Sie beim Aufrufen der Add-Methode für jedes "Initialisierungsliste"Mitglieder.

Beispielsweise wird wenn ein Aufruf der Add-Methode mit dem bereitgestellten Argument aus der Liste initialisieren Ergebnisse in eine Ausnahme, die Liste nicht mit alle Member initialisiert werden. Bedeutet dies in Wirklichkeit ist, dass die Auflistung überhaupt mit allen Mitgliedern oder nicht initialisiert initialisiert wird.

Dies bedeutet, wenn Ihre Liste drei Elemente und die dritte Wenn aufgerufen, verwenden die Add-Methode Ergebnisse in eine Ausnahme ist, Sie eine Ausnahme ausgelöst wird und eine nicht initialisierte Auflistung abrufen. Die Followingexample absichtlich wird eine Ausnahme zur Veranschaulichung dieses genaue Szenario generiert und Ergebnisse aus "Leer"in der Konsole geschrieben. Jedoch wird der Initialisierungsliste um den Wert 3 entfernen ändern "Initialized: Element Anzahl 2," führenwie im Abbildung 2 dargestellt.

Abbildung 2 der Initialisierungsliste ändern

Imports System.Runtime.CompilerServices

Module Module1
    Sub Main()
        Dim l1 As Stack(Of Integer)
        Try
            l1 = New Stack(Of Integer) From {1, 2}
        Catch ex As Exception
        End Try
        If l1 Is Nothing Then
            Console.WriteLine("Blank")
        Else
            Console.WriteLine("Initialized - Element Count:" & l1.Count)
        End If
    End Sub
End Module

Module Extensions
    <Extension()> Sub Add(Of t)(ByVal x As Stack(Of t), ByVal y As t)
        If y.ToString = "3" Then
            Throw New Exception("Intentional Exception")
        Else
            x.Push(y)
        End If
    End Sub
End Module

Wenn dies nicht, würde erforderlich erstellen zusätzlichen Code zum Bestimmen, ob keine Initialisierung Ausnahmen aufgetreten ist und welchen Status der Auflistung in war.

Mithilfe von Erweiterungsmethoden Syntax verkürzen

Die Standardsyntax für die Initialisierung einer Auflistung von komplexen Objekten führt "New < Typ >" Wiederholenfür jedes der Elemente in der Initialisierungsliste.

Module Module1
    Sub Main()
        Dim CustomerList As New List(Of Customer)
        From {New Customer With {.Name = "Spotty", .Age = 39},
              New Customer With {.Name = "Karen", .Age = 37}}
    End Sub
End Module

Class Customer
    Public Property Name As String = ""
    Public Property Age As Integer = 0
End Class

Die Syntax erfordert, dass jedes Element in der Initialisierungsliste instanziiert wird. Mithilfe der Erweiterungsmethoden kann diese Syntax noch weiter verkürzt werden. Die Funktionalität beruht auf der Tatsache, dass der Auflistungstyp die IEnumerable-Schnittstelle unterstützt und auch verfügt über eine Add-Methode, die in der eingeschlossenen Initialisierungsliste Elemente mit den Parametern Add-Methode zugeordnet wird, als in Abbildung 3 führt.

Abbildung 3 Verwenden von Erweiterungsmethoden

Imports System.Runtime.CompilerServices

Module Module1
    Sub Main()
        'Shortend Syntax through the use of extension methods
        Dim CustomerList As New List(Of Customer) 
          From {{"Spotty", 39}, {"Karen", 37}}

    End Sub
End Module

Module Extension
    <Extension()> Public Sub add(ByVal x As List(Of Customer), _
      ByVal Name As String, ByVal Age As Integer)
        x.add(New Customer With {.Name = Name, .Age = Age})
    End Sub
End Module

Class Customer
    Public Property Name As String = ""
    Public Property Age As Integer = 0
End Class

Fügen Sie die Methode überladen

Die Add-Methode Bedingung ist für dieses Feature von entscheidender Bedeutung und kann überladen werden. Jede Methode wird eine eigene Überladung, die basierend auf der aufrufenden Argumente aufrufen. Es ist keine hier und die Überladungsauflösung Add-Methode funktioniert wie Auflösung funktioniert bei jeder Methode zu überladen.

Dies wird wieder am besten durch ein einfaches Beispiel dargestellt. Im Abbildung 4 verfügen wir über Überladungen für verschiedene Datentypen – wir werden die für das aufrufende Argument aufrufen.

Warum werden die Syntax verwenden 'FROM' und nicht '='?

Eine allgemeine Frage gestellte des Produktteams für dieses Feature ist die Verwendung der "FROM"Schlüsselwort, da die Array-Initialisierungen bereits verwenden die "="für die Zuweisung.

In Visual Basic ist es möglich, eine Auflistungsklasse in drei verschiedene Arten instanziieren:

Dim x1 As New List(Of Integer)
        Dim x2 = New List(Of Integer)
        Dim x3 As List(Of Integer) = New List(Of Integer)

Hinzugefügt die Tatsache, die zwei der Syntax zum Instanziieren einer Auflistung bereits eine = Zeichen in der Syntax. Mithilfe zusätzlicher = Zeichen führt zu Verwirrung in Syntax zwischen der Zuweisung einer neuen Instanz des Auflistungstyps, Initialisierung der Member der Auflistung.

Mit einem Schlüsselwort anstelle einer = Zeichen bestimmen das Ergebnis ein Collection initializer-Aktion vermeidet dieses Problem und alle vorhandenen Syntaxkonventionen deklarieren und Initialisieren von Auflistungstypen ermöglicht. Die Möglichkeit zum Bestimmen der Initialisierungsliste bleibt noch die vorhandenen Initialisierer Arraysyntax vertraut.

Das FROM-Schlüsselwort wurde nach viel Diskussion gewählt. Zu diesen vertraut mit LINQ-Abfragen mag es eine seltsame Wahl, da bereits eine FROM-Schlüsselwort in LINQ. Es scheint, dass diese Auswahl zu potenziellen Mehrdeutigkeit könnten in LINQ-Abfragen aber wie wir sehen werden, dies nicht der Fall ist.

'FROM' nichtMit 'FROM' in Konflikt stehenin Abfragen?

Sogar in Abfragen, die Auflistung Initialisierungen enthalten, besteht keine Mehrdeutigkeit des Schlüsselwortes. Dies kann durch den folgenden Code dargestellt:

Module Module1
    Sub Main()
        'The first from is the query,
        'the second is the collection initializer.
        'The parser can always successfully identify the difference
        Dim x = From i In New List(Of Integer) From {1, 2, 3, 4}
                Where i <= 3
                Select i
        For Each i In x
            Console.WriteLine(i)
        Next
        Stop
    End Sub
End Module

Einschränkungen mit Auflistung Initalizer und Objektinitialisierer

Für das Produkt 2008 implementiert Visual Basic-Team Objektinitialisierer, die den Entwickler, Objekt-Felder/Eigenschaften initialisieren, wenn Sie eine Objektinstanz instanziieren wurden aktiviert:

Dim x As New List(Of Integer) With {.Capacity = 10}

Es ist jedoch nicht möglich, das Objekt und der Auflistung in der gleichen Deklaration initialisiert, sodass der folgende Code einen Syntaxfehler erzeugt:

Dim x as New List(Of Integer) from {1,2,3} With {.Capacity = 10}

Es gibt einige andere weniger offensichtlichen Änderungen, die beim 2010 im Zusammenhang mit Arrays, die möglicherweise nicht sofort erkennbar, jedoch konnte haben Auswirkungen auf Code mit Arrays.

Abbildung 4 Überladungen für verschiedene Datentypen

Imports System.Runtime.CompilerServices

Module Module1
    Sub Main()
        Dim l1 As New Stack(Of Integer) From {1, 2.2, "3"}
        Console.WriteLine("Element Count:" & l1.Count)
        Stop
    End Sub
End Module

Module Extensions
    <Extension()> Sub Add(ByVal X1 As Stack(Of Integer), _
      ByVal x2 As Integer)
        Console.WriteLine("Integer Add")
        X1.Push(x2)
    End Sub
    <Extension()> Sub Add(ByVal X1 As Stack(Of Integer), _
      ByVal x2 As Double)
        Console.WriteLine("Double Add")
        X1.Push(CInt(x2))
    End Sub
    <Extension()> Sub Add(ByVal X1 As Stack(Of Integer), _
      ByVal x2 As String)
        Console.WriteLine("String Add")
        X1.Push(CInt(x2))
    End Sub
End Module

Array-Initialisierung-Änderungen

Obwohl vor 2010 Version es möglich, einfache Arrays initialisieren war, gab immer noch einige Einschränkungen. Die neuesten Änderungen ermöglicht Arraytypen initialisiert und präziser Weise hergeleitet werden.

Zuvor erforderlich, um ein Element in Visual Basic als Array identifizieren Sie einen Satz Klammern auf den Bezeichner angeben:

Dim a() As Integer = {1, 2, 3}

Jetzt diese Klammern nicht erforderlich sind, und der Typ als ein Arraytyp mit Option Infer On, führt eine präziser Syntax abgeleitet:

Dim a = {1, 2, 3}

Array-Typrückschluss

In 2008 wurde die Typableitung Funktion implementiert, die Datentypen, um von deren Zuordnung Werte abgeleitet werden aktiviert. Dies war für einzelne im Methodentext deklarierten Objekte, aber Arrays ein nicht ableiten und wurden daher immer Arrays von Objekten.

Sub Main()
        Dim a() = {1, 2, 3}
          'Type would previously result in Object Array prior to 2010
    End Sub

Dies verbessert, und jetzt Arraytypen werden hergeleitet, wie folgt:

Sub Main()
        Dim a = {1, 2, 3} 'Type now infers Integer Array
    End Sub

Der abgeleitete Typ des Arrays wird durch die dominante Typ-Funktionalität in 2008 hinzugefügt bestimmt. Diese Typrückschluss funktioniert immer noch nur für Code im Methodentext, deklariert, damit Felder Objektarrays weiterhin werden, sofern nicht ausdrücklich eingegeben.

Es ist möglich, mehrere Dimensionen des Arrays zu initialisieren, aber alle geschachtelten Paare müssen die gleiche Anzahl von Elementen enthalten. Damit zwei Dimension Beispiele funktionieren.

Die beiden folgenden Beispiele werden beides ein zweidimensionales Array erstellt:

Dim TwoDimension1(,) = {{1, 2}, {3, 4}}
        Dim TwoDimension2 = {{1, 2}, {3, 4}}

Für eindimensionale Arrays die Syntax ist sehr ähnlich vorherigen Code, und alle vorhandener Code wird zum Arbeiten mit wenigen Ausnahmen fortgesetzt.

Dim a() = {1, 2, 3}

In der vorherigen Anweisung wird der Arraytyp aus der Initialisierungsliste hergeleitet. Dadurch werden ein Ganzzahlarray abgeleitet wird. In der Vergangenheit hätten diese einfach Objekt Arrays wie wir keine Arraytyp aus der Initialisierungsliste abgeleitet haben würde. Wenn Sie keinen Code, die überprüft den Typ verwenden, verwendet die Reflektion oder enthält mehrere Überladungen einschließlich Array von Objekttypen, kann dies jetzt verschiedene Ergebnissen führen. Beispiele hierfür sind möglicherweise die spät gebundene Methoden.

Mehrdimensionale Arrays

Für Sie ein mehrdimensionales Array zu initialisieren müssen die Dimensionen die Elementanzahl in der Initialisierungsliste übereinstimmen. Wenn diese sind nicht identisch, und alle geschachtelten Elemente in der Initialize-Liste verfügen nicht über eine konsistente Elementanzahl, wird dann ein Syntaxfehler auftreten:

Dim TwoDimension2 = {{1, 2}, {3, 4}}
  'Valid 2 dimension integer(,) array inferred
Dim TwoDimension2Invalid(,) = {{1}, {3}}
  'Invalid – dimension and element count mismatch
Dim TwoDimension2Invalid1(,) = {{1, 2}, {3}}
  'Invalid:element count not consistent in Initializer List

Dies bedeutet, dass mithilfe der ähnlichen Syntax wie vor, es möglich ist Standard initialisieren eindimensionale Arrays behoben.

Verzweigtes Array-Initialisierung

Das bedeutet jedoch, dass für ein verzweigtes Array (ein Array von Arrays) dieser Syntax nicht funktioniert unverändert. Um verzweigte Array-Initialisierungen zu ermöglichen, ist es erforderlich, dass jede Element-Listen in Klammern umbrechen:

Sub Main()
        'Incorrect Jagged Array syntax
        Dim JaggedDimensionIncorrect()() = {{1,2},{3,4,5}}

        'Correct Jagged Array syntax
        Dim JaggedDimension1()() = {({1,2}),({3,4,5})}
    End Sub

Im vorhergehende Beispiel führt die folgenden:

  • JaggedDimension1(0) mit Integer-Array mit Elementen 1,2
  • JaggedDimension1(1) mit Integer-Array mit Elementen 3,4,5

Der Typrückschluss Array funktioniert für die geschachtelte Arraytypen. Hier ist etwas komplexer Beispiel:

Dim JaggedDimension1() = {({1, 2}), ({3.1, 4.2, 5.3})}

Dies führt in JaggedDimension1 Object() sowie die Member hergeleitet wird wird der Typ Integer() und Double().

Erwartetes Verhalten und Array Rückschlussregeln

So überprüfen Sie in der Initialisierungsliste als hergeleiteten Array. Nicht! Der Initialisierungsliste ist kein konkreter Typ, wie Sie denken vielleicht;Es ist eine syntaktische Darstellung einer Liste von Elementen, die wird von einem bestimmten Typ je nach Kontext verwendet wird.

Im folgenden Codebeispiel wird veranschaulicht, dass wir verwenden können, die {,} Syntax:

1. Ableiten und ein Integer-Array zu initialisieren:

Dim a = {1, 2, 3}  'Infers Integer Array

Dies funktioniert wie keine Zieltyp angegeben ist und Sie seinen Typ basierend auf der vorherrschende Typ der Member Initialisierungsliste leitet.

2. Initialisieren Sie ein Array von anderen Typ:

Dim b As Single() = {1, 2, 3}
  'Will convert each integer value into single

Dies funktioniert, als wir eine Matrix mit Werten eine, zwei und drei initialisiert wird. Der Initialisierungsliste hat keine systeminternen Typ selbst.

Aber im folgenden wird erwartet, fehlschlagen:

Dim a = {1, 2, 3}  'Infers Integer()
        Dim c As Single() =
          a 'No conversion between Single() and Integer()

Dies mag etwas seltsam aber Variable eine als Array von Ganzzahlen abgeleitet ist und mit einem, zwei und drei Werten initialisiert. Variable c wird als einzelnes Array deklariert. Es ist jedoch keine Konvertierung zwischen einem einzelnen Array und ein Integer-Array den Syntaxfehler verursacht.

Eigenständiges Array Initialisierer Verwendung

Das Array Initialisierungsliste auch in einem Kontext eigenständige verwendet werden kann in diesem Fall es müssen keine angegebenen Zieltyps und arbeitet als ein Array vom bestimmenden Typ der Mitglieder der Liste initialisieren.

Dadurch können einige interessante Szenarios, die zuvor nicht verfügbar. Ein Beispiel könnte eine Methode sein, die in einem Array von Elementen, die Sie verwenden annimmt, um eine Datenstruktur initialisieren möchten. Des Methodenaufrufs bestimmt verschiedene Standardwerte, die als Aufruf Argumente verwendet werden, wie in Abbildung 5 dargestellt.

In diesem Fall erstellen wir ein Array lokalen für jeden Aufruf einfach, einen Arraytyp an die Methode übergeben. Mit dem neuen eigenständigen-Syntax-Feature ist möglich, Vermeiden unnötiger lokal für diese Art von Szenario zu erstellen und einfach können Sie die eigenständige Initialisierungsliste Arraytypen übergeben.

Der Initialisierungsliste in eigenständigen-Verwendungsszenario richtet hergeleiteten Arraytyp. So kann in einem Verwendungsszenario eigenständige initialisieren Liste als Array literal betrachtet werden. Dadurch müssen Elemente deklarieren, die nur in begrenzten Instanzen wie einzelne Methodenaufrufe verwendet werden soll.

Abbildung 5 verschiedene Standardwerte, die als Argumente für Aufruf verwendet werden

Module Module1

    Sub InitializeMethod(ByVal x As String())
        '....
    End Sub

    Sub Main()
        Dim i As Integer = 1

        Select Case I
            Case 1
                Dim Array1 As String() = {"Item1", "Item2"}
                InitializeMethod(Array1)
            Case 2
                Dim Array1 As String() = {"Item11", "Item12"}
                InitializeMethod(Array1)
        End Select
    End Sub
End Module

Verwenden mit anderen Features 2010

Eines der Features der 2010-Version des Produkts ist mehrfach Zielgruppenadressierung. Obwohl dieses Feature in die 2008-Version vorhanden ist, einige Verbesserungen wurden vorgenommen, die viele der Sprachfeatures in der 2010 Version des Produkts auf nach unten gerichtet Versionen verwendet werden können (2.0, 3.0 und 3.5 Ziele). Daher können Sie diese verbesserten Funktionalität für die Auflistung und Array-Initialisierungen für Ihre vorhandenen Anwendungen bei Verwendung die 2010 Version des Produkts. So können Sie den vorhandenen Quellcode vereinfachen und nutzen Sie die neue Sprache-Funktion.

Also wenn Sie diese neue Funktionalität verwenden, ist es potenzielle für vorhandenen Code beschädigen? Die Antwort ist Ja, es gibt einige Potenzial für Abwärtskompatibilität Seitenumbrüche, aber dies ist beschränkt auf wenige Szenarien, in denen die Vorteile überwiegen die ursprünglichen unterbrechende Änderung und problemlos die vorhandene Funktionalität beibehalten werden:

Dim x1() = {1, 2, 3}

In früheren Versionen die vorangehende Codezeile würde führten in ein Objektarray mit Visual Studio 2010 diese werden jedoch in den bestimmenden Typ der Elemente Typ abgeleitet – in diesem Fall Integer(). Das ist der Fall, unabhängig davon, ob Sie 4.0 abzielen oder nach unten Zielgruppenadressierung auf eine frühere Version. Wenn Code eine bestimmte Art von Object-Array erwartet wird, kann dieser Code fehlschlagen. Problemlos kann behoben werden, indem Sie explizit den Zieltyp:

Dim x1() As Object = {1, 2, 3}

Die Ausnahme dieses Verhalten ist, wenn kein bestimmenden Typ für die Elemente besteht:

Dim x1() = {1, 2.2, "test"}

Dadurch wird das frühere Verhalten führt X 1 wird ein Objektarray beibehalten.

Einfache Anwendung

Auflistung Initialisierungen sind eine großartige Ergänzung für die Sprache. Sie ermöglichen sehr viel präziser Syntax um Framework und von benutzerdefinierten Auflistungstypen zu initialisieren. Mit minimalen Änderungen kann diese Syntax problemlos auf vorhandenen Code angewendet werden.

Die Funktionalität ist ideal, um andere Sprache Funktionen z. B. Erweiterungsmethoden, aktivieren die Reduzierung der Verwendung der Syntax für alle Auflistungstypen verwenden zu können. Diese Verringerung Standardcode zuvor verwendete macht den Code kleiner und einfacher zu verwalten.

Das Array Initialisierer Verhalten wurde leicht geändert, führt Array Typrückschluss und, eigenständige Verwendung von Arrays ermöglichen eine verbesserte Funktionalität implementieren und eine verbesserte Möglichkeit, mehrdimensionale und verzweigte Arrays gegenüber früheren Versionen zu initialisieren.

Nahezu jeder Anwendung verwendet Arrays oder Auflistungen und dieses Feature können in nahezu allen Projekten verwendet werden.

Adrian Spotty Bowles wurde mit jeder Version von Visual Basic entwickelt und verwaltet hat, um seinen Weg in Redmond, Washington, finden auf der Visual Basic-Compiler konzentriert, wo er auf das VBA-Produktteam als ein Software Design Engineer Tester funktioniert. Während der Visual Basic 2008-Version er viele der Sprachfeatures gearbeitet, einschließlich Erweiterung Methods.You erreichen Bowles Abowles@microsoft.com.