Introduction à VB 2005 – VS 2005 … Mais encore

Introduction à VB
2005 – VS 2005 …
Mais encore ?!
1) Introduction à VB 2005 ..................................................................................................... 3
2) Les applications que vous pouvez construire .................................................................... 5
2.1) Applications Consoles ................................................................................................ 5
2.2) Applications Windows Smart Client .......................................................................... 6
2.3) Librairies de classes.................................................................................................... 6
2.4) Applications Web ....................................................................................................... 7
2.5) Web Services .............................................................................................................. 7
2.6) Windows Services ...................................................................................................... 8
2.7) Application Smart Device .......................................................................................... 8
2.8) Projets de setup et de déploiement ............................................................................. 8
3) VS 2005 : Un environnement de développement unifié.................................................... 9
4) Mais qu’est-ce que le .NET Framework ?....................................................................... 10
5) Quelques nouveautés du langage VB 2005 ..................................................................... 13
5.1) Générics .................................................................................................................... 14
5.2) Classes partielles....................................................................................................... 21
5.3) Types Nullables ........................................................................................................ 22
5.4) My............................................................................................................................. 22
5.5) Surcharge des Opérateurs ......................................................................................... 23
5.6) Mots clés IsNot & Using .......................................................................................... 24
5.7) Types Integer non signés .......................................................................................... 24
5.8) L’état Continue ......................................................................................................... 24
6) Nouveautés de VS 2005 .................................................................................................. 25
6.1) Nouveautés dans l’IDE............................................................................................. 26
6.2) Nouveautés dans l’édition de votre code.................................................................. 30
6.3) Nouveautés dans le debugger de Visual Studio 2005............................................... 36
1) Introduction à VB 2005
Le langage de programmation Visual Basic est historiquement dans les gênes de la société
Microsoft. Avec plus de 50.000 développeurs en France l’utilisant au quotidien, Visual Basic
reste un langage de programmation incontournable malgré les quelques erreurs de
communications de Microsoft à son sujet.
L’évolution des MFC (Microsoft Fundation Classes) et de VB 6.0 vers la première version du
.NET Framework sous entendu le CLR (Common Language Runtime) et VB.NET 1.0 à
partir de juin 2000 ouvrit de nouvelles perspectives pour tous types de développement.
La sortie en Mars 2003 de la version 1.1 du .NET Framework apporte de nouvelles
fonctionnalités au travers du nombre de classes ajoutées à la version 1.0 du .NET
Framework. Mais cette seconde version ne se limite pas à ceci, elle nous pousse à conclure
sur une pérennité de nos développements au travers de l’investissement et de la continuité
effectués par Microsoft sur cette technologie.
La sortie du .NET Framework 2.0 et du langage VB 2005 (notez la disparition de la
terminologie .NET) en novembre 2005 clôture toute polémique et conforte tout choix de
migration et d’évolution des équipes de développements de technologies plus anciennes (VB
6.0, VB.NET 1.0, 1.1) vers le .NET Framework 2.0. Vous ne pourrez qu’apprécier les
avancées en terme de productivité, sécurité de vos applications tant WebForm que
WinForm, l’intégrité de vos application, l’interopérabilité et déploiement de celles-ci.
Oubliez les idées reçues :
« VB.NET est mort, vive C# »
NON
« .NET et la programmation objet n’a pas de valeur ajoutée, et c’est compliqué »
NON
Faites-vous votre propre expérience et jugement ! Découvrez une plateforme et un
environnement de développement puissant, intuitif, performant. Ouvrez Visual Studio 2005
ou une version Express !
Fig 1 : « Visual Basic 2005 – Express Edition »
2) Les applications que vous pouvez construire
Le lancement officiel par Microsoft de Visual Studio 2005, du .NET Framework 2.0 et de ce
fait de Visual Basic 2005 s’est déroulé en novembre 2005. Microsoft met les bouchées
doubles afin de médiatiser, crédibiliser et professionnaliser sa gamme de produits de
développement. Le .NET Framework et les services web XML ont été le cheval de bataille
des campagnes marketing. Mais ces éléments ne sont pas une finalité en soi, Visual Basic
2005 et le .NET Framework vous permettent de développer bien d’autres types
d’applications : « Applications Consoles, Windows, Smart Device, Web, Web Services,
librairies, … ».
2.1) Applications Consoles
Les applications consoles ou plus fréquemment appelées « applications en lignes de
commande » restent des applications incontournables et d’une puissance parfois mal
considérée. Ce type d’application est plus généralement utilisé dans le cadre de gestions de
données en entrée et en sortie sans nécessité de passer par une Interface Utilisateur.
Fig 2 : « Nouveau projets type WinForm – Visual Basic Express Edition »
2.2) Applications Windows Smart Client
Ces applications sont celles se rapprochant le plus des applications Windows développables
en VB 6.0. Dans l’environnement .NET, ces applications sont couramment appelées des
applications « WinForm » en opposition avec les applications web « WebForm » !
L’application WinForm « Smart Client » est ainsi un compromis de la capacité d’exploiter la
puissance du processeur (capacité de calcul) de la machine cliente, des interfaces utilisateurs
riches et de la facilité de connectivité et de déploiement généralement associées aux
WebForms.
Ainsi l’application « Smart Client » est conventionnellement une application WinForm
contenant les améliorations suivantes :
• Consommation de web service
• Support du mode offline
• Déploiement depuis un serveur centralisé
• Distribution automatique de mises à jour
• Support de multi-devices
L’intérêt des applications « smart client » est ainsi fortement ressenti dans les applications
sujettes à exploiter la puissance du processeur client tout en exploitant le meilleur des
applications Web.
2.3) Librairies de classes
La capitalisation, factorisation, protection et réutilisation du code sont des facteurs essentiels
de tout développeur professionnel. Dans ce cadre, les librairies de classes appelées également
« Frameworks » ou « Assembly » permettent d’encapsuler tout code potentiellement
réutilisable sous forme de fichiers « *.dll ».
Cette opération est proche de la création d’un projet COM DLL pour tout développeur VB
6.0 hormis le fait que le fichier « *.dll » créé par Visual Studio 2005 n’est pas un composant
COM !
Les librairies de classes ou assemblies contiennent du code managé (basé sur le .NET
Framework). Celles-ci contiendront tout type de classes (ex : règles métiers, entités, …),
contrôles, composants, classes d’extension du FCL (Framework Class Librairy, le .NET
Framework).
2.4) Applications Web
Les applications web, un premier fer de lance du .NET Framework, ont popularisé cette
technologie. Mieux connu sous la dénomination de « ASP.NET », ce type d’application a
rapidement supplanté les applications développées en ASP 3.0 en apportant un modèle riche
d’objets au travers d’une puissance (passage d’un modèle interprété des pages ASP vers un
modèle compilé) et d’une scalabilité accrues.
Fig 3 : « Nouveau projets type WebForm – Visual Web Developer Express Edition »
2.5) Web Services
Les Web Services, second fer de lance au service du lancement et de la promotion du .NET
Framework, peuvent être considérés comme un sous ensemble des applications web
« ASP.NET ». Les web services sont basés sur SOAP (Simple Object Access Protocol) et
XML (Extensible Markup Language) définis par la syntaxe et les règles d’échanges entre
deux systèmes. Les messages SOAP se véhiculent de la même manière qu’une page web au
travers des protocoles http.
2.6) Windows Services
Les applications « Windows Services » ou entendez les services Windows sont des
applications tournant en tâches de fond pour des raisons de performance ou de distribution de
services au profit d’autres programmes. Un service Windows se démarre en générale
automatiquement et peut fonctionner alors qu’aucun utilisateur n’est connecté sur la machine.
Très utile et utilisé dans le cadre d’applications installées sur des serveurs de production. Ex :
gestion de synchronisation de serveur, rapatriement automatique de documents, … La
création de ce type d’application avec le .NET Framework est relativement aisée et peut se
faire à partir de n’importe quel langage dit .NET-Compliant.
2.7) Application Smart Device
L’ensemble des applications passées en revue tournent sur le .NET Framework. Vous pouvez
également développer des application sur le .NET Compact Framework (sous ensemble du
.NET Framework) orienté vers des supports à faibles ressources (processeur, ram, écrans)
comme les Pocket PC, SmartPhones, … Visual Studio 2005 embarque un émulateur vous
permettant de tester les fonctionnalités et le développement sur de telle plateforme.
2.8) Projets de setup et de déploiement
Vous pouvez également créer des projets de déploiement de vos projets développez via
Visual Basic 2005 ou tout autre projet .NET-Compliant. La facilité de création déconcertera
plus d’un développeur sur une technologie plus ancienne telle que Visual Basic 6.0. Visual
Studio 2005 vous permettra de créer 6 types de projets de déploiement différents permettant
autant des déploiements dits de type lourd ou de type léger. Vous rencontrerez ainsi deux
méthodes phares telles que le déploiement par MSI (Microsoft Installer) ou le déploiement
par ClickOnce qui fera l’objet d’un traitement particulier dans ces tutoriaux.
3) VS 2005 : Un environnement de développement unifié
L’apparition de Visual Studio .NET introduisit une nouvelle génération d’environnement
unifié ! Entendez par « environnement unifié » un environnement vous permettant de créer
différents types d’applications (comme celles mentionnées dans le point 2 de ce document).
Visual Studio 2005 offre quant à lui de nombreuses nouvelle fonctionnalités que vous aurez
l’occasion de parcourir un peu plus loin dans ce tutorial.
Fig 4 : « Structuration de la gamme de produits Visual Studio 2005 »
Visual Studio 2005 est disponible dans les éditions suivantes :
•
•
•
Visual
Studio
2005
Team
System
Gamme d'outils productifs, intégrés et extensibles de gestion du cycle de vie d'un
projet permettant aux équipes de développement de logiciels d'améliorer leur
communication et leur collaboration pendant tout le processus de développement.
Visual
Studio
2005
Professional
Editions
&
Office
System
Outil professionnel destinés aux développeurs individuels ou aux membres de petites
équipes créant des applications windows, Web, mobiles ou basées sur Microsoft
Office.
Visual
Studio
2005
Standard
and
Express
Editions
Outils de développement simples d'utilisation et faciles à prendre en main pour les
développeurs débutants, amateurs et étudiants qui souhaitent créer des applications
pour Windows et Internet.
Vous trouverez un comparatif des fonctionnalités des différentes versions de Visual Studio
.NET à l’adresse suivante :
http://www.microsoft.com/france/msdn/vstudio/vs2005/comparaison/default.mspx
4) Mais qu’est-ce que le .NET Framework ?
L’architecture .NET peut être définie de la façon suivante :
Il s’agit d’un ensemble de Services communs, utilisables depuis plusieurs langages objet. Ces
Services s’exécutent sous la forme d’un code intermédiaire indépendant de l’architecture
sous-jacente. Ces Services s’exécutent dans un « runtime » (CLR – Common Language
Runtime) assurant les fonctions de gestion des ressources et de surveillance du bon
fonctionnement des applications.
A la lecture de cette rapide description, on ne peut s’empêcher de faire un parallèle avec Java.
Effectivement, Microsoft ne se cache pas d’avoir puisé de façon tout à fait pragmatique ses
inspirations dans technologies existantes, et en particulier dans le monde Java.
Le but premier de .NET est de fournir aux développeurs les moyens de créer des applications
interopérables utilisant des "Web Services" depuis tout type de terminal : PC, assistant
personnel, téléphone mobile.
Fig 5 : L’architecture générale du .NET Framework
Avec la plateforme .NET, Microsoft fournit plusieurs langages ainsi que les compilateurs
associés, tels que VB 2005, C# 2.0, ..
D’autres éditeurs, soucieux de profiter de la vague .NET, écrivent des compilateurs pour
d’autres langages non supportés par les équipes de Redmond. Nous y retrouverons des
langages aussi divers et insolites que Cobol, Eiffel, Python.
Tous ces langages sont compilés sous la forme d’un langage intermédiaire (Initialement
appelé MSIL, rebaptisé IL pour Intermediate Language), indépendant du matériel et du
système d’exploitation.
Ce langage « IL » : Microsoft Intermediate Language est ensuite exécuté dans un Runtime, la
« CLR » (Common Language Runtime) qui remplit sensiblement le même rôle que la JVM
dans la plateforme Java.
Fig 6 : Briques logiques de la BCL (Base Class Library)
L’IL est alors traduit en code machine par un compilateur "Juste à temps" (JiT compiler).
Les applications compilées sous la forme de code intermédiaire se présentent sous la forme de
binaires exécutables portables (Portable Exécutable : DLL, EXE).
Pour qu’un langage soit éligible au rang de langage supporté par la plateforme .NET dit
« .NET-Compliant », il faut qu’il puisse fournir un ensemble de fonctionnalités qui sont
recensées dans un contrat de service « CLS » - Common Language Specification (cfr Fig 5).
Pour ajouter un langage à .NET, il suffira donc a priori de faire en sorte qu’il corresponde aux
exigences de la CLS ainsi que développer un compilateur pour ce langage vers le langage IL.
Ceci semble relativement anodin, mais sachez que les contraintes imposées par le respect de
la CLS aux différents langages de .NET font en sorte que Visual Basic .NET, par exemple,
est finalement un nouveau langage à part entière qui ne conserve de Visual Basic 6.0 que son
approche syntaxique.
Une autre conséquence directe du fait que les langages utilisés dans le .NET soient compilés
sous la forme de code intermédiaire est qu’une classe écrite dans un langage pourra aisément
être dérivée dans un autre langage, et de ce fait, nous pourrons instancier dans un autre
langage un objet d’une classe écrite dans un autre langage, de par le passage par le langage
IL.
Ainsi, via .NET, tous les langages offriront les mêmes possibilités et fourniront sensiblement
les mêmes performances, le choix entre VB.NET et C# ne dépendra plus que de vos goûts et
habitudes de programmation, et ne sera plus imposé par des contraintes d’implémentation.
« Que du Bonheur !!! » me direz-vous.
Comment tout ceci est donc possible ? Afin de mieux comprendre l’aspect multi-langage de
.NET, je spécifierais qu’en définitive le .NET ne supporte qu’un seul langage : le langage «
IL ».
En revanche, Microsoft vous propose pour votre confort, d’écrire ce code IL avec n’importe
quel langage normé Visual Basic, ou C++, Cobol ou Eiffel...
Cet ensemble hiérarchique de classes fournit l’ensemble des services et API nécessaires au
développement d’applications. Grâce aux possibilités d’introspection proposées par l’API de
« reflection » (System.Reflection), le code est auto documenté, ce qui fournit au développeur
une documentation non négligeable à l’inverse de Javadoc.
Fig 7 : « Hiérarchie de classes du .NET Framework en version 1.1 »
5) Quelques nouveautés du langage VB 2005
Le .NET Framework 2.0 apporte de sérieuses nouveautés dans ses différents langages. Le
mot d’ordre semble orienté vers une réduction de plus de 50% du code à générer !
A la première lecture, une classification sommaire nous permet de dégager les axes
d’innovation suivants :
• Innovation des langages
• Perfectionnements des compilateurs
• Perfectionnements de la productivité
• Perfectionnements du débuggeur
Comme vous pourrez le constater, les nouveautés et innovations des langages deviennent
difficilement dissociables de l’IDE Visual Studio 2005. Vous pourrez même, en faisant
abstraction de l’approche purement puriste, constater que les nouveautés majeures reposent
soit sur les combinaisons des langages et de leur cadre de développement respectif, soit les
différentes versions du VS.NET.
Bien qu’innovants, force est de reconnaître que des langages comme C# et VB.NET tendent à
s'uniformiser et à devenir tellement semblables en terme de réalisations pragmatiques
réalisables qu’il devient difficile de tirer des arguments purement techniques sur le choix
décisif de l’un ou l’autre. Ceci, fis de l'approche psycho métaphysique de tout puriste.
Dans la suite de ce tutoriel, vous aborderez les Générics, les classes partielles, les méthodes
anonymes, les itérateurs, les qualifications d'alias et des classes statiques, ... Les explications
se voudront relativement simples en vue de permettre une compréhension rapide de ces
avancées.
5.1) Générics
Présenté comme étant une des caractéristiques prépondérantes, soutenue par Bill Gates, du
.NET Framework 2.0 et initialement du langage C#, les Générics apportent la capacité de
réutilisation générique des algorithmes de langages .NET-Compliant.
Mieux connus en C++ sous le nom de Template, l’absence des Générics sous VB.NET ou C#
fut un reproche des utilisateurs auprès de Microsoft. Malgré que les Générics n’implémentent
pas encore la totalité des fonctionnalités des Templates C++, ceux-ci vous seront d’une
précieuse aide. Consultez l’article suivant pour la liste complète des différences entre les
Templates C++ et les Générics en .NET 2.0 : http://msdn2.microsoft.com/enus/library/c6cyy67b.aspx
Mais qu’est-ce qu’un « Générics » ? Selon une définition purement scientifique les Générics
ou « Parametric polymorphism » entendez Polymorphismes paramétriques font allusion aux
classes et aux méthodes qui travaillent uniformément sur des valeurs de types différents.
En bon français, cela pourrait donner la généralisation ou la réutilisation de collections,
classes et/ou méthodes sans se soucier des problématiques de typage (Type-Safe, dont le type
est sûr) ce celles-ci ou de leurs paramètres (transtypage engendrant les problématiques de
« Boxing – UnBoxing » et ainsi de test au debuging, performances, maintenance, …).
L’idée d’implémenter les générics dans la CLI puis dans la CLR fut proposée en 1999 par
Don Syme et Andrew Kennedy (http://research.microsoft.com/projects/clrgen). Les générics
ont été officiellement annoncés en 2002.
L’objectif principal des Générics, comme vous l’aurez compris, est multiple :
• Minimisation de votre code
• Approche générique de votre code
• Sécurisation de votre code lors de la compilation
Types Génériques
Observez le code suivant permettant d’introduire la gestion d’une classe de type collection :
Public Class myCollection
Public Sub Add(ByVal myKey As String, ByVal myElement As Object)
' ...
End Sub
End Class
Celle classe vous permettra ainsi de stocker des éléments de n’importe quel type, la première
problématique apparaît rapidement ! Pour traiter ces éléments de type sans rapport
spécifiques, vous êtes dans l’obligation de devoir les traiter en tant que type System.Object.
Deux problématiques viennent s’ajouter :
1. Supposons que vous ne souhaitiez que stocker des types « Entiers » dans votre liste,
vous pourrez certes utiliser cette classe, cependant que se passera-t-il si vous stocker
accidentellement un type « non-Entier » ?
2. Quid des problématiques de transtypage du type « Object » vers le type « Entier » et
des performances associées à ce transtypage.
La création d’une classe de type collection fortement typée sur un type « Entier » comme
présenté dans le code ci-dessous permettrait de contourner des deux problématiques.
Public Class myCollection
Public Sub Add(ByVal myKey As String, ByVal myInteger As Integer)
' ...
End Sub
End Class
Mais que se passe-t-il maintenant si vous souhaitez stocker non plus de entiers mais des types
dates ou boolean ou vos types personnels ? Vous devrez ainsi pour chaque type vous créer
une collection fortement typée… pas très productif même si vous passez par une approche
basée sur l’utilisation du type System.Object !
Ainsi les collections génériques vous apportent une aide non négligeable afin de résoudre ses
problématiques de duplication de code, de perte de performances ou encore d’utilisation de
collections fortement typées.
Observez les exemples de code ci-dessous :
Public Class myCollection(Of ElementType)
'Le second paramètre est défini et utilisé en qualité de générics
Public Sub add(ByVal myKey As String, ByVal myElementType As ElementType)
' ... code
End Sub
End Class
Public Class myCollection(Of KeyType, ElementType)
'Les deux paramètres sont définis et utilisés en qualité de générics
Public Sub Add(ByVal myKey As KeyType, ByVal myElement As ElementType)
' ... code
End Sub
End Class
Public Class usedGemerics
Sub myFirstUse()
Dim myIntegerCollection As New myCollection(Of Integer)
myIntegerCollection.add("myFirst", 1)
Dim myDateIntegerCollection As New myCollection(Of Date, Integer)
myDateIntegerCollection.Add(CDate("2005-12-27"), 123)
End Sub
End Class
Le premier exemple « Dim myIntegerCollection As New myCollection(Of Integer) » définit ainsi
une collection fortement typée n’acceptant que des types Entiers qui seront directement
affectés dans le second attribut de la méthode « Add ». Vous remarquerez que cette approche
fonctionne également pour tout autre paramètre devant être fortement typé.
Note : Vous remarquerez dors et déjà la capacité de surcharger les classes selon leur
déclaration
de
type.
A
même
titre
que
leurs
méthodes.
L’utilisation de cette approche est également fonctionnelle dans le cas de structures,
d’interfaces ou de délegates devant être génériques.
Observez le résultat obtenu lors de la compilation du code suivant :
Dim myIntegerCollection As New myCollection(Of Integer)
'Ajout valide, second paramètre de type Integer
myIntegerCollection.add("myFirst", 1)
'Ajout non valide, second paramètre de type string
myIntegerCollection.add("myFirst", "reBonjour")
Vous constaterez effectivement que lors de l’implémentation du type ElementType par la
compilation Just-in-Time, le langage IL se charge de valider le type « Entier » de l’élément
passé et ainsi éviter toute conversion vers un type System.Object.
Méthodes Génériques
A même titre que les collections, vous pourriez avoir le souhait d’utiliser des méthodes
exploitant des types différents. Les problématiques ainsi rencontrées ne feraient que se
répéter. L’exemple de la méthode « Sort » présenté ci-dessous peut en être un bon exemple !
Public Sub Sort(ByVal Arr() As Object)
' ... code
End Sub
Ces problématiques peuvent, comme vous devez déjà le concevoir, se résoudre au travers de
la construction d’une méthode générique « Sort » comme présentée ci-dessous.
Public Sub Sort(Of myType)(ByVal Arr() As myType)
' ... code
End Sub
Vous le constatez, la méthode générique « Sort » est ainsi fortement typée avant toute
exploitation d’un de paramètres traditionnels.
Vous pouvez maintenant invoquer la méthode générique « Sort » en lui passant un argument
« Type » pur myType et un argument traditionnel.
Dim myIntArray() As Integer = {2, 3, 4, 5}
Sort(Of Integer)(myIntArray)
La réelle contrainte restante dans ce code étant que le type « myType » que vous invoquerez
devra être iComparable afin de passer par une méthode type « Sort » contenant
vraisemblablement un passage par … myItem(i).CompareTo(myItem(j))
L’apparition d’une contrainte d’implémentation d’IComparable dans ce cas particulier est
nécessaire afin de ne pas engendre une erreur lors de la compilation.
Afin de résoudre ce nouvel obstacle, vous aurez la possibilité d’utiliser deux méthodes de
gestion de contraintes :
- contraintes de Type : « Type Constraints »
- contraintes New : « New Constraints »
Contraintes de Type
Vous pourrez ainsi utiliser des contraintes de types afin de vous assurer que le type de
l’argument exploité dans un des paramètres hérite bien ou implémente le type souhaité. Les
classes et interfaces pourront être spécifiées par des contraintes de Type.
Public Class myContraintsCollection(Of KeyType, ElementType As
System.Windows.Forms.Panel)
'Les deux paramètres sont définis et utilisés en qualité de générics
'ElementType possède une contrainte sur le type "Panel"
Public Sub Add(ByVal myKey As KeyType, ByVal myElement As ElementType)
' ... code
Dim myControl As System.Windows.Forms.Control = myElement
End Sub
End Class
L’exploitation de ce code n’en restera que plus transparent :
'Déclaration correcte, la contrainte "Panel" est respectée
Dim myContraintsCollection As New myContraintsCollection(Of String, Panel)
'Déclaration non correcte, la contrainte "Panel" n'est pas respectée
Dim myContraintsCollection_bis As New myContraintsCollection(Of String, TextBox)
Voici le retour côté IDE :
Bien entendu les contraintes pourront être individuelles et placées sur chaque paramètre.
Celles-ci pourront également être multiples, voir croisées avec les contraintes « New » cidessous. Une contrainte pourra également est par exemple une Interface.
Contrainte New
Ce type de contrainte est plus typique puisqu’elle vous permet de valider le fait que votre
« Type » possède bien un constructeur et ne soit pas par exemple une Interface voir une classe
« MustInherit ». Observez l’exemple suivant :
Public Class myFactory(Of myType As New)
Public Function myInstance() As myType
' ... code
Dim myNewInstance As New myType
End Function
End Class
Qui sera exploité de la manière suivante :
'Déclaration correcte puisque l'objet de Type Control possède bien un constructeur
Dim myFactory As New myFactory(Of Control)
Contraintes Multiples
Voici un exemple de contraintes multiples. Supposons le contexte suivant :
Interface myInterface1
Sub mySub1()
Sub mySub2()
End Interface
Interface myInterface2
Sub mySub1()
Sub mySub3()
End Interface
Class myClasse
Sub mySub4()
End Sub
End Class
Vous pourrez ainsi créer votre classe générique avec les contraintes suivantes :
Class myMultipleContraints(Of myType As {myClasse, myInterface1, New}, mySecondType As
{myInterface1, myInterface2})
Public Sub myMethod()
Dim myT As New myType
myT.mySub4()
myT.mySub1()
myT.mySub2()
Dim myT2 As mySecondType
'Déclaration incorrecte du au caractère ambigue entre les deux interfaces
'mySub1 étant présente dans les deux interfaces
'remarquez que myT2 n'instancie pas de constructeur New puisqu'elle ne possède
pas de contrainte de type New
myT2.mySub1()
'Déclaration correcte de par le Cast explicite de myT2 myInterface2
CType(myT2, myInterface2).mySub1()
'Déclaration correcte, pas de caractère ambigue
myT2.mySub3()
End Sub
End Class
Voyez côté IDE – Intellisense :
Générics vs Polymorphism
Bien que vous ayez parcouru au travers de ces quelques explications l’exploitation potentielle
des générics au sein de votre code VB 2005. Que se passerait-il dans le cas suivant.
Supposez que vous souhaitiez définir une méthode permettant d’imprimer le contenu texte
d’un contrôle.
Deux possibilités s’offrent à vous :
1. Définition d’une méthode non générique attendant un paramètre de type Control
2. Définition d’une méthode générique
Observez :
'Méthode non générique
Sub PrintControl(ByVal C As Control)
'... code
End Sub
'Méthode générique
Sub PrintControl(Of myType As Control)(ByVal C As myType)
'... code
End Sub
Quel sera le meilleur choix ? la méthode générique ou non générique ?
Les deux méthodes permettent l’exploitation de tout type de contrôle pour autant que celui-ci
hérite du type Control (ex : Button, TextBox, …). Ainsi le côté pragmatique devrait vous
pousser vers la première non générique puisque la seconde n’apporte aucun élément
qualificatif supplémentaire et n’engendrerait que complexité complémentaire.
Mais supposons maintenant que vous souhaitiez n’imprimer que les contrôles implémentant
l’Interface « IPrint » ci-dessous.
Interface IPrint
'... code
End Interface
Dans ce cas, l’exploitation code change de la manière suivante :
'Méthode non générique
Sub PrintControl(ByVal C As IPrint)
'... code
End Sub
'Méthode générique
Sub PrintControl(Of myType As {Control, IPrint})(ByVal C As myType)
'... code
End Sub
Hors, quid ici de la garantie que l’objet de type IPrint sera bien un type Control, ainsi dans ce
second cas la méthode générique est plus appropriée.
5.2) Classes partielles
Les classes partielles représentent une nouveauté intéressante et plus particulièrement dans le
cadre du travail collaboratif, voir dans l’extension de code généré au travers d’outils comme
des AGL (Agents de Génie Logiciel).
L’approche est simple, à l’avenir les classes pourront être écrites sur plusieurs fichiers grâce à
la syntaxe " public partial class …"
Voici un exemple de création de classes partielles :
•
myPartialClass1.vb
Partial Public Class myPartialClass
Sub mySub1()
'... code
End Sub
End Class
•
myPartialClass2.vb
Partial Public Class myPartialClass
Sub mySub2()
'... code
End Sub
End Class
•
myPartialClass3.vb
Public Class myPartialClass
Sub mySub1(ByVal myAtt As String)
'... code
End Sub
Sub mySub3()
'... code
End Sub
End Class
Et voici le résultat obtenu au travers de l’explorateur de classes nous montrant bien que le
compilateur se chargera bien de reconstruire pour l’IL de votre assembly une classe unique à
partir des partiales classes.
Une nuance à ce titre entre VB.NET et C#, VB.NET tolère une classe déclarée en « Public
Class ».
5.3) Types Nullables
Si vous n’aviez jamais imaginé assigner des valeurs nulles à vos types « valeur », détrompezvous ! Vous pouvez désormais assigner des valeurs nulles à des types valeur en définissant un
type nullable.
Les types nullables dérivent du type générique System.Nullable<T>. T étant votre type.
Deux propriétés étendent l'utilité des types nullables : "HasValue" et "Value".
HasValue évalue le caractère « nulle » de votre type tandis que Value retournera la valeur
fondamentale que celle-ci soit nulle ou non.
Observez le code ci-dessous :
'Définition du type nullable sur un type Integer
Dim myNullable As Nullable(Of Integer)
'Vérification si la valeur est nulle ou non
If myNullable.HasValue Then
'... Code
Else
Console.WriteLine("Type Null !")
End If
Les nouveautés sont toutes aussi importantes que celles de C# 2.0. Certaines sont communes.
Nous pourrions parler de My, de la surcharge d'opérateurs, des mots clés IsNot et Using, des
types Integer non signés, de Continue ainsi que des processus asynchrones en nouveautés
distinctes.
5.4) My
L’objet "My" est retrouvé exclusivement dans l’interface de développement sous Visual
Basic. Celui-ci permet d'avoir accès rapidement à un ensemble de fonctionnalités diverses.
Voici un exemple de chargement d’un fichier son :
My.Computer.Audio.Play("c:\mesSons\fichierson.wav")
Dès plus intuitif ! Observez un autre exemple de code permettant de vérifier l’état de
connexion de l'ordinateur au réseau.
If My.Computer.Network.IsAvailable Then
'... Code
Else
'... Code
End If
Voici la représentation de l'objet "My" :
Vous y retrouverez : « My. »
-
Application : informations de version, logs, …
Computer : impression, base de registre, audio, fichiers, …
Forms : collection de formulaires
Resources : icônes, images, …
Settings : paramètres des applications et utilisateurs
User : nom d’utilisateur, groupe, domaine, …
WebService : collection des web services référencés dans le projet
5.5) Surcharge des Opérateurs
Historiquement, le .NET Framework permet la surcharge des opérateurs. Ce dispositif
permet de consommer des opérateurs dont la fonctionnalité a été surchargée par une classe
particulière, ce dispositif n’était pas disponible dans les versions précédentes, et permet aussi
au développeur de surcharger les fonctionnalités des opérateurs standards des langages
comme +, -, *, / et bien d’autres.
Dim p1 As New Point(100, 100)
Dim s1 As New Size(20, 30)
Dim p2 As Point = p1 + s1
Dim p3 As Point = p1 - s1
p2 contenant ainsi {120, 130} et p3 contenant {80, 70},
Cette surcharge n'est pas limitée à ces quelques opérateurs mais s’étend à d’autres opérateurs
comme / , ^, &, Like, Mode, And, Or, Xor, Not, <<, >>, = (comparaison), <>, <, <=, >, >=,
CType, IsTrue et IsFalse.
5.6) Mots clés IsNot & Using
Une des innovations se trouve également dans l’introduction de ces deux mots clés. Voici ce
que vous deviez écrire :
Dim Obj As New Object
If Not (Obj Is Nothing) Then
'... Code
End If
Vous écrirez à partir de maintenant :
Dim Obj As New Object
If Obj IsNot Nothing Then
'... Code
End If
Plus intuitif !
Dans VB.NET 2005 apparaît le mot clé Using qui se chargera de créer un bloc de code qui
sera disposé lors de la fin de l’utilisation de ce bloc, peut importe comment vous échapperez
ce bloc de code.
Voici un exemple repris de la MSDN :
Private Sub Form1_Paint( _
ByVal sender As Object, ByVal e As PaintEventArgs) _
Handles MyBase.Paint
' Create a new font.
Using myFont As New Font("Verdana", 12)
' Create a new solid brush.
Using myBrush As New SolidBrush( _
Color.FromArgb(123, 0, 123))
e.Graphics.DrawString( _
"Hello, World!", myFont, myBrush, 0, 0)
End Using
End Using
End Sub
5.7) Types Integer non signés
VB.NET 2005 prend nativement en charge les type signés et non signés ainsi que l’ensemble
des méthodes nécessaires à la conversion de ceux-ci. Les types SByte, UShort, UInteger et
ULong.
5.8) L’état Continue
VB.NET 2005 intègre le « Continue ». Cette syntaxe est déjà présente en C#. Elle permet de
passer directement à l'itération suivante sans exécuter le code de votre Do, While, For.
6) Nouveautés de VS 2005
Les nouveautés de Visual Studio 2005 (Professional Edition) comme vous pourrez le
constater sont nombreuses et peuvent un peu déconcerter au premier abord, une tendance à la
réorganisation méthodologique fait grand pas dans cette nouvelle version. Le mot d'ordre
reste toujours : "Plus productif, plus pragmatique, plus professionnel !"
Ce paragraphe se veut centrique sur l’IDE en version « Professional ». Ainsi les nouveautés
orientées sur des aspects comme Team System seront volontairement écartés en vue de se
concentrer sur une approche orientée purement développeur !
Les nouveautés de l’IDE peuvent être classées en catégories, voici celles mentionnées par la
MSDN US dont vous trouverez la référence en fin de tutorial :
•
•
•
•
•
•
•
Nouveautés dans l’IDE
Nouveautés dans l’édition de votre code
Nouveautés dans la création et gestion des Projets, Solutions, et Items
Nouveautés dans la compilation, le test et le déploiement
Nouveautés dans le debugger de Visual Studio 2005
Nouveautés dans la gestion des extensions et automatisation dans Visual Studio 2005
Nouveautés dans l’aide de Visual Studio 2005
Vous voici face un beau panel de catégories nous pouvant être détaillées au travers d’un
simple tutorial tant les nouveautés des l’IDE sont riches.
6.1) Nouveautés dans l’IDE
La première catégorie de nouveautés, visuellement spectaculaire, permettra de mieux
comprendre la nouvelle direction "Productivité" prise par les équipes de Redmond. Cette
première direction ne reste pas orpheline puisque d'autres groupes d’améliorations comme la
navigation, les nouveaux dispositifs de l’IDE et l'intégration de la communauté des
développeurs au sein même de VS 2005 sont au goût du jour !
Dès l’ouverture, le nouveau design de la page d’accueil et de l'IDE peut surprendre, bien qu’à
ce stade de nombreux articles ont déjà fleuris et permis de s’habituer à cette nouvelle
approche visuelle. La fenêtre d'accueil a complètement été revue graphiquement pour cette
release et contient maintenant quatre sections d’informations que vous pouvez découvrir dans
la capture ci-dessus.
La réorganisation de création des projets centrée sur l'objet du développement (Besoin final
du client) et non plus sur la compétence du développeur transpire au travers de ce nouvel
IDE. Y aurait-il un souhait de réconcilier ces deux mondes ?
La personnalisation lors du premier lancement de Visual Studio nous donne la même
impression, les arrangements de l’IDE sont de plus en plus orientés vers le type de
développements et personnalisation individuelle !
Ces personnalisations incluent les configurations des fenêtres, l’exposition ou non des
commandes et menus, de leurs noms, des raccourcis clavier,…
Toutes les adaptations effectuées sur votre IDE sont dépistées automatiquement et stockées.
Celles-ci pourront être par la suite exportées et importées par d'autres utilisateurs de Visual
Studio 2005. Ceci permettant une plus grande cohésion dans le cadre d’un travail
collaboratif.
Un assistant accessible de puis l'option « Tools / Import and Export Settings Wizard » vous
permettra d’effectuer une telle opération.
Mais avant d’exporter ou importer l’adaptation de l’IDE, observez quelques nouveautés non
négligeables propres à l’exploitation visuelle de celui-ci.
•
La Gestion de la disposition des fenêtres et boîtes à outils a subit un sérieux
rafraîchissement comme vous pouvez le constater dans la capture ci-dessus, la
visualisation de l’ancrage a nettement été améliorer. L'arrangement des boites à outils
et fenêtre se fait maintenant avec une grande précision en un minimum de temps!
•
La navigation entre les fenêtres ouvertes dans l'IDE grâce à la combinaison des
touches « Ctrl + Tab » sera certainement un des éléments de navigation que vous
apprécierez. Effectivement, celui-ci se veut proche du mode de navigation entre les
fenêtres dans Windows.
•
La liste des fichiers actifs accessible dans la partie supérieure droite d'affichage des
fichiers ouverts permet également une meilleure navigation au sein des fichiers de
votre projet.
Vous constaterez que ces quelques fonctionnalités deviennent très rapidement indispensables
et manquent cruellement lors de tout retour dans Visual Studio .NET 2003 !
Enfin, et afin de clôturer cette première catégorie de nouveautés de l'IDE, vous retrouverez
une intégration forte du monde communautaire (Projet CodeWise – CodeZone) au sein de
l'IDE de Visual Studio 2005.
Effectivement, ceci a été possible grâce au travail de collaboration de l’ensemble des
représentants et responsables des communautés tant francophone qu'anglophone, l'idée de
cette intégration est de permettre un accès centralisé à l'ensemble des sources, articles,
tutoriaux au sein de l’aide de Visual Studio 2005 tout en préservant l'autonomie et
l'indépendance de chaque communauté membre de cette initiative.
6.2) Nouveautés dans l’édition de votre code
Cette seconde catégorie, plus proche des besoins quotidiens du développeur, apporte de
sérieuses nouveautés permettant d’accroître la productivité et le professionnalisme de manière
considérable.
Ces nouveautés fonctionnelles, tantôt propre à un langage, tantôt non, sont nombreuses et
demanderaient un traité à part entière rien que pour les lister et les décrire brièvement.
En voici une première liste non exhaustive propre à l’édition de votre code et la création de
vos interfaces :
•
Code
Snippets
Les Code Snippets sont des segments de codes prêt à l’emploi pouvant être inséré
dans vos projets VB.NET, C# ou J#.
Snippets sous VB.NET
Snippets sous C#
Les Code Snippets peuvent être administrés à partir de la fenêtre « Code Snippets
Manager » accessible depuis le menu "Tools".
Cette fenêtre vous permettra d’ajouter, supprimer ou importer vos Snippets personnels
(accessible dans le répertoire : \ Mes documents\Visual Studio 2005\Code Snippets).
Voir de les partager avec vos collègues en mode collaboratif. L’ensemble des
Snippets présents par défaut dans Visual Studio (C#) sont accessibles depuis le
répertoire suivant : C:\Program Files\Microsoft Visual Studio 8\VC#\Snippets.
L’accès au snippets de VB.NET se fait en modifiant "VC#" par "VB"
•
Smart
Tags
Les Smart Tags vous accompagneront tout au long de votre travail avec Visual Studio
2005. Ceux-ci se chargeront de vous relayer les informations ou indications
disponibles en fonction de votre contexte de travail.
•
Refactoring
Disponible par défaut en C# et sous forme d’add-in (DeveloperExpress) à VS 2005
pour VB.NET, les options Refactoring vous permettront de renommer vos objets à la
volée, l’extraction de méthodes, l’extraction d’interfaces, la modification de signature
ainsi que l’encapsulation de propriétés.
•
Track
Changes
Au cours de votre utilisation de VS 2005, vous remarquerez vite des zones de couleurs
changeantes en marge des lignes de votre code. Effectivement, cette nouvelle option
vous permet d’avoir une visualisation directe des modifications et sauvegarde que
vous opérez dans vos fichiers. La couleur jaune déterminant dans ce cas les lignes
modifiées et la couleur verte leur sauvegarde.
Les couleurs peuvent être adaptées à partir des options de VS 2005.
•
AutoRecover
Fonctionnalité non négligeable, celle-ci se chargera de sauvegarder vos fichiers toutes
les 5 minutes et videra son cache à partir de 7 jours. Les délais peuvent bien
évidemment être refixés à partir des options, voir même désactivé.
Cette
fonctionnalité de Recover ira un cran plus loin en vous proposant à l’ouverture de VS
2005 de récupérer vos fichiers ouverts lors de la session précédente en cas de
fermeture non souhaitée de l’IDE.
Mais ceci n’est pas tout, d’autres fonctionnalités plus orientées sur la création de vos
interfaces et le soutient que VS 2005 peut vous apporter sont pour le moins bluffantes, le mot
d’ordre restant toujours : « plus de productivité ».
Un rapide coup d’œil sur la toolbox de contrôles web permet de se rendre compte à quel point
ce nouvel IDE permettra d’accélérer les temps de développements.
Et ce n’est qu’un début, l’ouverture d’un formulaire vous permettra de vite vous rendre
compte de nouvelle fonctionnalités vous permettant encore d’accélérer votre travail.
La navigation dans les tags de votre document, dans un formulaire web au sein d'un projet
ASP.NET, devient des plus intuitives grâce à l’exploitation de la barre de navigation de
documents html en mode design (Tag Navigator).
Observez l’interaction de VS2005 et de SQL Server ainsi que les nouveaux contrôles
ADO.NET au travers d’un petit exemple des plus explicites en créant l’affichage de la liste
des enregistrements de la table « Products » de la base Northwind au sein d’une page
ASP.NET.
La création de ceci se fera sans écrire une seule ligne de code, par un simple cliquer-déplacer
de la table products sur l’ASPX rappelant furieusement le mode de fonctionnement de la
MxDataGrid présente dans WebMatrix.
Vous obtiendrez le résultat suivant :
VS2005 a créé ainsi un GridView ainsi que le SQLDataSource correspondant.
Après quelques adaptations effectuées en quelques secondes grâce aux Smart Tags du
GridView et toujours sans avoir effectué une ligne de code, nous obtiendrons le résultat
suivant :
6.3) Nouveautés dans le debugger de Visual Studio 2005
Cette dernière catégorie fait certainement partie des plus impressionnantes, effectivement, le
debugger, bien qu’indispensable et performant sous VS.NET 2003, manquait de lisibilité pour
le développeur.
Le debugger sous VS 2005 s’est enrichi et offre de nouvelles fonctionnalités qui réjouira plus
d’un développeur ! Vous pourriez simplement parler de l’Edit & Continue, des Smart Tags
de navigation en mode débug de vos objets, de l’incorporation de l’intellisense au sein des
fenêtres d’espion, des visualiseurs, de l’exception helper, ou encore le mode debugger
DataTips permettant de visualiser le contenu de structure de données complexes.
Bien entendu, à tout mode debugger vient se greffer de manière naturelle une gestion des
points d’arrêts (BreakPoints). L’exploitation de ceux-ci c’est également vu subir un sérieux
coup de rafraichissement. Pour cause, vous pouvez toujours ajouter ou supprimer des points
d’arrêts mais vous pourrez également travailler sur des modes conditionnels, de Hit Count,
Filter, Location ou When Hit dans le cadre de l’exploitation de ceux-ci !
L’ajout et la suppression d’un point d’arrêt n’a pas changé, par contre vous aurez la
possibilité à partir de son menu contextuel de transformer votre point d’arrêt en un Trace
Point grâce à la fonctionnalité « When Hit » :
Cette fenêtre de gestion du TracePoint vous permettra ainsi d’afficher un message définit sous
forme d’expression, voir de démarrer une macro et enfin de définir si ce TracePoint garde le
comportement intrinsèque ou non d’un point d’arrêt !
Nous pourrions ainsi nous étendre sur bien d’autres nouveautés de VS 2005 et constater que
le tapage marketing Microsoft n’est pas dénué de sens. La « Productivité » est clairement le
mot d’ordre qui a guidé les équipes de Redmond dans l’évolution vers cette nouvelle version
de l’IDE.
Sa prise en main, des plus intuitives, rassurera tout développeur dans le passage de la version
2003 à la version 2005.
D’autres fonctionnalités importantes auraient encore pu être traitées dans ce tutorial.
Rappelons toutefois d’autres nouveautés comme :
• Le Class Designer
• La fenêtre de définition de code en C#
• La fenêtre de commande incorporant encore plus d’IntelliSense et d’Alias
• Le Wizard de publication de vos sites en ASP.NET
• L’amélioration du formatage de votre code VB.NET ou C#
• L’amélioration de l’édition de l’XML et le XSLT debugging
• …
Je ne pourrais ainsi que vous conseiller l’installation d’au moins une version Express et de
vous faire votre propre expérience et jugement.
Sources & références Web
Site Microsoft & MSDN2 :
•
•
•
•
•
•
•
Visual Studio 2005
http://www.microsoft.com/France/msdn/vstudio/
Centre de développement Visual Basic
http://www.microsoft.com/France/msdn/vbasic
Visual Studio 2005 Developer Center
http://lab.msdn.microsoft.com/vs2005/
http://msdn.microsoft.com/vstudio/products/
Tools and Utilities
http://lab.msdn.microsoft.com/vs2005/downloads/tools/default.aspx
NImport – Export Settings Wizard
http://msdn2.microsoft.com/library/1x6229t8
Defining and Using Generics in Visual Basic 2005
http://msdn.microsoft.com/library/default.asp?url=/library/enus/dnvs05/html/vb2005_generics.asp