http://www.c2i.

fr

LES MANIPULATIONS DE CHAÎNES EN VB.NET

Il existe une bonne trentaine de "fonctions" de manipulations de chaînes.
Comme tout est objet, ce sont en réalité des membres de la classe ‘Microsoft.VisualBasic.Strings’
En recherchant l’expression "membres de la bibliothèque runtime visual-basic" on peut avoir un aperçu de l’ensemble des
classes mises à disposition par l’espace de noms qui est inclus systématiquement dans les projets VB.NET.

En faisant un copier-coller de la portion concernant les ‘strings’ dans Excel, on pourra obtenir l’aide de chaque fonctionnalité
(méthode, propriétés ) dans des instances indépendantes d’Internet explorer.

La plupart de ces membres ont leur équivalent dans les membres des classes proposées par le framework ( system.string ).
On commence à trouver ça et là des articles qui vantent les mérites de certaines classes par rapport à d’autres en termes de
rapidité d’exécution.
Personnellement je suis partagé entre l’utilisation simple des "fonctions" qui viennent directement des versions antérieures de
VB et l’utilisation des classes du framework qui représentent un dénominateur commun entre les différents langages ( C#,
J#…) et donc une certaine ouverture.
Comme il faut bien privilégier une approche, dans la mesure du possible on essayera d’utiliser les classes du framework, à
moins de ne pas trouver la correspondance ( fonction VB/Classe .NET ).

Par Dominique Nuvoloni

 http://www.c2i.fr

A l’instar de certaine classes fournies par le « framework .net », la classe string offre plusieurs membres partagés :

Cela signifie qu’il n’est pas nécessaire d’avoir une instance de la classe string ( donc un objet ) pour avoir le droit d’utiliser
certains de ses services.
Voici quelques exemples à tester ( projet vide/Ajout d’une classe ):

Imports System.Diagnostics
Public Class TestString
Shared Sub main()
'L'espace de nom Microsoft.VisualBasic est systématiquement inclus ds le prj VB
'Debug.WriteLine(Microsoft.VisualBasic.StrDup(50, "=")) s'écrit donc:
Debug.WriteLine(StrDup(100, "="))

'Correspond à une chaîne vide

Debug.WriteLine("String.Empty:" & String.Empty)

'Si la comparaison est OK renvoie 0 ...

Debug.WriteLine("String.Compare:" & String.Compare("B", "b", True))
Debug.WriteLine("String.Compare:" & String.Compare("B", "A", True))
Debug.WriteLine("String.Compare:" & String.Compare("A", "B", True))

'Concaténation
Debug.WriteLine("String.Concat:" & String.Concat("Comment vas-tu", "Yau de poele"))

'Renvoi un objet chaine initialisé

Debug.WriteLine("String.Copy:" & String.Copy("Je pense donc je suis"))

'Jouons un peu...
Debug.WriteLine("Combinaison...:" & String.Compare(String.Copy(""), String.Empty))

'Les 2 string ont ils ( objet ) la même valeur ?

Debug.WriteLine("String.Equals:" & String.Equals("A", "A"))
Debug.WriteLine("String.Equals:" & String.Equals("A", "B"))

'Voir "Chaînes de format numériques" dans l'aide

Debug.WriteLine("String.Format:" & String.Format("Le {0:M} j'ai gagné {1:C}", Now,
1000))

'Rassembler les différents items d'un tabelau dans une string avec séparateur
Dim aUnTableau As String() = {"Elmnt1", "Elmnt2", "Elmnt3"}
Debug.WriteLine(String.Join(";", aUnTableau))

Debug.WriteLine(StrDup(100, "="))
End Sub
End Class

Par Dominique Nuvoloni

 http://www.c2i.fr

Il existe de nombreuses méthodes permettant de manipuler les chaînes.

Certaines sont plus fréquemment utilisées que d’autres.
Parmi celles-ci, la vedette est sans conteste Substring qui retourne une portion de chaîne prise dans une autre chaîne.

Dim s As String = "123ab456"

Debug.WriteLine("Substring:" & s.Substring(3, 2))

Pour obtenir la longueur d’une chaîne, il faut lui demander ( .length )

Debug.WriteLine("Length:" & s.Length)

On trouvera aussi les méthodes PadLeft et PadRight permettent de justifier ( compléter ) facilement les caractères à gauche
ou à droite sur une certaine longueur.

Debug.WriteLine("PadLeft:" & s.PadLeft(20))

Debug.WriteLine("PadRight:" & s.PadRight(20, "x"))

Quand à la méthode IndexOf, elle permet de savoir si une sous-chaîne est présente dans une chaîne :

Debug.WriteLine("IndexOf:" & s.IndexOf("b4"))

Plus haut nous avons vu la méthode ‘join’, son pendant est ‘Split’ qui rend de grands services, notamment pour extraire des
informations qui seraient passées en argument ( ligne de commande ).

En recherchant dans l’aide « Manipulation de chaînes » on trouvera de nombreux exemples sur les autres méthodes qui
nécessitent un objet ‘String’.
( sur le site http://www.kode-fu.com/rosetta/string_funcs_main.html on trouvera également un tableau intéressant
regroupant les principales fonctions de manipulations de chaîne déclinées en C#, VB.NET,MFC,PYTHON,VB6…)

Mais peut-être avez-vous vu dans la documentation sur la classe ‘String’ que celle-ci « représente une série de caractères
immuable » ; c’est à dire qu’elle est constante.
Pourtant rien ne nous empêche de modifier des chaînes.
En réalité, la cuisine interne .NET copie le contenu de la chaîne, puis détruit sa référence avant d’en créer une nouvelle.
Personnellement, du moment que les cuisines sont propres, j’aime autant diner dans la salle. Le problème c’est que le service
peut devenir extrêmement lent si il y a trop de monde.
Heureusement, il existe un objet ‘StringBuilder’ qui optimise la gestion des chaînes.
Si nous avons la curiosité de tester les performances, le résultat est édifiant.

Dans l’exemple qui suit, nous allons concaténer une chaîne 30000 fois ( augmentez ce nombre si vous avez la chance d’avoir
une machine performante ) et noter le temps pris pour cette action grâce à la propriété ‘Environment. TickCount’ dont l’unité
de temps est la millisecondes ( La classe Environmemt est celle qui vous permettra de savoir si des paramètres ont été
passés à la ligne de commande, quel est le nom de la machine etc. ).
Puis nous renouvelons l’opération avec l’objet ‘stringBuilder’.

Par Dominique Nuvoloni

 http://www.c2i.fr

TextBox2.Refresh permet de
voir le résultat avant que la
deuxième boucle n’ai terminé

Imports System
Imports System.Environment
Imports System.Diagnostics

Public Class Form1

Inherits System.Windows.Forms.Form

( + #Region " Code généré par le Concepteur Windows Form " )

Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As 

System.EventArgs) Handles Button1.Click
Dim tLoop As Integer
Dim i As Integer

Dim s2 As New System.Text.StringBuilder()

tLoop = TickCount
For i = 1 To 30000
s2.Append("a")
Next
tLoop = (TickCount - tLoop) / 1000
TextBox2.Text += tLoop.ToString & " secondes " & s2.Length & vbCrLf
TextBox2.Refresh()

Dim s1 As String
tLoop = TickCount
For i = 1 To 30000
s1 = s1 & "a"
Next
tLoop = (TickCount - tLoop) / 1000
TextBox1.Text += tLoop.ToString & " secondes " & s1.Length & vbCrLf

End Sub
End Class

Par Dominique Nuvoloni