Cours les nouveautés du langage Visual Basic 10, tutoriel & guide de travaux pratiques Visual Basic en pdf.

Les initialiseurs de collection

Présentation

Le langage Visual Basic 9.0 (cf : voir le cours sur ce langage publié sur Dotnet-France) présentait les initialiseurs d’objets, qui permettaient de « simplifier » l’écriture de la création d’objets à partir d’une classe ou d’un type anonyme, en combinant dans la même instruction :
– L’instruction de la création de l’objet.
– L’initialisation de l’état de l’objet (soit l’ensemble des attributs).
Le langage Visual Basic 10 rejoint le langage C# en proposant les initialiseurs de collection. Voici un exemple, montrant commun créer une collection de nombre entiers, via l’utilisation du mot clé From :
// VB
Dim oListeEntiers As New List(Of Integer) From {1, 3, 4, 6, 90, 34}
Voici un autre exemple, montrant comment créer une collection d’objets de type Voiture :
// VB
Dim oListeVoitures As New List(Of Voiture)
From {New Voiture(« 34 YT 54 »), New Voiture(« 17 RE 33 »), New Voiture(« 106 IU 75 ») With {.Marque = « Peugeot »}}
L’exemple ci-dessus, vous montre qu’il est aussi possible d’utiliser l’initialisation d’objets (via l’utilisation du mot clé With), dans une instruction utilisant l’initialisation de collections.
Dotnet France Association – James RAVAILLE

Le typage dynamique

Présentation

Le typage dynamique des objets permet de créer des instructions dynamiques. Ces instructions permettent déclarer des variables locales, des paramètres de méthodes ou des attributs de classe, qui seront typés lors de l’exécution de l’application (on parle dans ce cas de liaisons tardives). Elles peuvent aussi être utilisées comme type de retour de méthodes.
Le typage dynamique exploite une nouvelle fonctionnalité de la CLR, appelée la DLR (Dynamic Language Runtime). Cette fonctionnalité permet d’exécuter dans la CLR des langages dynamiques tels que le langage IronPython (« Python » pour .NET).
Une fois déclarée dynamiquement, il est possible d’utiliser ces membres, sans qu’aucune vérification ne soit effectuée par le compilateur.
Les intérêts des instructions dynamiques sont les suivants :
– Utiliser plus facilement des objets venant de langage de programmation dynamique tels que les langages IronPhyton et IronRuby.
– Faciliter l’accès et l’utilisation d’objets COM.
– Proposer une alternative à la réflexion (mécanismes d’introspection de code MSIL, …).
Toutefois, attention à l’utilisation des instructions dynamiques. Utilisées à mauvais escient, elles rendront les applications moins robustes lors de leur exécution, en provoquant des erreurs uniquement lors de l’exécution (le compilateur ne connaît pas le type des objets manipulés). Dans des cas très précis, elles permettent de simplifier le développement.
Pour mettre en œuvre le typage dynamique, nous utiliserons le mot clé dynamic.

 Exemples

