Accueil
Club Emploi Blogs   TV   Dév. Web PHP XML Python Autres 2D-3D-Jeux Sécurité Windows Linux PC Mac
Accueil Conception Java DotNET Visual Basic  C  C++ Delphi Eclipse MS-Office SQL & SGBD Oracle  4D  Business Intelligence

Cours VB.NET

Date de mise à jour : 05/12/2010


VI. Classes
VI-A. Espace de noms, Classes, Objet
VI-A-1. Classes
VI-A-2. Essayons de comprendre
VI-A-2-a. Détails en VB 2003
VI-A-2-a-i. Les Références
VI-A-2-a-ii. Importation d'espace de noms
VI-A-2-b. Détails en VB 2005 2008 2010
VI-A-2-b-i. Les Références
VI-A-2-b-ii. Importation d'espace de noms
VI-A-2-b-iii. Portée de l'espace de noms
VI-A-2-b-iiii. Propriété ambiguë
VI-A-2-b-iiiii. Alias
VI-A-2-b-iiiiii. Héritage
VI-A-2-b-iiiiiii. Membre d'instance et membre partagé
VI-A-2-b-iiiiiiii. Classes statiques ou non
VI-B. Les différentes Classes, le Framework
VI-B-1. Les différentes 'Classes'
VI-B-1-a. Les classes du Framework fournies par Microsoft avec VB
VI-B-1-b. Les classes fournies par des tiers
VI-B-1-c. Les Classes écrites par le programmeur
VI-B-2. Dans Visual Basic.Net
VI-B-3. Lors de la création d'un nouveau projet
VI-B-4. Framework 1, 2, 3, 3.5, 4.
VI-C. Le CLR
VI-D. Procédures évènement, surcharge de méthode
VI-D-1. Évènement et procédure évènement
VI-D-2. Différentes méthodes pour gérer les évènements
VI-D-3. Surcharge de Méthode
VI-E. L'écriture 'Compact'
VI-F. Notion de flux ou 'Stream'


VI. Classes

Voir la vidéo : au format 'Flash'> ou au format 'Avi' en Visual Basic 2005.

La vidéo (identique à celle du chapitre sur les objets) contient:

1)Objets, Classes.

2)Références, espaces de noms.


VI-A. Espace de noms, Classes, Objet


VI-A-1. Classes

Nous avons vu qu'on utilise des objets. Des objets 'visuels' pour les formulaires, boutons.. ou des objets comme les variables, les collections, des objets mathématiques...

Il existe des 'types' d'objet qui définissent les caractéristiques communes des objets. Ces types se nomment les Classes.

Exemple:

La Classe System.Windows.Forms contient les objets 'Forms' et les 'Control' (formulaire= fenêtre et contrôles).

On rappelle que se sont ces classes que l'on utilise pour instancier (créer) un objet, une instance.

Dim B As New Form ' crée un formulaire( une instance de formulaire) 
'à partir de la Classe Form (Fenêtre).
B hérite de toutes les caractéristiques de la Classe Form.

Les classes sont regroupées en bibliothèques sous la dénomination 'Espace de noms' (NameSpace).

Un Framework est un ensemble d'espace de noms et de classes.



VI-A-2. Essayons de comprendre

