Fonctions et méthodes

Relevez vos sièges, attachez vos ceintures, et saisissez à pleines mains votre sac en plastique. Nous entrons dans une zone de turbulences.

Nous avons découvert avec C# ce que sont des objets, par opposition aux variables simples (ou indicées, ou structurées) que nous connaissions en programmation procédurale. Les objets ont cette particularité étonnante de posséder des morceaux de code « pré-embarqué » : les méthodes (je ne parle pas de la possibilité qu'ont certains d'entre eux, en plus, de gérer des événements. Cette faculté ne concerne pas ce chapitre).

Eh bien, une particularité de la programmation objet, c'est que tout finit par devenir un objet, ce qui, au départ, n'en était pas un. Ainsi, mais ce n'est qu'un exemple parmi bien d'autres, les simples variables ordinaires sont considérées par C# comme des instances des classes (assimilées aux types) qui ont servi à les fabriquer. Une variable de type String est donc, pour C#, également une instance de la classe String. Une variable de type Integer est également une instance de la classe Integer, etc.

Par conséquent, les simples variables peuvent, elles aussi, être traitées comme des objets (je dirais même : elles doivent l'être). En particulier, la classe String, la classe Integer, et toutes les autres classes formées à partir des types simples, sont dotées, comme toutes les autres classes, d'un certain nombre de méthodes. Celles-ci ont été conçues de manière à recouvrir à peu près les anciennes fonctions traditionnelles prédéfinies pour ces variables. À partir de là, les concepteurs des langages objet ont suivi deux stratégies différentes :

• Pour ne pas désorienter les programmeurs peu familiers de la programmation objet, certains langages ont fait le choix de conserver, à côté de ces méthodes, la plupart ou la totalité des fonctions traditionnelles. De sorte que dans ces langages, la plupart des outils qui permettent de manipuler les variables ordinaires existent sous deux formes : une fonction « à l'ancienne », et une méthode. C'est ainsi que les choses se passent, par exemple, en VB.Net.
• D'autres langages - et c'est le cas de C# - ont coupé radicalement avec le passé : les fonctions ont disparu, et ne subsistent dorénavant que les méthodes.

Faisons donc un rapide (et non exhaustif) tour du propriétaire.

1. Méthodes de chaînes

On trouve bien sûr en tête de gondole les deux incontournables :

• Substring, qui n'est autre que notre bonne vieille Mid, et qui extrait donc des caractères à partir d'une chaîne. Elle n'emploie que deux arguments : le caractère à partir duquel on souhaite l'extrait, et le nombre de caractère voulus. Attention ! Le comptage des caractères commence à zéro. Ainsi :
  string toto = "J'adore ce langage".Substring(11, 4);
  mettra la suite de caractères "lang" dans toto. À signaler une particularité bien pratique : on peut employer la méthode Substring avec un seul argument. Dans ce cas, il s'agit du premier des deux, et la méthode récupèrera tous les caractères à partir de celui-ci, jusqu'à la fin. L'équivalent d'un Right pour pas cher, et bien pratique pour éviter des calculs fastidieux.
• De même, à la traditionnelle fonction Len(chaîne) qui renvoie le nombre de caractères de la chaîne, correspond dorénavant la méthode Length. Si Phrase est une chaîne et qu'on a besoin de récupérer sa longueur pour la balayer par une boucle, on poura donc écrire :

  for (i=0; i

Il existe bien sûr une floppée d'autre méthodes pour traiter les chaînes. Parmi celles-ci, je signale :

• IndexOf, qui est un équivalent de notre vieux Trouve - une version plus simple, booléenne, de cette méthode, existe avec Contains.
• Insert, pour insérer une chaîne dans une autre à la position voulue.
• Replace, pour remplacer toutes les occurrences d'une chaîne dans une autre chaîne.
• ToLower et ToUpper, pour changer la casse d'une chaîne et la convertir respectivement en minuscules et en majuscules.
• Trim, TrimEnd et TrimStart, qui purgent les espaces sur les bords d'une chaîne (respectivement, au début et à la fin, à la fin, et au début.

Et puis, deux méthodes inattendues, mais qui sont extrêmement pratiques pour gérer la conversion de données vers un fichier texte géré en délimité (C# n'est en revanche pas du tout pratique pour gérer des champs de largeur fixe) :

• Split(caractère) qui éclate la chaîne en un tableau (de chaînes), en fonction du séparateur indiqué par le paramètre caractère. Ceci peut aussi s'avérer pratique pour découper un chemin menant à un fichier, par exemple, et récupérer dans un tableau la liste des répertoires et des sous-répertoires en un tournemain.
• Join(caractère, tableau de chaînes) qui effectue l'opération inverse  : cette méthode assemble une chaîne à partir des chaînes contenues dans le tableau de chaînes passé en paramètre, et en insérant à chaque fois comme séparateur le caractère passé en paramètre.

2. Méthodes de nombres

À côté des chaînes, les nombres semblent faire pâle figure. Une variable déclarée dans un type numérique ne possèdera en effet qu'une quantité ridicule de méthodes accessibles. Mais que les matheux se rassurent, ils n'ont pas été oubliés. Ces méthodes sont en fait regroupées dans une classe appelée math ; c'est là qu'il faut donc aller les chercher, en passant le nombre à traiter en paramètre. Ainsi, pour obtenir la racine carrée de toto, on écrira :

Math.Sqrt(toto)

J'en profite pour signaler que la génération de nombres aléatoires pose une petite difficulté (vite surmontée). Il faut en effet distinguer la série de nombres aléatoires que le programme peut générer, des différents nombres au sein de cette série. Pour bien faire, il faut donc commencer par générer la série, puis ensuite, demander à la machine d'aller y piocher les nombres les uns après les autres.<.p>

La génération d'une série s'effectue via l'instanciation de la classe Random :

Random truc = new Random();

Ensuite, on va chercher le nombre suivant de la série via la méthode Next :

int de = truc.Next(1, 7);

La méthode Next admet donc comme paramètres les bornes du nombre à générer ; la première est inclue, la seconde exclue. On peut également ne l'utiliser qu'un seul paramètre : dans ce cas, il correspond à la borne supérieure, et la borne inférieure est considérée comme valant zéro.