Cet article a fait l'objet d'une traduction automatique.
Basic Instincts
Collection et les initialiseurs de tableau dans Visual Basic 2010
Adrian Spotty Bowles
Certaines des modifications de langue qui ont eu lieu pendant le cycle de produit Microsoft Visual Studio (VS) 2010 ont été destinées à simplifier les tâches qui étaient auparavant possible uniquement via l'utilisation des beaucoup de code réutilisable. Cette approche dans Visual Studio 2010 améliore la programmation, vous rendre plus productif. Une des fonctionnalités nouvelles dans Visual Studio pour la version 2010 est initialiseurs de la collection. Cette fonctionnalité était disponible dans le langage c# en 2008 et le cadre de la philosophie de parité général Microsoft a été adopté. Certaines des modifications apportées à Visual Basic 2010 peuvent être moins évidente, et cet article permettra d'identifier certains détails d'implémentation moins évidentes.
Collections et tableaux sont des constructions très courantes dans n'importe quelle application moderne, et ces collections doivent souvent être initialisé. Avant pour les versions 2010, Visual Basic était capable de gérer les initialiseurs de tableau de base avec certaines limitations, mais collections ne pouvaient pas être initialisée dans une instruction une ligne similaire, qui traduit souvent par code réutilisable comme suit :
Dim x As New List(Of String)
x.Add("Item1")
x.Add("Item2")
Ou elle nécessite la création d'un constructeur pour la classe, ce qui suit à l'aide :
Dim x as new list(of string)({"Item1","Item2"})
Aucune de ces approches ont été particulièrement élégant solutions.
Bien que les deux les travaillé, impliquées écrire de code supplémentaire pour initialiser la collection. Bien que ce code soit souvent code simple, il peut gonflements le code source, qui peut entraîner des coûts de maintenance associées.
Si vous examinez presque n'importe quel code qui utilise des collections, vous verrez du code réutilisable similaire. Dans l'exemple précédent, nous ajoutez deux éléments de chaîne et utilisez les appels à la méthode add pour chacune des chaînes. Si nous avons utilisé un personnalisé "définis par l'utilisateur"collection ou à une collection de "définis par l'utilisateur"types, le code standard augmenterait pour faire la même tâche de l'initialisation de la collection.
Nouvelle syntaxe
Avec Visual Studio 2010, nous sommes maintenant capables gérer cette tâche de l'initialisation de collection dans un formulaire plus concis, réduisant la plusieurs lignes de code et des appels de méthode Ajouter répétés dans une seule instruction :
Dim x As New List(Of String) From {"Item1", "Item2"}
Voici un exemple simple utilisant des types de collection liste générique de l'infrastructure pour fournir une collection de type sécurisé. Ces types de collection sont désormais plus couramment utilisé que les types collection handcrafted, qui ont été utilisés dans le passé pour implémenter des collections de type sécurisé.
La syntaxe permet les les membres de collection pour être spécifié comme une liste d'éléments contenus dans les accolades {} et chaque élément est séparé par des virgules à l'aide «FROM»mot clé pour déterminer le list.The membre initial précédent exemple fonctionne correctement pour un type de liste, mais pour des types de collection plus complexes telles que des dictionnaires, où il existe peut-être une paire clé-valeur fournie pour chaque membre, nous avons besoin un jeu supplémentaire d'accolades autour de chaque paire clé-valeur, comme suit :
Dim x As New Dictionary(Of Integer, String)
From {{1, "Item1"}, {2, "Item2"}}
La syntaxe est propre et cohérente. Chaque paire clé-valeur est déterminée par les imbriqué {}, et ces arguments sont utilisés lors d'un appel au type de collection méthode Add (dictionnaire). Par conséquent, les lignes précédentes sont correspondent à :
Dim x As New Dictionary(Of Integer, String)
x.Add(1, "Item1")
x.Add(2, "Item2")
Implémentation et utilisation dans les autres types de collection
Les exemples ci-dessus montrent comment des collections initialiser l'utilisation pour les types framework par défaut. Toutefois, vous peut avoir implémenté vos propres types de collection ou peut utiliser certains types où il est immédiatement Impossible d'utiliser l'initialiseur, car ils ne possèdent pas une méthode Add (exemples incluent Stack, Queue).
Pour nous permettre d'utiliser la fonctionnalité initialiseur de collection dans ces deux scénarios, il est important de comprendre un peu sur ce qui se passe en coulisses et comment cette fonctionnalité est implémentée. Cette présentation puis nous permettra d'étendre son utilisation dépasse les exemples de liste et le dictionnaire simples.
Pour utiliser la syntaxe d'initialiseur de collection, nous avons besoin deux articles à true. Le type doit être :
- Implémenter le modèle IEnumerable, qui peut être l'interface IEnumerable ou ont simplement une méthode GetEnumerator. Ce peut être appelé «duck»tapez : Si elle ressemble à un projet duck et quacks comme un projet duck, il est probablement un canard.
Dans notre cas, si elle contient une méthode GetEnumerator avec une signature appropriée, puis il est probablement implémenter un comportement similaire pour l'interface IEnumerable. Ce comportement en tapant duck est déjà utilisé pour permettre types à utiliser avec pour chaque construction. - Contenir au moins une méthode Ajouter accessible avec un paramètre. Cela peut être une instance ou une méthode d'extension.
Si votre classe de collection remplit les deux conditions suivantes, vous pouvez utiliser la syntaxe d'initialiseur de collection.
Pour des initialiseurs de la collection, nous n'utilisez pas réellement la méthode IEnumerable pour initialiser la collection, mais nous l'utiliser comme indicateur pour déterminer que ce type est, en fait, un type de collection. Si elle implémente IEnumerable ou le modèle de IEnumerable, puis pose une forte probabilité que vous avez une collection, bien qu'il n'est pas garanti.
La méthode Add est appelée pour chaque élément dans la liste initialiseur pour ajouter des éléments à la collection. Le fait que la méthode Add est présente ne signifie pas nécessairement qu'il doit implémenter les fonctionnalités à ajouter des éléments à la collection. Mais les appels à une méthode Add avec les arguments transposé dans la liste «initialisation»seront effectuées.
Pour illustrer ce point, exemple de code suivant dans de la figure 1 est valide et pouvez utiliser la syntaxe d'initialiseur de collection, mais en fait n'est pas ajouter tous les éléments à une collection.
Autres Classes Framework — utilisation de méthodes d'extension
Certains types de collection framework ne répondent à deux ces conditions. Piles et files d'attente implémentent les méthodes telles que POP et commande au lieu d'ajouter. Pour pouvoir l'utiliser la fonctionnalité d'initialiseur de collection concise pour ces types, vous pouvez exploiter la puissance des méthodes d'extension. Il est facile créer une méthode d'ajout d'une extension pour ces types, puis va vous permet d'initialiser les méthodes avec une syntaxe simple.
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
Lorsque vous utilisez les méthodes d'extension, il est conseillé pour développer uniquement les types qui vous ont contrôler. Étendus utilisation des méthodes d'extension peut entraîner des conflits ou les changements de comportement si les types sont mis à niveau, par conséquent, utilisez-les avec prudence.
Utiliser avec la continuation de ligne implicite
Visual Studio 2010 contient également une autre fonctionnalité attendue très : continuation de ligne. Cette fonctionnalité permet de pouvoir éliminer les caractères _ pernicieux. Continuation de ligne implicite est autorisée pour les éléments dans le "initialiser List", il est possible de placer chacun de ces éléments sur leur propre ligne par souci de clarté.
Dim st1 As New Stack(Of Integer) From {1,
2,
3}
Syntaxe d'initialiseur de la figure 1 collection
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
Ainsi, vous permet de produire du code en mode minimal est simple à lire, ne contient pas les caractères _ supplémentaire et permet d'éviter répétition. Vous pouvez l'utiliser pour vos propres collections et pour ceux déjà dans l'infrastructure. Prise en charge IntelliSense de l'éditeur permet «FROM»prise en charge pour tous les types qui suivent les deux règles ci-dessus, ce qui signifie qu'il fonctionnera pour vos types de collection. Si code existant qui utilise le caractère _ et que vous préférez rester cohérent avec l'ancienne syntaxe, ce choix est toujours pris en charge.
Comportement de gestion des exceptions
Il sont quelques exemples intéressants des choses à remarquer lors de l'appel la méthode Add pour chacun de la "liste d'initialiseur"membres.
Par exemple, lorsqu'un appel à la méthode Add avec l'argument fourni dans les résultats liste d'initialisation d'une exception, la liste ne sera pas initialisée avec les membres. Cela signifie en réalité est que la collection est initialisée avec tous les membres ou son non initialisé du tout.
Cela signifie que si votre liste comporte trois éléments et la troisième lorsque appelée en ajouter méthode entraîne une exception, vous obtenez une exception et une collection non initialisée. Le followingexample intentionnellement génère une exception pour illustrer ce scénario précis et résultats de «Blanc»écrits dans la console. Toutefois, la modification de la liste d'initialiseur pour supprimer la valeur trois provoque dans "Initialized : élément nombre 2"comme dans de la figure 2.
La figure 2 modification de la liste d'initialiseur
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
Si cela n'a pas, puis il faudrait élaboration de code supplémentaire pour déterminer si aucune exception d'initialisation s'est produite et quel état de la collection était en.
L'utilisation de méthodes d'extension pour raccourcir la syntaxe
La syntaxe standard pour initialiser une collection de résultats des objets complexes d'avoir à recommencer "Nouveau type de < >"chacun des éléments dans la liste d'initialiseur.
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
La syntaxe requiert que chaque élément dans la liste d'initialiseur est instancié. À l'aide des méthodes d'extension, il est possible réduire encore davantage cette syntaxe. La fonctionnalité repose sur le fait que le type de collection prend en charge l'interface IEnumerable et a également une méthode Add, ce qui entraînera la les éléments de liste d'initialiseur délimités mappés aux paramètres de méthode add, comme illustré à la de la figure 3.
La figure 3 Utilisation de méthodes d'extension
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
Ajouter la surcharge de méthode
La condition de méthode Add est essentielle à cette fonctionnalité et peut être surchargée. Chaque méthode appelle sa propre surcharge basée sur les arguments d'appel. Il n'existe aucune magie ici et la résolution de surcharge de méthode Ajouter fonctionne comme résolution fonctionne pour n'importe quelle méthode de surcharge.
Cela est encore mieux illustré par un exemple simple. Dans de la figure 4, nous avons surcharges pour différents types de données, nous appellerons celui approprié pour l'argument d'appel.
Pourquoi l'utilisation de la syntaxe «FROM» et non '=' ?
Une question courante demandée de l'équipe produit de cette fonctionnalité est l'utilisation de «FROM»mot clé, étant donné que les initialiseurs de tableau déjà utilisez le "="pour l'affectation.
Dans Visual Basic, il est possible instancier une classe de collection de trois manières différentes :
Dim x1 As New List(Of Integer)
Dim x2 = New List(Of Integer)
Dim x3 As List(Of Integer) = New List(Of Integer)
Ajoutez à cela le fait que les deux syntaxes pour instancier une collection déjà incluent un caractère dans la syntaxe =. L'utilisation supplémentaires = caractère aurait pour résultat confusion dans la syntaxe entre que d'affectation d'une nouvelle instance du type de collection et initialisation des membres à la collection.
À l'aide un mot clé plutôt qu'un caractère = pour déterminer le résultat d'une action Collection Initializer évite ce problème et permet à tous les conventions de syntaxe existante déclarer et initialiser les types de collection. La façon de déterminer la liste d'initialiseur reste encore familière à la syntaxe d'initialiseur de tableau existant.
Le mot clé FROM a été choisi après beaucoup discussion. Pour les requêtes LINQ connaissant, il peut sembler étrange choix qu'il existe déjà un mot clé FROM utilisé dans LINQ. Il peut sembler que ce choix pourrait entraîner des ambiguïtés potentielles lorsqu'il est utilisé dans les requêtes LINQ, mais comme nous le verrons, ce n'est pas le cas.
N'est pas 'FROM'Entrer en conflit avec 'FROM'dans des requêtes ?
Même dans les requêtes contenant des initialiseurs de collection, il n'existe aucune ambiguïté du mot clé. Cela peut être illustré par le code suivant :
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
Limitations de l'utilisation de collections Initalizer avec initialiseur d'objet
Pour le produit 2008, l'équipe Visual Basic implémenté initialiseurs d'objet qui permettait au développeur d'initialiser objet champs/propriétés lorsqu'ils ont été instancier une instance d'objet :
Dim x As New List(Of Integer) With {.Capacity = 10}
Toutefois, il n'est pas possible d'initialiser l'objet et la collection sur la même déclaration, afin que les éléments suivants produira une erreur de syntaxe :
Dim x as New List(Of Integer) from {1,2,3} With {.Capacity = 10}
Il existe quelques autres modifications moins évidentes dans 2010 relatives aux tableaux qui ne sont pas immédiatement visible mais peuvent avoir impact sur le code à l'aide de tableaux.
Figure 4 Overloads de types de données différents
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
Modifications d'initialiseur de tableau
Bien qu'avant vers la version 2010, il était possible d'initialiser des tableaux simples, il y avait toujours quelques limitations. Une des modifications récentes permet aux types tableau être initialisé et déduit de manière plus concise.
Auparavant, pour identifier un élément dans Visual Basic sous la forme d'un tableau requis de spécifier un jeu de parenthèses sur l'identificateur :
Dim a() As Integer = {1, 2, 3}
Maintenant ces parenthèses ne sont pas requis et le type sera déduit en tant que type tableau avec Option Infer On, ce qui entraîne une syntaxe plus concise :
Dim a = {1, 2, 3}
Inférence de type tableau
En 2008, la fonctionnalité inférence de type a été implémentée, qui activé être déduit de leurs valeurs d'affectation des types de données. Il a travaillé pour des objets déclarés dans le corps de méthode, mais les tableaux ne reconnaît pas un type et par conséquent étaient toujours tableaux d'objets.
Sub Main()
Dim a() = {1, 2, 3}
'Type would previously result in Object Array prior to 2010
End Sub
Cela a été améliorée et maintenant les types tableau sont déduits, comme suit :
Sub Main()
Dim a = {1, 2, 3} 'Type now infers Integer Array
End Sub
Le type déduit du tableau est déterminé par la fonctionnalité de type principal ajoutée dans 2008. Cette inférence de type fonctionne toujours uniquement pour code déclarée dans le corps de méthode, afin de champs seront toujours tableaux d'objets, sauf si spécialement typée.
Il est possible d'initialiser plusieurs dimensions du tableau, mais toutes les paires imbriquées doivent contenir le même nombre de membres. Exemples ainsi deux-dimension fonctionneront.
Les deux exemples suivants à la fois créera un tableau d'entiers à deux dimensions :
Dim TwoDimension1(,) = {{1, 2}, {3, 4}}
Dim TwoDimension2 = {{1, 2}, {3, 4}}
Pour les tableaux unidimensionnels, la syntaxe est très similaire au code précédent et tout code existant continueront à fonctionner à quelques exceptions près.
Dim a() = {1, 2, 3}
Dans l'instruction précédente, le type du tableau sera déduit à partir de la liste d'initialiseurs. Cela entraîne un tableau d'entiers est déduit. Dans le passé, ces aurait simplement été tableaux d'objets que nous n'avez serait pas déduit n'importe quel type de tableau dans la liste initialiseur. Si vous utilisez n'importe quel code qui vérifie le type, utilise la réflexion ou contient plusieurs surcharges notamment les types tableau objet, cela peut désormais produire des résultats différents. Cela peut exemples de méthodes à liaison tardive.
Tableaux multidimensionnels
Pour, vous devez initialiser un tableau multidimensionnel les dimensions doivent correspondre au nombre d'éléments dans la liste d'initialiseur. Si ceux-ci ne sont pas le même et tous les éléments imbriqués de la liste d'initialisation n'ont pas un nombre d'éléments cohérente, une erreur de syntaxe se produit :
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
Cela signifie qu'utilisant la syntaxe similaire que précédemment, il est possible d'initialisation standard dimensions des tableaux.
Initialisation de tableau en escalier
Cependant, cela signifie que pour un tableau en escalier (un tableau de tableaux), cette syntaxe ne fonctionne que. Pour permettre les initialiseurs de tableau en escalier, il est nécessaire que vous encapsulez chacune des listes de membres dans entre parenthèses :
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
L'exemple précédent donne les éléments suivants :
- JaggedDimension1(0) contenant le tableau entier avec des éléments 1,2
- JaggedDimension1(1) contenant le tableau entier avec des éléments 3,4,5
L'inférence de type tableau fonctionnera pour les types tableau imbriqué. Voici un exemple légèrement plus complexe :
Dim JaggedDimension1() = {({1, 2}), ({3.1, 4.2, 5.3})}
Ceci peut entraîner des JaggedDimension1 déduit que Object() et les membres étant de type Integer() et Double().
Inférence de tableau et le comportement prévu
Par conséquent, vous rechercher dans la liste d'initialiseur comme un tableau inféré. Ne pas ! La liste d'initialiseur n'est pas un type concret comme vous le pensez ;Il est une représentation syntaxique d'une liste de membres, qui devient un type spécifique en fonction du contexte qu'il est utilisé dans.
L'exemple de code suivant illustre que nous pouvons utiliser la {,} syntaxe pour :
1. Déduire et initialiser un tableau d'entiers :
Dim a = {1, 2, 3} 'Infers Integer Array
Cette méthode fonctionne comme aucun type de cible n'est spécifié et il détermine son type selon le type principal des membres de liste d'initialiseur.
2. Initialiser un tableau de type différent :
Dim b As Single() = {1, 2, 3}
'Will convert each integer value into single
Cela ne fonctionne que nous va s'initialiser un tableau unique avec des valeurs un, deux et trois. La liste d'initialiseur n'a aucun type intrinsèque par lui-même.
Mais les éléments suivants sont attendu à échouer :
Dim a = {1, 2, 3} 'Infers Integer()
Dim c As Single() =
a 'No conversion between Single() and Integer()
Cela peut sembler un peu étrange mais variable un est inféré en tant qu'un tableau d'entiers et initialisé avec les valeurs un, deux et trois. C variable est déclarée comme un tableau unique. Toutefois, il n'existe aucun conversion entre un tableau unique et un tableau entier, ce qui provoque l'erreur de syntaxe.
Utilisation d'initialiseur de tableau autonome
Le tableau liste initialiseur peuvent également servir dans un contexte autonome, dans ce cas, il aura pas ont un type de cible spécifié et va fonctionner comme un tableau du type principal des membres de la liste d'initialisation.
Cela permet à certains scénarios intéressants n'est pas déjà disponibles. Un exemple pourrait être une méthode qui prend un tableau d'éléments que vous souhaitez utiliser pour initialiser une structure de données. Où la méthode est appelée détermine les valeurs par défaut différent, qui sont utilisés comme arguments d'appel, comme dans de la figure 5.
Dans ce cas, nous créer un tableau local pour chaque appel, tout simplement à transmettre un type tableau à la méthode. Avec la nouvelle fonctionnalité de l'utilisation autonome, il est possible éviter de créer des variables locales inutiles pour ce type de scénario et vous pouvez utiliser simplement la liste d'initialiseur autonome pour passer des types tableau.
La liste d'initialiseur dans le scénario d'utilisation autonome s'aligne sur un type tableau inféré. Donc dans un scénario d'utilisation autonome, la liste d'initialisation peut considérer comme un tableau littérale. Ceci évite à déclarer des éléments qui sont uniquement doit être utilisé dans les instances limitées, telles que les appels de méthode individuelle.
La figure 5 différentes valeurs par défaut utilisés comme arguments d'appel
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
Utilisation avec les autres fonctionnalités 2010
Une des fonctionnalités de la version 2010 du produit est multiversions. Bien que cette fonctionnalité existe dans la version 2008, certaines améliorations ont été apportées qui permettent de nombreuses fonctionnalités langue dans la version 2010 du produit pour être utilisé sur versions ciblés vers le bas (2.0, 3.0 et 3.5 cibles). Par conséquent, vous pouvez utiliser cette fonctionnalité améliorée de collection et les initialiseurs de tableau pour vos applications existantes si vous utilisez la version 2010 du produit. Cela permet de simplifier votre code source existant et profiter des nouvelles fonctionnalités de langage.
Lorsque vous utilisez cette nouvelle fonctionnalité, est donc il risque de casser le code existant ? La réponse à cette est Oui, il existe certains potentiel de sauts de compatibilité descendante, mais il est limité à quelques scénarios dans lesquels les avantages l'emportent sur la modification avec rupture d'origine et les fonctionnalités existantes peuvent être conservées facilement :
Dim x1() = {1, 2, 3}
Dans les versions précédentes, la ligne de code précédente aurait résulté en un tableau Object, mais avec Visual Studio 2010, ce sera le type déduit du type principal des éléments — dans ce cas, Integer(). Ce sera le cas si vous ciblez 4.0 ou ciblage vers le bas dans une version antérieure. Si vous avez le code qui attend un type spécifique de tableau Object, ce code peut échouer. Elle peut facilement être corrigée en spécifiant explicitement le type de cible :
Dim x1() As Object = {1, 2, 3}
L'exception à ce problème ne : Si aucun type principal pour les éléments :
Dim x1() = {1, 2.2, "test"}
Ceci conservera le comportement antérieur, aboutissant à 1 x est un tableau d'objets.
Application facile
Collection initialiseurs sont un ajout très à la langue. Ils permettent d'une syntaxe plus concise pour afin d'initialiser framework et types de collections définis par l'utilisateur. Avec les modifications minimales, cette syntaxe peut être appliquée au code existant facilement.
La fonctionnalité est idéalement adaptée à pouvoir utiliser d'autres fonctionnalités de langage telles que les méthodes d'extension, l'activation de la réduction de l'utilisation de la syntaxe pour les types de collection. Cette réduction dans le code réutilisable utilisé précédemment rend le code plus petits et plus facile à gérer.
Le comportement d'initialiseur de tableau a changé légèrement, aboutissant à la mise en œuvre inférence de type tableau et des fonctionnalités améliorées, autorisant autonome l'utilisation de tableaux et améliorée permet d'initialiser des tableaux en escalier et multidimensionnels par rapport aux précédentes versions.
Presque chaque application utilise des tableaux ou collections et cette fonctionnalité peuvent être utilisés dans pratiquement n'importe quel projet.
Adrian Spotty Bowles a développé avec chaque version de Visual Basic et a réussi à trouver son moyen de Redmond, Washington, où il travaille sur l'équipe produit Visual Basic comme un testeur d'ingénieur de conception logiciel axé sur le compilateur Visual Basic. Lors de la version Visual Basic 2008, il a travaillé sur bon nombre des fonctionnalités de langage, y compris Methods.You Extension peut atteindre Bowles à Abowles@microsoft.com.