Cours VB.NET

Image non disponible


précédentsommairesuivant

VI. Classes

Image non disponibleVoir 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.

 
Sélectionnez

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:
     
    Sélectionnez
    
    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'):
     
    Sélectionnez
    
    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.
     
    Sélectionnez
    
    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:
     
    Sélectionnez
    
    Form1.Show()    'pour faire apparaître la fenêtre
    ou une propriété:
     
    Sélectionnez
    
    Form1.BackColor=Color.Red 'pour modifier la couleur de fond

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

VI-A-3. Détails en VB 2003

VI-A-3-a. 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':

Image non disponible

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

Image non disponible

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-3-b. 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).

 
Sélectionnez

Imports System.Math

Ensuite, on peut écrire:

 
Sélectionnez

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-4. Détails en VB 2005 2008 2010

VI-A-4-a. 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'

Image non disponible

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:

Image non disponible
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-4-b. 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).

 
Sélectionnez

Imports System.Math

Ensuite, on peut écrire:

 
Sélectionnez

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'):

Image non disponible

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-4-c. 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-4-d. 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.

 
Sélectionnez

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 ).

 
Sélectionnez

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-4-e. 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:

 
Sélectionnez

 Chaine=STR.Left(C,i)

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-4-f. 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-4-g. 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:

     
    Sélectionnez
    
    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-4-h. 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):

 
Sélectionnez

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:

 
Sélectionnez

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 :

Image non disponible

Il y a aussi la instructions VisualBasic.

Elle est propre au VisualBasic.

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.

Image non disponible

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

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:

Image non disponible

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:

 
Sélectionnez

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:

 
Sélectionnez

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:

 
Sélectionnez

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.

 
Sélectionnez

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.

 
Sélectionnez

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.

 
Sélectionnez

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:

 
Sélectionnez

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: Image non disponible

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

 
Sélectionnez

Reponse= MessageBox.show(TexteAAfficher,Titre, TypeBouton etIcone, BoutonParDéfaut)

Ici on donne 4 paramètres.

 
Sélectionnez

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:

Image non disponible

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:

 
Sélectionnez

Dim s As String

s = "Philippe. Jean . Toto" 

On peut écrire:

 
Sélectionnez

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

Rien n'empêche d'initialiser avec une expression complexe:

 
Sélectionnez

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:

 
Sélectionnez

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:

 
Sélectionnez

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:

 
Sélectionnez

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:

 
Sélectionnez

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:.

 
Sélectionnez

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:

 
Sélectionnez

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

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

 
Sélectionnez

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.

 
Sélectionnez

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:

 
Sélectionnez

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

Avec la classe File:

 
Sélectionnez

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:

 
Sélectionnez

SW.WriteLine ("Bonjour")

SW.WriteLine ("Monsieur")

Enfin on ferme:

 
Sélectionnez

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:

 
Sélectionnez

Dim SR As New StreamReader ("MonFichier.txt")

Avec la Classe File:

 
Sélectionnez

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:

 
Sélectionnez

Do Until SR.Peek=-1

     Ligne=SR.ReadLine()

Loop

Enfin on ferme:

 
Sélectionnez

SR.Close()

précédentsommairesuivant

Vous avez aimé ce tutoriel ? Alors partagez-le en cliquant sur les boutons suivants : Viadeo Twitter Facebook Share on Google+   

  

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. 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'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.