Soit le bloc d’instructions ci-dessous, que nous pouvons exécuter dans une application Windows Forms :
// VB
Dim var1 As Object = « abc »
Dim var2 As String = var1.ToUpper()
MessageBox.Show(var2)
La première instruction permet de déclarer une variable nommée var1, et de la typer (lors de l’exécution) en chaîne de caractères (type string), ce type étant déduit de la valeur d’affectation « abc ».
La seconde instruction permet d’appliquer (dynamiquement) la méthode ToUpper à cette variable, de manière à transformer sa valeur en chaîne de caractères majuscules.
La troisième instruction permet d’afficher dans une boite de message le contenu de la variable VAR1.
Dotnet France Association – James RAVAILLE
Voici un second exemple. Soit les deux classes suivantes :
// VB
Public Class Personne
Public Property Nom As String
Public Property Prenom As String
Public Sub New(ByVal aNom As String, ByVal aPrenom As String)
Me.Nom = aNom
Me.Prenom = aPrenom
End Sub
Public Function Deplacer() As String
Return Me.Nom +  »  » + Me.Prenom +  » est arrivé à destination » End Function
End Class
Public Class Animal
Public Property Nom As String
Public Property Race As String
Public Sub New(ByVal aNom As String, ByVal aRace As String)
Me.Nom = aNom
Me.Race = aRace
End Sub
Public Function Deplacer() As Point
Return New Point(20, 50)
End Function
End Class
Ces deux classes possèdent un accesseur Nom (vous remarquerez l’utilisation des accesseurs simplifiés, cf : cours sur les nouveautés du langage Visual Basic 9.0) en commun, ainsi qu’une méthode nommée Deplacer.
Voici une autre méthode ayant un paramètre défini dynamiquement, appliquant une méthode Deplacer() à cet objet, et affiche les informations retournées par cette méthode :
// VB
Public Sub ChangerPosition(ByVal aObjet As Object)
MessageBox.Show(aObjet.Deplacer().ToString())
End Sub
Le bloc d’instructions crée une instance de la classe Personne, une autre de la classe Animal, et exécute deux fois la méthode ChangerPosition en passant successivement ces objets en paramètre :
// VB
Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button2.Click
Dim oPersonne As New Personne(« RAVAILLE », « James »)
Dim oAnimal As New Animal(« Médor », « Chien »)
Me.ChangerPosition(oPersonne)
Me.ChangerPosition(oAnimal)
End Sub
L’instruction Me.ChangerPosition(oPersonne) affiche le message suivant :
Ces deux exemples mettent en évidence que la méthode Deplacer est bien appliquée dynamiquement à un objet, dont le type de données n’est pas explicitement défini lors de la compilation, mais lors de l’exécution. Elle est appliquée sur un objet, quelque soit son type, tant que cette méthode est définie au sein de la classe ou héritée d’une classe de base. Cependant :
– Il n’est pas possible d’appliquer de cette manière les méthodes d’extension (cf : cours sur les nouveautés du langage Visual Basic 9.0).
– Il n’est pas possible d’utiliser les expressions lambda (cf : cours sur les nouveautés du langage Visual Basic 9.0) comme paramètre des méthodes.
Voici une méthode nommée Embaucher, acceptant un paramètre défini dynamiquement, et affichant le Nom et le Prenom de l’objet passé en paramètre :
// VB
Public Sub Embaucher(ByVal aPersonne As Object) MessageBox.Show(aPersonne.Nom +  »  » + aPersonne.Prenom +  » a été
embauché le  » + DateTime.Now.ToString())
End Sub
Comme nous l’avons vu, il est alors possible d’appeler cette méthode en passant un objet créé à partir de n’importe quelle classe exposant des propriétés Nom et Prenom. Mais cet objet peut aussi avoir été créé à partir d’un type anonyme (cf : cours sur les nouveautés du langage Visual Basic 9.0) :
// VB
Private Sub Button3_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button3.Click
Dim oPersonne As New Personne(« RAVAILLE », « James »)
Dim oPersonne1 = New With {.Nom = « VERGNAULT », .Prenom = « Bertrand »}
Me.Embaucher(oPersonne)
Me.Embaucher(oPersonne1)
End Sub

Saut d’instruction d’implicite

Avec le langage Visual Basic 9, pour déclarer et initialiser une chaîne de caractères en une seule instruction sur plusieurs lignes dans l’éditeur, nous devons utiliser le caractère de saut d’instruction « _ ». Voici un exemple :
// VB
Dim s As String = « Date 1 :  » + DateTime.Now.ToString() + _
 » Date 2 :  » + DateTime.Now.AddDays(1).ToString() + _
 » Date 3 :  » + DateTime.Now.AddMonths(1).ToString()
Le langage Visual Basic 10 permet d’écrire ce bloc d’instruction, sans avoir à utiliser le caractère de saut d’instruction :
// VB
Dim s As String = « Date 1 :  » + DateTime.Now.ToString() +
 » Date 2 :  » + DateTime.Now.AddDays(1).ToString() +
 » Date 3 :  » + DateTime.Now.AddMonths(1).ToString()

Les instructions lambda multi-lignes

Voici un bloc d’instructions permettant d’exécuter de manière asynchrone un traitement sur des chaînes de caractères (valable avec les versions 9 et 10 du langage Visual Basic) :
// VB
Private Sub Button6_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button6.Click
Dim oListeNoms = {« James », « Bertrand », « Julien », « Laurent »}
Dim oThread As New System.Threading.Thread(AddressOf Traiter)
oThread.Start(oListeNoms)
oThread.Join()
End Sub
Private Sub Traiter(ByVal aListeStrings As String())
For Each s As String In aListeStrings
‘ Bloc d’instructions …
Next s
End Sub
Dans le bloc de code ci-dessous, nous sommes dans l’obligation de créer une nouvelle méthode dans notre classe, contenant le code exécuté de manière asynchrone, à savoir Traiter.

1 Introduction
1.1 Présentation
1.2 Pré-requis
2 Les propriétés simplifiées
2.1 Présentation
2.2 Exemple de mise en oeuvre
3 Les initialiseurs de collection
3.1 Présentation
4 Le typage dynamique
4.1 Présentation
4.2 Exemples
5 Saut d’instruction d’implicite
6 Les instructions lambda multi-lignes
7 La co-variance et la contre-variance
7.1 Co-variance et contre-variance sur les délégués
7.1.1 La co-variance et les interfaces génériques
7.1.2 La contre-variance et les interfaces génériques
8 Conclusion

……….