Pour utiliser un objet en VB (fourni par le Framework par exemple), il faut:
  1. Que la Dll correspondante soit chargée dans le projet. (La Dll c'est un fichier exécutable '.dll' qui contient le code nécessaire; le Framework en comporte plusieurs). En VB.NET on appelle cela la 'Référence' (Dans 'Explorateur de solutions')Exemple de Dll:
    
    System.dll
    
  2. Que l'espace de nom soit importé: une Dll contient des espaces de noms dans lesquelles se trouvent les Classes. Pour utiliser une Classe il faut inclure l'espace de noms correspondant dans le programme donc il faut l'importer à partir de la Dll . On va par exemple importer l'espace de nom 'System.Windows.Forms' ( il est dans System.dll et contient les Classes 'Form' et 'Control'):
    
    Imports System.Windows.Forms    
    
  3. On peut maintenant utiliser les Classes contenues dans cet espace de nom et créer un objet. par exemple on va créer une fenêtre avec la Classe Form contenue dans System.Windows.Forms.
    
    Dim Form1 As New Form
    
    Form1 est donc un objet formulaire qui hérite de tous les membres (Propriétés, méthodes) de la Classe Form, on peut donc utiliser une méthode de cet objet:
    
    Form1.Show()    'pour faire apparaître la fenêtre
    
    ou une propriété:
    
    Form1.BackColor=Color.Red 'pour modifier la couleur de fond
    

info Les Classes les plus courantes sont déjà chargées et disponibles, ce qui simplifie un peu les choses.

VI-A-2-a. Détails en VB 2003


VI-A-2-a-i. Les Références
Pour qu'une classe soit utilisée, il faut que le composant correspondant (la DLL) soit chargé; on a vu que par défaut quelques composants du Framework (System.dll..) et le CLR ( mscorlib.dll) étaient chargés.

Dans 'Explorateur de solutions':

Double-cliquez la rubrique références pour voir les DLL (références déjà chargées).

Si vous souhaitez utiliser un autre composant dans votre application et qu'il n'est pas chargé, il faut ajouter la référence de ce composant. Dans la fenêtre de l'explorateur de solutions, cliquez le bouton droit de la souris puis cliquez sur 'Ajouter une référence'. La boîte de dialogue 'Ajouter une référence de Visual Studio .NET' propose trois options :

  • .NET - Répertorie tous les composants .NET Framework pouvant être référencés. (Certains sont déjà chargés comme System..) et les composants extérieurs NET.
  • COM - Répertorie tous les composants COM pouvant être référencés (ceux qui fonctionnaient en VB6).
  • Projets - Répertorie tous les composants réutilisables créés dans des projets locaux.

VI-A-2-a-ii. Importation d'espace de noms
Certains espaces de noms ne sont pas chargés, l'espace de noms Math n'est pas chargé par exemple. (Bien que la référence, la dll qui se nomme System soit présente dans le projet.)

Si je veux utiliser Round pour arrondir un nombre il faut d'abord importer l'espace de nom 'Math':

Pour cela il faut taper en haut de la fenêtre (au-dessus de public Class).

Imports System.Math
Ensuite, on peut écrire:

Label1.Text = (Round(1.2)).ToString 'qui affiche 1.
Si l'Import n'a pas été fait, System.Math.Round(1.2) est accepté aussi. (A condition que la Dll soit chargée)

Noter bien que dans notre exemple, comme Math fait partie de System, la référence (la Dll correspondante) est déjà chargée.


Autre exemple: si on veut utiliser les fichiers, il faut importer System.IO.



VI-A-2-b. Détails en VB 2005 2008 2010


VI-A-2-b-i. Les Références
Pour qu'une classe soit utilisée, il faut que le composant correspondant (la DLL) soit chargé; on a vu que par défaut quelques composants du Framework (System.dll..) et le CLR ( mscorlib.dll) étaient chargés.

Dans 'Explorateur de solutions' double-cliquez sur 'My Projet', ou dans le menu Projet, cliquez sur propriétés de..

Puis choisir l'onglet 'Références'

On voit la liste des références chargées dans le projet: ici System, System.Data..

Si vous souhaitez utiliser un autre composant dans votre application et qu'il n'est pas chargé, il faut ajouter la référence de ce composant. Cliquez le bouton 'Ajouter...'. La boîte de dialogue 'Ajouter une référence' s'ouvre:

Elle propose:
  • .NET - Répertorie tous les composants .NET Framework pouvant être référencés. (Certains sont déjà chargé comme System..) et les composants extérieurs NET.
  • COM - Répertorie tous les composants COM pouvant être référencés (ceux qui fonctionnaient en VB6).
  • Projets - Répertorie tous les composants réutilisables créés dans des projets locaux. (D'autres programmes VB)
  • Parcourir permet de rechercher ; Récent liste les DLL récemment chargées.
En cliquant sur une référence puis sur 'Ok', cela charge la référence.


VI-A-2-b-ii. Importation d'espace de noms
Certains espaces de noms ne sont pas chargés, l'espace de noms Math n'est pas chargé par exemple. (Bien que la référence, la dll qui se nomme System soit présente dans le projet.)

Si je veux utiliser Round pour arrondir un nombre il faut d'abord importer l'espace de nom 'Math':

Pour cela il faut taper en haut de la fenêtre (au-dessus de public Class).

Imports System.Math
Ensuite, on peut écrire:

Label1.Text = (Round(1.2)).ToString 'qui affiche 1.
Si l'Import n'a pas été fait, System.Math.Round(1.2) est accepté aussi. (A condition que la Dll soit chargée)

Noter bien que dans notre exemple, comme Math fait partie de System, la référence (la DLL correspondante) est déjà chargée.

On peut aussi importer les espaces de noms directement depuis l'onglet références (Après avoir cliqué sur 'My Projet'):

Il suffit de choisir la dll en haut pour voir l'afficher les espaces de noms contenus dans cette dll en bas et de cocher ceux que l'on veut charger.


VI-A-2-b-iii. Portée de l'espace de noms
Si un seul espace de noms est spécifié (Imports System), tous les membres à nom unique de cet espace de noms sont présents. Si un espace de noms et le nom d'un élément de l'espace de noms sont spécifiés (Import System.Math), seuls les membres de cet élément sont disponibles sans qualification.

Exemple:

Imports System

Permet d'utiliser System.ArgumentException mais pas Systeme.Math.round

Pour utiliser Round il faut Importer System.Math



VI-A-2-b-iiii. Propriété ambiguë
Certaines propriétés sont communes à plusieurs classes, il peut y a avoir ambiguïté et il faut utiliser dans ce cas la syntaxe complète: 'EspacedeNom.Classe'.

C'est le cas pour Left qui est une propriété de Microsoft.VisualBasic.String mais aussi une propriété des contrôles.

MonControle.Left=250  'est accepté

Chaine= Left(C,2)     'pose des problèmes.
Pour lever l'ambiguïté il faut écrire Microsoft.VisualBasic.Left(C,i) par exemple quand on utilise Left pour manipuler des chaînes(Car Left fait partie de l'espace Microsoft.VisualBasic ).

Chaine= Microsoft.VisualBasic.Left(C,2) 'est accepté.
On voit là tout l'intérêt des espaces de nom qui permettent d'avoir plusieurs éléments (classe, propriétés..) de même nom mais dans des espaces de nom différents.



VI-A-2-b-iiiii. Alias
Parfois pour simplifier l'écriture ou pour éviter des ambiguïtés on peut utiliser des Alias:

Imports STR= Microsoft.VisualBasic.Strings importe l'espace de nom String mais le désigne sous le nom de STR (STR est un Alias); STR est utilisé ensuite:

 Chaine=STR.Left(C,i)

info En résumé:
Les Classes sont dans des espaces de nom qui sont dans des Dll (références).
ou
Les 'Dll' contiennent des 'Espaces de noms' contenant des 'Classes'.
Les références ( Dll) permettent de charger des composants, des Classes du Framework ou d'autres classes.
L'instruction 'Imports' permet d'importer des espaces de nom venant de ses références.
Cela donne accès dans le programme à des classes. on pourra donc instancier des objets grâce à ces Classes puis utiliser des méthodes.
Noter que dans les Classes, il existe une structure arborescente.

La premier Classe (en haut) est System.

Dessous il y a entre autres System.WindowsForms.

Dessous System.Windows.Forms.Control.

Enfin System.Windows.Forms.Control.Name par exemple.



VI-A-2-b-iiiiii. Héritage
Les classes héritent des membres (propriétés, méthodes) dont elles sont issues:

Exemple :

Un contrôle Button hérite de System.Windows.Forms.Control et de toutes ses propriétés car tous les composants avec représentation visuelle héritent de 'Control'.

Et bien les propriétés Name, Left, Right, Visible, Enabled qui sont des membres de Control deviennent aussi des membres de Button.



VI-A-2-b-iiiiiii. Membre d'instance et membre partagé
Un objet a des membres (propriétés et méthodes):

  • Un membre peut être accessible directement sur un instance : on appelle cela un membre d'instance.
    Exemple:

    Dim A As String crée une variable A , en fait une instance, un objet à partir de la Classe String.

    Ensuite on peut utiliser:
    
    B=A.Trim(" ") 'ici Trim enlève les blancs en début et fin de chaîne.
    
    Trim est bien une méthode qui s'applique à une instance (A).

  • Un autre membre peut être accessible par les méthodes de la classe (en non pas de l'instance) :
    La Classe de sa nature, de son type.

    Dans la classe 'String' j'utilise la méthode Compare pour comparer 2 chaînes.

    c=String.Compare(a,b)

    J'utilise 2 paramètres, mais j'appelle la méthode directement à partir de la Classe String.

    La Classe de l'opération à effectuer:

    Dans la Classe Math j'utilise la méthode Abs (Valeur absolue):

    c= Math.Abs(-12)


On appelle cela une méthode partagée (shared) car on l'utilise directement à partir du nom de la classe sans avoir à instancier.


On remarque que la Classe String a des membres d'instance et aussi des membres partagés.

La syntaxe est parfois bizarre mais obéit donc à une certaine logique.



VI-A-2-b-iiiiiiii. Classes statiques ou non
Ici on parle des classes et non des membres.

Certaines Classes sont dites Statiques car elles existent d'emblée et on peut travailler dessus sans les instancier:

Exemple:

La Classe Directory (répertoire):

Directory.GetCurrentDirectory    'est utilisable directement pour obtenir le répertoire courant. 

Par contre avec une Classe non statique il faut instancier l'objet que l'on va utiliser:

Pour la classe DirectoryInfo (information sur le répertoire), on doit instancier avant usage un DirectoryInfo particulier:

Dim D As DirectoryInfo

D= New DirectoryInfo( MonDossier)
C'est un peu théorique, mais on verra au fur et à mesure des exemples pratiques de cela.


VI-B. Les différentes Classes, le Framework


VI-B-1. Les différentes 'Classes'

Il existe 3 types de Classes


VI-B-1-a. Les classes du Framework fournies par Microsoft avec VB
Il existe ainsi des classes :
  • pour les formulaires Windows (WindowsForms) ;
  • pour le Web (WebForms) ;
  • pour l'accès aux données ;
  • pour les réseaux ;
  • pour la sécurité ;
  • etc.

Elles sont communes à VB, C#, C, ...

Le Framework est fourni avec VB, Vista, Window 7.

Il y a les Framework 1, 2, 3, 3.5 (correspondant à VB 2003, 2005, 2008).

Exemple du vieux Framework 1 :


Il y a aussi la instructions VisualBasic.

Elle est propre au VisualBasic.


info Quand on crée un nouveau projet, les Classes le plus souvent utilisées sont automatiquement chargées dans le projet:


VI-B-1-b. Les classes fournies par des tiers
On peut ajouter des références (Dll) permettant d'ajouter des classes nouvelles, cela permet d'ajouter de nouvelles fonctionnalités à VB: Exemple: les pilotes de base de données, les contrôles qui n'existent pas dans VB et que vous achetez. ..



VI-B-1-c. Les Classes écrites par le programmeur
Le programmeur peut les créer de toute pièce dans les modules de Classe(On verra cela plus loin).

En VB, on peut créer une classe, ses propriétés, méthodes.. et l'utiliser dans le corps du programme.

Vous pouvez vous aussi créer une Classe, la compiler, puis dans un autre projet référencer la Dll de la classe que vous avez créée et l'utiliser dans le nouveau projet.



VI-B-2. Dans Visual Basic.Net

Dans VB.Net il y a donc possibilité de travailler avec:
  • Les Classes du Framework, leurs propriétés, leurs méthodes. Les Forms, Controls, les classes des variables (String, Int32..) sont disponibles par défaut. (voir annexe 1)
  • Les instructions VB.Net de Microsoft.VisualBasic disponible par défaut. Ce sont des instructions VB bien connues (Left, Int, IsNumeric.. ) (voir annexe 2)
  • A oublier: Les instructions de la bibliothèque de compatibilité VB6. il faut dans ce cas importer Microsoft.VisualBasic. Compatibility et Microsoft.VisualBasic. Compatibility.Data, ces instructions sont là pour aider à la conversion, elles permettent d'utiliser des fonctions qui n'existent plus en VB.Net (comme les chaînes fixes par exemple), il faut les éviter impérativement car ce n'est pas du VB.Net et elles disparaîtront probablement dans les futures versions.
Exemple:

Pour la manipulation des nombres

'Int' 'Randomize' et 'Rnd' font partie de VB.Net,

'Round' fait partie de la classe Math donc du Framework,

'Imp' fait partie de la bibliothèque de compatibilité VB6.

Parfois certaines fonctions font double emploi et ont des équivalents dans les 2 ou 3 catégories.

Lesquelles utiliser?

Les Classes sont souvent plus riches avec multiples surcharges et, sont communes à tous les langages utilisant le Framework .Net. Si vous voulez passer au C#, les classes sont les mêmes.

Les instructions VB.Net sont propres à VB , c'est du VB et du .Net.

Par contre, les instructions devant de la compatibilité VB6 sont à éviter absolument. Seront-elles conservées dans les futures versions de VB.NET?



VI-B-3. Lors de la création d'un nouveau projet

Sont automatiquement chargé:

Une partie du Framework (System.dll) et le CLR la couche qui fait tourner le programme ( mscorlib.dll).

Sont donc à disposition:

  • Quelques espaces de nom contenant des classes du Framework:
System: espace de nom racine pour les types de données et le type objet.

System.data: Classe contenant l'accès aux bases de données; ADO.Net en particulier

System.drawing, System.Xml c'est clair!!

System.Windows: Classes de l'interface utilisateur.

Ce dernier contient les Controls

et aussi:

Microsoft.VisualBasic qui contient la bibliothèque qui permet d'utiliser les instructions VB (MsgBox, IsNumeric, Chr, Asc.....)

Comme ces Classes sont chargées au départ cela permet d'emblée de créer des feuilles, des contrôles..(qui sont dans les WindowsForms et les Controls).Cela permet aussi d'utiliser les instructions VB.

Si on a besoin d'autres classes, il faut les importer:

Imports System.Math par exemple pour utiliser les fonctions mathématiques.

Imports System.IO pour les fichiers séquentiels, aléatoires...

Imports System.Collections pour les Collections...

Imports System.Net pour le reseau...

..

Eviter d'importer Microsoft.VisualBasic.Compatibility qui apporte la compatibilité VB6


VI-B-4. Framework 1, 2, 3, 3.5, 4.

Un Framework est donc un ensemble de Classes.

Le framework 1.0 est utilisé par VB 2003.

Le framework 2.0 est utilisé par VB 2005.

Il contient des classes supplémentaires.

Le framework 3.0 peut être utilisé par VB 2005.

Le framework 3.0 est composé du framework 2.0 auquel s'ajoute WCF (Windows Communication Foundation), WWF (Windows Workflow Foundation), WPF (Windows Presentation Foundation) et infocard pour l'authentification des utilisateurs.
Windows Presentation foundation permet de gérer l' affichage des fenêtres. Celui-ci est basé sur direct x (version 10).

Le Framework 3.5 (fin 2007) utilisé par VB2008. C'est le Framework 3 auquel s'ajoute AJAX, LINQ et REST.

Le framework 4.0 peut être utilisé par VB 2010.


Sous Windows 98, XP, il faut installer le framework (avant d'utiliser l'environnement VisualBasic ou un exécutable VB)

Sous Windows Vista et Windows 7 les Frameworks sont installés nativement(Framework 1, 1.1, 2, 3, 3.5 pour Windows 7).

VB 2003 utilise le Framework 1.0.

VB 2005 utilise le Framework 2.0. ou 3.0

VB 2008 permet de choisir et d'utiliser le Framework 1.0, 2.0, 3.0, 3.5.

Voici le Framework 3.5:


VB 2010 permet de choisir et d'utiliser le Framework 2.0, 3.0, 3.5, 4.


VI-C. Le CLR

On rappelle que ce qui fait tourner le Framework c'est le CLR (Common Language RunTime); de la version 2 à la version 3.5 du Framework, c'était toujours la version 2.0.50727 du CLR qui est utilisée.
Avec le Framework 4 c'est la version 4!! du CLR qui est utilisée.


VI-D. Procédures évènement, surcharge de méthode


VI-D-1. Évènement et procédure évènement

On a vu qu'un objet pouvait avoir un évènement.

L'objet 'Button1' à un évènement Button1.Click

Comment faire pour que l'action de cliquer sur le bouton1 exécute une procédure?

Il faut l'indiquer grâce à Handles:

Si on veut que le Click sur Button1 exécute la procédure, la Sub 'MaRoutine', il faut écrire:

Sub Maroutine() Handles Button1.Click

End Sub
Ainsi quand l'utilisateur clique sur le bouton, la procédure Maroutine est exécutée.

VB, qui est vraiment très sympa, écrit automatiquement le code pour vous:

En mode 'Design', créez un bouton, double-cliquez dessus, vous vous retrouvez dans la procédure:

Private Sub Button1_Click() Handles Button1.Click

End Sub
Par défaut il a nommé la procédure Button1_Click (mais elle aurait pu se nommer autrement).


Dans la réalité, il a ajouté 2 paramètres:

Sender qui contient le nom de l'objet qui a déclenché l'évènement (c'est un objet)

e un objet qui contient les arguments de cet évènement. (de type EventAgrs mais pas toujours)

Cela donne:

Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs)  _
Handles Button1.Click

End Sub

Pour les forts et pour être complet, dans Form1.InitializeComponent (c'est une routine ou il y a le code créant les contrôles), il y a la ligne:

Friend WithEvents Button1 As System.Windows.Forms.Button qui indique que le bouton a des évènements (WithEvents).


En conclusion :

VB écrit automatiquement les procédures évènement. On verra plus loin qu'il est possible de créer nous même nos objets, évènements et procédures évènement.


VI-D-2. Différentes méthodes pour gérer les évènements

Avec WithEvents

On vient de voir cette méthode utilisée automatiquement quand on ajoute un objet visuel dans l'interface:
WithEvents indique qu'il faut gérer les évènements.

Friend WithEvents Button1 As System.Windows.Forms.Button
Cela permet ensuite d'écrire une Sub qui est exécutée quand l'évènement se produit:
Le mot Handles indique l'évènement qui exécute la Sub.

Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs)  _
Handles Button1.Click

End Sub

L'inconvenient de cette méthode est que la gestion de l'évènement ne peut pas être modifiée.


Avec AddHandler

On crée un gestionnaire d'évènement.
On crée un bouton, une Sub BoutonClick; avec AddHandler on indique que quand l'évènement Bouton.Click se déclenche il faut sauter à l'adresse de la routine BoutonClick.

Dim Button1 As New Button
AddHandler Button1.Click, addressOf BoutonClick


Sub BoutonClick
...
End Sub

Cette méthode est dynamique: dans le code , en cours d'éxécution, on peut ajouter un objet, géré les évènement.
On peut même annuler la gestion d'évènement grâce à RemoveHandler:

RemoveHandler Button1.Click, addressOf BoutonClick


VI-D-3. Surcharge de Méthode

Quand on utilise une méthode avec des paramètres, il y a parfois possibilité d'utiliser, avec la même méthode, un nombre différent de paramètres ou des paramètres de nature différente: on dit que la méthode est surchargée.

Chaque manière d'écrire les paramètres s'appelle une signature.

Exemple:

Voici une fenêtre MessageBox:

Pour ouvrir une fenêtre MessageBox il y a 12 signatures, en voici 2:

Reponse= MessageBox.show(TexteAAfficher,Titre, TypeBouton etIcone, BoutonParDéfaut)
Ici on donne 4 paramètres.

Reponse= MessageBox.show(TexteAAfficher)
Ici 1 seul paramètre.

On voit qu'on peut appeler la méthode MessageBox.Show avec un nombre différent de paramètres.

Comme on ne peut pas connaître toutes les signatures, VB nous aide:

Si on tape R= MessageBox.show( VB affiche dans un cadre une signature, de petites flèches permettent de faire défiler toutes les autres signatures:



VI-E. L'écriture 'Compact'

Habituellement on écrit une instruction par ligne:

Mais:

On peut créer une variable et l'initialiser en même temps:

Au lieu de:

Dim s As String

s = "Philippe. Jean . Toto" 
On peut écrire:

Dim s As String= "Philippe. Jean . Toto" 
Rien n'empêche d'initialiser avec une expression complexe:

Dim t As Single =  (3* Int(u))-2)

Autre exemple:

Ici par exemple on découpe la string s en utilisant des séparateurs et on met les noms dans un tableau:

Version non compacte:

Dim s As String= "Philippe. Jean . Toto" 

Dim sep() As Char={" "c, ","c, "."c}

Dim nom() As String 'Tableau des noms

nom = s.Split ( sep, 100, StringSplitOptions.RemoveEmptyEntries )
Mais on peut compacter le code:

Dim nom() As String = "Philippe. Jean . Toto".Split(New Char() {" "c, ","c, "."c, ":"c}, 100, _
StringSplitOptions.RemoveEmptyEntries)
On crée la variable nom, on l'initialise en même temps avec une méthode, les paramètres étant directement crées au niveau de l'appel de la méthode.


Même chose avec des fonctions:

Le paramètre d'une fonction peut être le résultat d'une fonction.

Soit une fonction qui se nomme 'Carré' , on peut lui envoyer un paramètre (elle accepte un Single), elle retourne le carré du paramètre:

Function Carré ( v as Single) as Single

    Return v*v

End Function
Soit une fonction qui se nomme 'Inverse', on peut lui envoyer un paramètre (elle accepte un Single), elle retourne le paramètre après avoir inversé le signe:

Function Inverse ( v as Single) as Single

    Return -v

End Function

 
Si on veut prendre le carré de 2 puis l'inverse et enfin la partie entière du résultat:.

Dim resultat As Single

Dim resultatintermediaire1 As Single

Dim resultatintermediaire2 As Single

resultatintermediaire1= Carré(2)        

resultatintermediaire2 = Inverse (resultatintermediaire1)

resultat= Int(resultatintermediaire2)
Ou de manière compacte:

Dim resultat As Single = Int(Inverse(Carré(2)))

warning L'écriture compacte du code est plus ramassée, moins 'lourde', avec moins de variables intermédiaires mais on perd en lisibilité parfois.

Dim resultat As Single = Int(Inverse(Carré(2))) 'Cet exemple est compact mais lisible.

Dim nom() As String = S.Split(New Char() {" "c, ","c, "."c, ":"c}, 100, _ 
StringSplitOptions.RemoveEmptyEntries) 
'C'est moins lisible


VI-F. Notion de flux ou 'Stream'

Le Stream (flux, torrent, courant) est une notion générale, c'est un flux de données provenant ou allant vers un fichier, un port, une connexion TCP/IP...

Ici on utilise un Stream pour lire ou écrire dans un fichier.

L'accès est séquentiel: les données sont traitées du début à la fin du fichier.

Pour écrire dans un fichier texte:

Il faut instancier un objet de la classe StreamWriter . On écrit avec Write ou WriteLine.(ajoute un saut de ligne) Enfin on ferme avec Close.

On peut instancier avec le constructeur de la classe StreamWriter et avec New, ou par la Classe File.

Dim SW As New StreamWriter ("MonFichier.txt") ' crée ou si existe écrase
Il existe une surcharge permettant de ne pas écraser mais d'ajouter à la fin du fichier:

Dim SW As New StreamWriter ("MonFichier.txt", True) ' crée ou si existe ajoute
Avec la classe File:

Dim SW As  StreamWriter=File.CreateText ("MonFichier.txt") ' crée ou si existe écrase

Dim SW As StreamWriter = File.AppendText("MonFichier.txt") ' crée ou si existe ajoute

 
Ensuite pour écrire 2 lignes:

SW.WriteLine ("Bonjour")

SW.WriteLine ("Monsieur")
Enfin on ferme:

SW.Close()
Pour lire dans un fichier Texte:

Il faut instancier un objet de la classe StreamReader. On lit avec Read (un nombre d'octet) ReadLine (une ligne) ReadToEnd (de la position courante jusqu'à la fin). Enfin on ferme avec Close.

Avec le constructeur de la Classe Stream Reader:

Dim SR As New StreamReader ("MonFichier.txt")
Avec la Classe File:

Dim SR As  StreamReader=File.OpenText ("MonFichier.txt") '
Comment lire chaque ligne du fichier et s'arrêter à la fin?

En effet on ne sait pas habituellement combien le fichier contient de ligne, si le fichier contient 2 lignes il faut en lire 2 et s'arrêter sinon on tente de lire après la fin du fichier et cela déclenche une erreur.

3 solutions:
  1. Utiliser ReadToEnd qui lit en bloc jusqu'à la fin.
  2. Avant ReadLine mettre un Try: quand l'erreur 'fin de fichier' survient elle est interceptée par Catch qui sort du cycle de lecture et ferme le fichier.
  3. Utiliser Peek qui lit dans le fichier un caractère mais sans modifier la position courante de lecture.
    La particularité de Peek est de retourner -1 s'il n'y a plus de caractère à lire sans déclencher d'erreur, d'exception.

La troisième solution est la plus générale et la plus élégante:

Do Until SR.Peek=-1

     Ligne=SR.ReadLine()

Loop
Enfin on ferme:

SR.Close()

 

Les sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Par contre cette page de présentation de ces sources constitue une oeuvre intellectuelle protégée par les droits d'auteurs. Copyright © . Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E de dommages et intérêts. Cette page est déposée à la SACD.

Vos questions techniques : forum d'entraide Accueil - Publiez vos articles, tutoriels, cours et rejoignez-nous dans l'équipe de rédaction du club d'entraide des développeurs francophones. Nous contacter - Copyright 2000..2005 www.developpez.com