Vous êtes sur la page 1sur 21

Les nouveauts du langage Visual Basic 9.

0
Version 1.3

James RAVAILLE
http://blogs.dotnet-france.com/jamesr

Les nouveauts du langage Visual Basic 9.0

Sommaire

Introduction ..................................................................................................................................... 3 1.1 Prsentation ............................................................................................................................ 3

Les dlgus non stricts .................................................................................................................. 4 2.1 2.2 Prsentation ............................................................................................................................ 4 Mise en uvre......................................................................................................................... 4

Le support du langage XML approfondi .......................................................................................... 6 3.1 3.2 Prsentation ............................................................................................................................ 6 Mise en uvre......................................................................................................................... 6

Les mthodes partielles................................................................................................................... 8 4.1 4.2 Prsentation ............................................................................................................................ 8 Exemple de mise en uvre ..................................................................................................... 9

Les initialiseurs dobjets ................................................................................................................ 10 5.1 5.2 Prsentation .......................................................................................................................... 10 Exemple de mise en uvre ................................................................................................... 10 Les initialiseurs dobjets ................................................................................................ 10

5.2.1 6

Linfrence de type et les types anonymes ................................................................................... 12 6.1 6.2 6.3 Prsentation de linfrence de type ...................................................................................... 12 Prsentation des types anonymes ........................................................................................ 12 Exemple de mise en uvre ................................................................................................... 12

Les mthodes dextension ............................................................................................................. 14 7.1 7.2 Prsentation .......................................................................................................................... 14 Exemple de mise en uvre ................................................................................................... 15

Les expressions lambda ................................................................................................................. 18 8.1 8.2 8.3 Prsentation .......................................................................................................................... 18 Exemple de mise en uvre ................................................................................................... 18 Utilisation des expressions lambda comme paramtre de mthode ................................... 19

Conclusion ..................................................................................................................................... 21

Dotnet France Association James RAVAILLE

Les nouveauts du langage Visual Basic 9.0

1 Introduction
1.1 Prsentation
En Fvrier 2008, Microsoft sort officiellement et pour le grand public, Visual Studio 2008, la version 3.5 du Framework .NET, ainsi quune nouvelle version du langage Visual Basic .NET. Nous vous proposons dans ce cours, de vous prsenter chacune des nouveauts de ce langage, avec pour chacune dentre elles : Une partie thorique afin de vous expliquer en quoi elle consiste, et quel est son but, dans quels cas il est ncessaire/conseill de lutiliser Une partie pratique avec des exemples de mise en uvre.

Ces nouveauts sont les suivantes : Les dlgus non stricts. Le support approfondi du langage XML. Les mthodes partielles. Les initialiseurs dobjets. Linfrence de type. Les types anonymes. Les mthodes dextension. Les expressions lambda.

Dotnet France Association James RAVAILLE

Les nouveauts du langage Visual Basic 9.0

2 Les dlgus non stricts


2.1 Prsentation
Que ce soit dans une application Windows ou Web, nous sommes amens implmenter des vnements sur des objets, pouvant tre des objets mtiers ou des contrles graphiques dun formulaire. Dans le langage Visual Basic 8.0, tout vnement est bas sur un dlgu. Un dlgu peut tre dfini comme un pointeur de mthode. De manire plus prcise, un dlgu est un type de donnes, qui permet de crer des objets qui pointent vers une mthode. Les dveloppeurs Visual Basic 8.0 nont peut tre pas lhabitude dutiliser les dlgus pour dfinir des vnements, puisquil est possible de dfinir un vnement dans une classe, sans avoir utiliser explicitement un dlgu. Alors que dans le langage Visual Basic, on ne peut dfinir un vnement sans utiliser un dlgu. La signature de lvnement est dfinie sur lvnement luimme (contrairement au langage C#, o la signature dun vnement est dfinie au travers du dlgu, utilis pour dfinir lvnement). Lors de la cration dun gestionnaire dvnement, autrement dit une mthode qui sera abonne un vnement, la signature de cette mthode doit respecter la signature du dlgu ayant t utilis pour dfinir lvnement.

2.2 Mise en uvre


Le langage Visual Basic 9.0 introduit la notion de dlgus non stricts , qui permet : De ne pas spcifier les arguments des gestionnaires dvnements, sils ne sont pas utiliss. o La signature dun gestionnaire dvnements classiques, telle quon lcrivait jusquen Visual Basic 8.0 :

' VB .NET Private Sub CmdAction1_Click(ByVal sender As Object, ByVal e As EventArgs) Handles CmdAction1.Click ' ... End Sub

Lvnement Click dfinit dans la classe System.Windows.Forms.Control, classe de base des contrles graphiques pour les applications Windows Forms, est dfini avec un dlgu nomm EventHandler acceptant comme paramtres, un objet lorigine de la leve de lvnement (de type Object), et un argument dvnement (de type EventArgs). o Dans le langage Visual Basic 9.0, on peut alors omettre ces paramtres sils ne sont pas utiliss dans le gestionnaire dvnement :

' VB .NET Private Sub CmdAction2_Click() Handles CmdAction2.Click ' ... End Sub

Dotnet France Association James RAVAILLE

Les nouveauts du langage Visual Basic 9.0

De pouvoir assigner une mme mthode, des vnements dfinis avec des dlgus ayant une signature diffrente. Cest le cas de la mthode Me_MonEvt, qui est abonne aux vnements MontEvt1 et MonEvt2, qui nont pas la mme signature :

' VB .NET Private Event MonEvt1(ByVal aCode As Integer) Private Event MonEvt2(ByVal aCode As Integer, ByVal aMessage As String) Private Sub Me_MonEvt() Handles Me.MonEvt1, Me.MonEvt2 ' ... End Sub

Dotnet France Association James RAVAILLE

Les nouveauts du langage Visual Basic 9.0

3 Le support du langage XML approfondi


3.1 Prsentation
Le langage Visual Basic 9.0 propose un support tendu de lutilisation du langage XML, au travers de deux nouveauts : Les littraux XML, qui permettent dincorporer directement un flux XML dans un bloc de code Visual Basic. Il propose une aide la saisie, et vrifie quil est bien form lors de la compilation (autrement dit, quil respecte les spcifications du langage XML). Le code MSIL Microsoft Intermediate Language) obtenu, gnre un code utilisant les classes de lespace de noms System.Xml.Linq du Framework .NET ( savoir les classes XElement, XAttribute) pour gnrer ce flux XML. Les proprits daxe qui permettent daccder aux donnes contenues dans un flux XML. Cette nouveaut est trs apprcie dans les requtes LINQ For Xml, visant requter un flux XML : o Proprit d'axe d'attribut XML : element.@attribute o Proprit d'axe enfant XML : element.<enfant> o Proprit d'axe descendant XML : element...<descendant> o Proprit d'indexeur d'extension : element(index) o Proprit de valeur XML : element.Value

3.2 Mise en uvre


Voici un exemple de code, permettant dintgrer un flux XML, dans du code Visual Basic. La variable oListeLivres nest pas de string, mais System.Xml.Linq.XElement :
' VB .NET Dim oListeLivres = <livres> <livre titre="Microsoft Office SharePoint Server 2007" prix="25,78"> <auteur>Anthony BIDET</auteur> </livre> <livre titre="C# 2 et ASP.NET 2.0" prix="25,78"> <auteur>Anthony BIDET</auteur> </livre> <livre titre="Windows Server 2008" prix="30,50"> <auteur>Jean-Franois APREA</auteur> </livre> </livres>

Par la suite, il est alors possible de requter les donnes contenues au travers une requte LINQ For Xml. Cest le cas de lexemple ci-dessous, qui construit un nouveau flux de donnes au format XML, partir du flux XML prsent ci-dessus :

Dotnet France Association James RAVAILLE

Les nouveauts du langage Visual Basic 9.0

' VB .NET Dim sLibrairie As String sLibrairie = "Rue de l'Ile" Dim oFluxLibrairie = <librairie> <nom><%= sLibrairie %></nom> <livres> <%= From oLivre In oListeLivres.<livre> _ Select <livre titre=<%= oLivre.@titre %> auteur=<%= oLivre.<auteur>.Value %>></livre> %> </livres> </librairie>

La variable oFluxLibrairie est de type System.Xml.Linq.XElement. Il contient le flux de donnes XML suivant :
<librairie> <nom>Rue de l'Ile</nom> <livres> <livre titre="Microsoft Office SharePoint Server 2007" auteur="Anthony BIDET"></livre> <livre titre="C# 2 et ASP.NET 2.0" auteur="Anthony BIDET"></livre> <livre titre="Windows Server 2008" auteur="Jean-Franois APREA"></livre> </livres> </librairie>

Dotnet France Association James RAVAILLE

Les nouveauts du langage Visual Basic 9.0

4 Les mthodes partielles


4.1 Prsentation
Les mthodes partielles sont obligatoirement contenues dans des classes partielles (nouveauts du langage Visual Basic 8.0), dans le mme projet. Pour rappel, deux classes partielles constituent la mme classe, spares physiquement dans deux fichiers ou plus. Une mthode partielle est une mthode dont : La signature de la mthode est dfinie dans une classe partielle. Limplmentation de la mthode est dfinie dans une autre partie de la classe partielle. Cette implmentation est optionnelle.

Voici les caractristiques des mthodes partielles : Elles sont dfinies avec le mot cl partial. Elles sont obligatoirement prives. Elles ne peuvent tre appeles que dans la classe dans laquelle elles sont dfinies.

Lintrt majeur des classes partielles rside dans les gnrateurs de code, ou bien encore dans des projets qui partagent des assemblies communes :

Gnrateur de code Dveloppeur 1 Dveloppeur 2

ou
Classe partielle VoitureCourse Fichier VoitureCourse1.vb Classe VoitureCourse Classe partielle VoitureCourse Fichier VoitureCourse2.vb

Par exemple, via un gnrateur de code (prenons par exemple LINQ for SQL), on gnre une classe. Cette classe contient des membres pour lesquels il nest pas possible de dfinir une implmentation lors de la gnration. Le gnrateur de code ne gnre alors que la signature de la mthode, et les appels de cette mthode dans la mme classe. Cette implmentation ne peut tre fournie que par le dveloppeur 2. Ce dernier, au lieu de la fournir dans le fichier gnr (ces modifications pourraient tre perdues lors dune prochaine gnration de la classe), va la fournir en dfinissant la mme mthode partielle dans une autre partie de la classe partielle. Dotnet France Association James RAVAILLE

Les nouveauts du langage Visual Basic 9.0

4.2 Exemple de mise en uvre


Voici un exemple de mthodes partielles :
' VB .NET Partial Public Class Voiture Private _NumeroImmatriculation As String Public Property NumeroImmatriculation() As String Get Return Me._NumeroImmatriculation End Get Set(ByVal value As String) Me._NumeroImmatriculation = value End Set End Property Public Sub New(ByVal aNumeroImmatriculation As String) Me.NumeroImmatriculation = aNumeroImmatriculation Me.Demarrer() End Sub Partial Private Sub Demarrer() End Sub End Class

La mthode Demarrer est une mthode partielle. Cette mthode est appele dans le constructeur de la mme classe. Nous avons vu prcdemment, que limplmentation de la mthode partielle dans lautre classe partielle est optionnelle. Si on observe le code Visual Basic .NET rtrocompil de lassembly contenant cette classe avec loutil Reflector (http://www.redgate.com/products/reflector), alors on peut observer que lappel de la mthode Dmarrer, est prsent uniquement si limplmentation est ralise dans une autre partie de la classe partielle. Voici un exemple dimplmentation de la mthode Dmarrer. Cette mthode aussi ne doit pas tre dfinit avec un niveau de visibilit, et doit avoir la mme signature que la mthode prcdemment dfinie :
' VB .NET Private Sub Demarrer() Console.WriteLine("La voiture " + Me.NumeroImmatriculation + " a dmarr") End Sub

Dotnet France Association James RAVAILLE

10

Les nouveauts du langage Visual Basic 9.0

5 Les initialiseurs dobjets


5.1 Prsentation
Le rle des initialiseurs dobjets, est de simplifier lcriture de la cration dobjets partir dune classe ou dun type anonyme, en combinant dans la mme instruction : Linstruction de la cration de lobjet. Linitialisation de ltat de lobjet (soit lensemble des attributs).

La mise en uvre des initialiseurs dobjets est ralise au travers de linstruction With {.attribut = valeur, }.

5.2 Exemple de mise en uvre


5.2.1 Les initialiseurs dobjets Soit la classe Voiture suivante :

' VB .NET Partial Public Class Voiture Private _NumeroImmatriculation As String Private _Marque As String Public Property NumeroImmatriculation() As String Get Return Me._NumeroImmatriculation End Get Set(ByVal value As String) Me._NumeroImmatriculation = value End Set End Property Public Property Marque() As String Get Return Me._Marque End Get Set(ByVal value As String) Me._Marque = value End Set End Property Public Sub New(ByVal aNumeroImmatriculation As String) Me.NumeroImmatriculation = aNumeroImmatriculation Me.Demarrer() End Sub Public Sub New() Me.New(String.Empty) End Sub Partial Private Sub Demarrer() End Sub End Class

Dotnet France Association James RAVAILLE

11

Les nouveauts du langage Visual Basic 9.0 Voici un bloc dinstruction Visual Basic, permettant de crer une instance de cette classe, en utilisant un constructeur dfini dans la classe, et linitialiseur dobjets :
' VB .NET Dim oVoiture As Voiture oVoiture = New Voiture() With {.NumeroImmatriculation = "212 YT 44", .Marque = "Renault"}

Via linitialisation dobjet, il est ainsi possible dans la mme instruction, de crer une instance de la classe VoitureCourse en utilisant lun des deux constructeurs prsents dans la classe, et dinitialiser tous les attributs souhaits. A noter que le constructeur est toujours appel avant linitialisation des attributs.

Dotnet France Association James RAVAILLE

12

Les nouveauts du langage Visual Basic 9.0

6 Linfrence de type et les types anonymes


6.1 Prsentation de linfrence de type
Linfrence de type permet de dclarer une variable locale sans prciser son type. Cependant, cette variable doit obligatoirement tre initialise, afin que le compilateur puisse dterminer son type, partir de la valeur ou lexpression dinitialisation. Une fois la variable dclare, on peut lui appliquer tous les membres, exposs par le type automatiquement dtermin. Je pense que linfrence de type, doit uniquement tre utilise quand il nest pas possible ou trs difficile de dtermin le type de la variable partir de sa valeur dinitialisation. Cette situation peut se produire dans deux cas : Lorsquun type anonyme est utilis dans la valeur dinitialisation. Cest le cas lors de la ralisation de projection de donnes dans les requtes LINQ. Lorsque le type de la valeur dinitialisation est complexe, et donc difficilement dfinissable par tout dveloppeur. Linfrence de type est mise en uvre au travers du mot cl Dim.

6.2 Prsentation des types anonymes


Le langage Visual Basic 8.0 introduisait les mthodes anonymes. Le langage Visual Basic 9.0 introduit les types anonymes. Il ny a pas de relation directe entre ces deux notions. Les types anonymes permettent de crer des objets et des collections dobjets, sans avoir dfinir explicitement dans lapplication, la classe utilise pour crer les objets. Cest le compilateur qui se charge de gnrer dynamiquement la classe, lors de la compilation du code. Lutilisation de cette nouveaut entraine lutilisation implicite de linitialisation dobjets et de collections, ainsi que de linfrence de types. On retrouve lutilisation de toutes ces nouveauts dans lcriture de requtes LINQ. Les types anonymes correspondent uniquement des structures de donnes en mmoire. Ils ne peuvent contenir des mthodes, applicables aux objets quils permettent de crer. Comme toutes classes, les types anonymes drivent de la classe System.Object. Les seules mthodes alors applicables ces objets sont ceux hrits de cette mme classe. La mise en uvre des types anonymes est ralise au travers de la syntaxe suivante : New With { proprit = valeur , }.

6.3 Exemple de mise en uvre


Voici un exemple de code, permettant de crer un objet nomm oVoiture partir dun type anonyme. La structure de cet objet est dtermine par les attributs qui sont dfinis et valoriss entre accolades. Cet exemple met en vidence un exemple dutilisation des initialiseurs dobjets :

Dotnet France Association James RAVAILLE

13

Les nouveauts du langage Visual Basic 9.0

' VB .NET Dim oVoiture = New With {.Marque = "Renault", .NumeroImmatriculation = "212 YT 44", .Couleur = Color.Black}

Il est alors possible de crer des objets, contenant uniquement des donnes, sans avoir implmenter dans le code la classe permettant de les crer. On remarque lutilisation de linfrence de type avec le mot cl Dim.

Voici un autre exemple, qui montre lutilisation de linfrence de type, dun type anonyme et linitialisation dobjets. La requte LINQ permet dobtenir une collection dobjets, o chacun contient une marque de voiture et un numro de dpartement, partir dune collection de voitures. Seules les voitures immatricules dans les dpartements 44 et 35, doivent tre slectionnes :
' VB .NET Dim oListeNomsPrenomsEmployesActifs = (From oEmploye In oListeEmployes _ Where (oEmploye.Actif) _ Select New With {.NomPrenom = oEmploye.Nom + " " + _ oEmploye.Prenom}).ToList()

Dotnet France Association James RAVAILLE

14

Les nouveauts du langage Visual Basic 9.0

7 Les mthodes dextension


7.1 Prsentation
Les mthodes dextension permettent dtendre une classe, en ajoutant de nouvelles mthodes, sans crer de classe drive de cette mme classe. Elles sont utiles dans les cas suivants : Soit une interface IVehicule, qui dfinit les membres de toutes classes permettant de crer des objets, qui se considrent comme tant des vhicules. Soit les classes Voiture, Camion, Velo, Moto, qui implmentent cette interface.

Alors si on tend linterface IVehicule par une mthode dextension, alors cette mthode dextension est applicable toutes les instances, cres partir des classes implmentant cette interface.

Vous dveloppez une application, qui utilise des classes contenues dans un assembly qui vous a t fourni. Vous ne possdez pas les sources de cet assembly. Vous savez quil contient une classe Animal, qui possde des classes drives. Vous souhaitez alors ajouter des membres supplmentaires cette classe, afin denrichir les classes drives. Comme vous ne possdez pas les sources de lassembly, vous ne pouvez le faire autrement quen crant des mthodes dextension, qui tendent la classe Animal.

En Visual Basic 9.0, une mthode dextension est une mthode, contenue dans un module de code. Cependant, cette mthode sera utilise comme toute autre mthode dinstance de la classe tendue. La signature de cette mthode est particulire : Elle doit tre dfinie avec System.Runtime.CompilerServices.Extension(). lattribut de mthode

Dotnet France Association James RAVAILLE

15

Les nouveauts du langage Visual Basic 9.0 Le type du premier paramtre reprsente le type tendu. Une mthode dextension peut possder des paramtres dentre, qui sont alors ajouts la suite de ce premier paramtre.

7.2 Exemple de mise en uvre


Voici une mthode dextension permettant dtendre le type System.Int32 du Framework .NET :
' VB .NET Public Module IntExtension <System.Runtime.CompilerServices.Extension()> _ Public Function MultiplierParDeux(ByVal aNombre As Integer) As String Return aNombre.ToString() + " * 2 = " + (aNombre * 2).ToString() End Function End Module

Elle permet de multiplier par deux le contenu de toute variable de type System.Int32. Voici un exemple :
' VB .NET Dim i As Integer = 10 Console.WriteLine(i.MultiplierParDeux()) => Affiche 10 * 2 = 20

Un autre exemple : toutes les classes reprsentant un dictionnaire de donnes, dit gnrique implmente linterface IDictionary(Of TKey, TValue) du Framework .NET. Alors voici une mthode permettant dtendre toute collection de donnes, implmentant cette interface, de manire pouvoir accder la valeur dun lment partir de sa cl, ou obtenir une valeur par dfaut, si aucun lment de la collection nest identifi avec la cl :

Dotnet France Association James RAVAILLE

16

Les nouveauts du langage Visual Basic 9.0

' VB .NET Public Module IDictionnaryExtension <System.Runtime.CompilerServices.Extension()> _ Public Function GetValue(Of TKey, TValue)( _ ByVal aListe As IDictionary(Of TKey, TValue), _ ByVal key As TKey, ByVal defaultValue As TValue) As TValue Dim aValeurRetour As TValue If (aListe.ContainsKey(key)) Then aValeurRetour = aListe(key) Else aValeurRetour = defaultValue End If Return aValeurRetour End Function End Module

Et voici un exemple dutilisation de la mthode dextension, avec la classe gnrique IDictionary(Of TKey, TValue), qui implmente linterface gnrique IDictionary(Of TKey, TValue) :
' VB .NET Dim oListeFormations As New Dictionary(Of Integer, String) oListeFormations.Add(1, "Formation VB .NET") oListeFormations.Add(2, "Formation ASP .NET") oListeFormations.Add(3, "Atelier Accs aux donnes") oListeFormations.Add(4, "La scurit dans les applications .NET") Dim sFormation As String sFormation = oListeFormations.GetValue(4, "formation inexistante") Console.WriteLine(sFormation)

Le corps des mthodes dextension peut tre paramtrables , personnalisables , au travers de lutilisation dexpressions lambda.

7.3 Rgles particulires


Soit le diagramme de classes suivant :

Dotnet France Association James RAVAILLE

17

Les nouveauts du langage Visual Basic 9.0 Voici quelques rgles observer lors de lutilisation de mthodes dextension : Si les classes IVehiculeExtension et ITransporteurExtension possdent une mthode dextension de mme nom et avec une signature analogue , alors une erreur survient lors de la compilation, lorsque cette mthode est applique une instance de la classe Vehicule. Si la classe Vehicule contient une mthode, et que la classe IVehiculeExtension et/ou ITransporteurExtension propose une mthode dextension de mme nom et avec une signature analogue , alors lapplication compile et la mthode de la classe Vehicule masque les mthodes dextension.

Dotnet France Association James RAVAILLE

18

Les nouveauts du langage Visual Basic 9.0

8 Les expressions lambda


8.1 Prsentation
Une expression lambda est une fonction ne possdant pas de nom, et excutant un traitement retournant une valeur. Une expression lambda est compose de deux parties : Une liste de paramtres, dclare avec le mot cl Function. Une expression Dans quels cas peut-on utiliser les expressions lambda : Pour raliser des fonctions de calcul. Largement utilises dans les mthodes dextension de linterface IEnumerable(Of T).

8.2 Exemple de mise en uvre


Par exemple, vous manipulez une liste dentiers, cres avec le bloc dinstructions cidessous :
' VB .NET Dim oListeNombres As New List(Of Integer) Dim oListeNombrePaires As New List(Of Integer) oListeNombres.Add(1) oListeNombres.Add(34) oListeNombres.Add(3) oListeNombres.Add(9) oListeNombres.Add(12) oListeNombres.Add(18)

Et dans cette liste, vous souhaitez uniquement slectionner les nombres pairs. Avec le langage Visual Basic 8.0, on crira le bloc de code suivant :
' VB .NET oListeNombrePaires = New List(Of Integer)() For Each i As Integer In oListeNombres If (i Mod 2 = 0) Then oListeNombrePaires.Add(i) End If Next

Avec le langage Visual Basic 9.0, en utilisant la mthode dextension Where de linterface gnrique IEnumerable(Of T), on crirait le bloc de code suivant :

Dotnet France Association James RAVAILLE

19

Les nouveauts du langage Visual Basic 9.0

' VB .NET oListeNombrePaires = oListeNombres.Where(Function(i) i Mod 2 = 0).ToList()

Le bloc de code Visual Basic ci-dessus utilise la mthode dextension Where, tendant linterface gnrique IEnumarable(Of T) du Framework .NET. Cette mthode permet de filtrer la collection dentiers, en fonction dune expression boolenne. Cette expression boolenne est dfinie via lexpression lambda Function(i) i Mod 2 = 0, qui signifie pour tous les nombres i de la collection pour lesquels le rsultat du modulo par deux vaut 0 .

8.3 Utilisation des expressions lambda comme paramtre de mthode


Dans une mthode classique ou une mthode dextension, il est possible de paramtrer , personnaliser le comportement de la mthode, en utilisant une expression lambda. Voici une mthode dextension, permettant de parcourir une liste dentiers laquelle elle est applique, afin de les traiter. Le traitement de ces entiers nest pas dtermin dans la mthode dextension elle-mme, mais par le code utilisant cette mthode dextension :
' VB .NET <System.Runtime.CompilerServices.Extension()> _ Public Sub TraiterElements(ByVal aListe As List(Of Integer), ByVal aExpression As Func(Of Integer, Integer)) For i As Integer = 0 To aListe.Count Step 1 aListe(i) = aExpression(i) Next End Sub

Pour dfinir une expression lambda, il suffit dutiliser le mot cl Func permettant de dfinir des types de donnes (une volution des dlgus). Dans lexemple prcdent, Func(Of Integer , integer) dcrit une expression de traitement acceptant une donne de type Integer en paramtre (le premier type prcis), effectuant un traitement avec ou sur ce paramtre, et retournant une donne de type Integer (second type de donne dfini).

Enfin, voici deux blocs de code utilisant la mthode TraiterElements sur une collection dentiers, afin de multiplier par 2 chacun des nombres de la collection :

Dotnet France Association James RAVAILLE

20

Les nouveauts du langage Visual Basic 9.0

' VB .NET ' Premier exemple. Dim oExpressionTraitement As Func(Of Integer, Integer) = Function(i) i*2 oListeNombres.TraiterElements(oExpressionTraitement) ' Second exemple. oListeNombres.TraiterElements(Function(i) i*2)

Dotnet France Association James RAVAILLE

21

Les nouveauts du langage Visual Basic 9.0

9 Conclusion
Ce chapitre vous a prsent les nouveauts du langage Visual Basic 9.0. Ces nouveauts ont t ncessaires, afin de permettre dcrire des requtes LINQ (sur une grappe dobjets, sur une base de donnes SQL Server, ou sur un flux XML), et lutilisation de composants daccs aux donnes tels que Classes LINQ For SQL. Voici un exemple, qui rcapitule et combine de nombreuses nouveauts du langage Visual Basic 9.0, au travers dune requte LINQ : crire une requte LINQ, permettant de slectionner la liste des fichiers dextension txt dun rpertoire, dont la taille est strictement suprieure 10 Ko. En sortie, on doit obtenir uniquement le nom et la taille des fichiers en octets, dans lordre alphabtique invers sur le nom :
' VB .NET Dim oDirInfo As New DirectoryInfo(Application.StartupPath) Dim oListeFichiers = oDirInfo.GetFiles("*.txt") _ .Where(Function(oFichier) oFichier.Length > 10 * 1024) _ .OrderByDescending(Function(oFichier) oFichier.Name) _ .Select(Function(oFichier) New With {oFichier.Name, .Taille = oFichier.Length}) For Each oFichier In oListeFichiers Console.WriteLine(oFichier.Name + ":" + oFichier.Taille.ToString()) Next

La requte LINQ prsente dans le bloc de code ci-dessus, utilise pleinement les nouveauts du langage Visual Basic 9.0 que nous avons tudies dans ce support : Infrence de type : lie lutilisation du type anonyme, et marque par lutilisation du mot cl var. Mthodes dextension : marques par lutilisation des mthodes dextension Where, OrderByDescending, et Select de linterface gnrique IEnumerable(Of T) du Framework .NET. Type anonyme : marque par lutilisation du mot cl new, et la projection de donnes effectue en ne slectionnant que le nom et la taille du fichier en octets. Expressions lambda : utilises dans les trois mthodes dextension. Autrement dit, pour filtrer, trier les fichiers, et raliser une projection de donnes sur les informations des fichiers. Initialisation dobjet : utilise au sein du type anonyme.

Dotnet France Association James RAVAILLE