Apprenez à programmer en C#

Dites bonjour au monde entier

Comme la vidéo l'a expliqué, une fonction peut être considérée comme un bloc de code ayant un nom, et qui exécute un service. Pour ce qui est de la fonction  Main  , le service effectué est en fait le programme lui-même ! Plutôt cool, non ? Lorsqu'une fonction est située à l'intérieur d'une classe, elle s'appelle une méthode. En C#, puisque tout le code est situé à l'intérieur de classes, vous pouvez utiliser les deux termes (fonctions et méthodes) de manière interchangeable.  😎

Maintenant que vous connaissez la fonction  Main  et que vous savez comment démarrer un programme, il est temps d'écrire votre premier programme ! Traditionnellement, lorsque l'on apprend un langage pour écrire son premier programme, on cherche à afficher la chaîne de caractères Hello World! (Bonjour le monde, en français).

Découvrons le code C# qui rend honneur à cette tradition :

using System;

namespace Hello
    {
    /// <summary>
    /// Ceci est une implémentation du message traditionnel « Hello world! »
    /// </summary>
    /// <remarks>Créée par l'équipe éducative d'OpenClassrooms</remarks>
    public class HelloWorld
    {
        /// <summary>
        /// Le programme commence ici
        /// </summary>
        public static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");
        }
    }
}

Décortiquons ce code :

• La première instruction,  using System;  , est une directive using. Elle indique au compilateur les espaces de noms dans lesquels il va trouver les classes que vous utilisez dans votre code. Un espace de noms organise un ensemble connexe de classes C#. L'espace de noms  System  contient des classes fondamentales et des classes de base qui définissent les types de données référence et valeur couramment utilisés, les événements et les gestionnaires d'événements, les interfaces, les attributs et les exceptions.

• La deuxième instruction,  namespace Hello  , correspond à la déclaration d'un espace de noms. Vous pouvez utiliser un même nom d'espace de noms pour tous vos fichiers quand vous écrivez un programme simple. 

• La déclaration  public class HelloWorld  définit le nom de la classe comme étant  HelloWorld  . En C#, l'ensemble du code doit se trouver à l'intérieur d'une classe. Vous serez amené à écrire et à utiliser deux types de classes :

  1. Les classes qui servent de plan pour vos futurs objets, comme vous l'avez vu dans le chapitre Définissez les objets et leurs attributs avec des classes. Elles définissent l'état de l'objet avec des champs et son comportement avec des méthodes.

  2. Les classes utilitaires qui servent de conteneurs pour les opérations que vous voulez effectuer, mais qui n'ont pas besoin d'un état persistant. Ces classes ne contiennent généralement pas de champ.

• Dans la classe se trouve la déclaration de fonction  public static void Main(string[] args)  . C'est ce bout de code que l'interpréteur C# recherche lorsque vous lancez un programme. 

• Dans la méthode  Main  se trouve l'instruction  Console.WriteLine("Hello World!");  , qui affiche le message attendu.

• Pour information, les lignes commençant par les caractères  ///  sont des commentaires de documentation. Elles permettent de créer automatiquement un fichier XML qui peut être transformé en pages Web HTML contenant la documentation de votre code. Elle inclut généralement une liste de classes, de méthodes et de variables, ainsi que des commentaires. Les autres programmeurs peuvent ainsi utiliser votre code sans devoir le lire dans le détail. Pratique, n'est-ce pas ? Pour l'instant, vous savez simplement reconnaître ce que font ces lignes, mais nous y reviendrons à la fin du chapitre. 😇

En résumé, le code de démarrage d'un programme C# est contenu dans une fonction (ou méthode) nommée Main. Cette fonction est elle-même contenue dans une classe. Enfin, cette classe appartient à un espace de noms.

Maintenant que vous savez écrire du code, il est temps de l'exécuter !

Exécutez votre programme

En C#, les développeurs ont pour habitude de créer une structure de fichiers qui correspond aux espaces de noms et aux classes. Dit plus simplement, pour exécuter votre programme, créez des dossiers qui correspondent aux espaces de noms, et des fichiers qui correspondent aux classes ! Pour le moment, nous avons écrit notre code Hello World! dans la méthode Main d'une classe HelloWorld, dans un espace de noms nommé Hello. Voyons maintenant comment créer la structure de fichiers et dossiers correspondante.

Voici les étapes principales :

1. Tout d'abord, vous devez créer un dossier dans lequel vous allez mettre tout votre code. C'est ce qu'on appelle généralement le dossier racine.

2. À l'intérieur de ce dossier racine, vous pouvez créer un dossier « Hello », du nom de votre espace de noms.

3. Ensuite, créez un fichier HelloWorld.cs dans ce dossier (nom de votre classe).

Vous voyez comment tout cela s'organise ? Espace de noms = dossier, classe = fichier. ✅ Une fois le fichier HelloWorld.cs créé, vous pouvez saisir votre code C#. Reprenons le code de la section précédente :

using System;

namespace Hello
{
    /// <summary>
    /// Ceci est une implémentation du message traditionnel « Hello world ! »
    /// </summary>
    /// <remarks>Créé par l'équipe éducative d'OpenClassrooms</remarks>
    public class HelloWorld
    {
        /// <summary>
        /// Le programme commence ici
        /// </summary>
        public static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");
        }
    }
}

Une fois tout le code copié dans le fichier, vous devez convertir ce code C# en code exécutable, que l'ordinateur peut comprendre.

Quel que soit le langage de programmation que vous utilisez pour écrire votre code, il doit être traduit en un ensemble d'instructions qu'un ordinateur peut exécuter. C'est ce qu'on appelle le code machine.

Même si le code machine est parfaitement lisible pour les ordinateurs, il serait très difficile à utiliser pour les êtres humains. On peut comparer votre code à une recette de cuisine. Vous pouvez utiliser un langage de tous les jours pour décrire les ingrédients et les étapes à suivre, ou vous pouvez utiliser leur composition chimique et un vocabulaire spécialisé pour décrire les différentes étapes. Cette dernière option pourrait être comprise par certains, mais la plupart d'entre nous ne pourraient pas cuisiner avec de telles instructions. Et même pour ceux qui les comprendraient, le processus serait très long ! Vous ne croyez pas ?

Organisez votre code pour que votre fonction Main soit aussi courte que possible

Le but de votre fonction  Main  est de démarrer votre programme. Si vous y placiez toute la logique de votre programme, votre code serait difficilement compréhensible, et sa maintenance deviendrait rapidement compliquée. C'est la raison pour laquelle vous devez organiser votre code en classes.

Comme nous l'avons dit au début de ce chapitre, il existe deux types de classes que vous pouvez écrire et utiliser.

Utilisez des classes en tant que plans

Nous l'avons vu dans la première partie de ce cours, vous pouvez définir des types complexes qui regroupent différents attributs représentant un concept nommé. Ce sont des classes de plans. Elles servent à modéliser le domaine de votre application : ce pour quoi vous écrivez votre programme.

La classe  String  que vous utilisez pour stocker et manipuler les chaînes de caractères dans votre programme en est un exemple. Cette classe est disponible dans l'espace de noms  System  , qui est accessible à partir de n'importe quelle partie de votre code.

Vous pouvez également utiliser l'alias  string  en lieu et place de  String  pour faire référence à un objet. Si vous souhaitez faire référence expressément à la classe, utilisez  String  .

String  est une classe non seulement parce que son nom commence par une lettre majuscule, mais aussi parce qu'elle définit un état et un comportement :

1. Son état est la chaîne de caractères que vous stockez. La valeur réelle est définie pour chaque objet lorsque vous l'instanciez.

2. Son comportement est l'ensemble des méthodes que la classe  String  définit, et qui vous permettent de manipuler la chaîne que vous stockez.

Voyons cela en action :

using System;

namespace DemoString
{
    public class DemoString
    {
        public static void Main(string[] args)
        {
            // Déclarer et créer une chaîne de caractères
            string phraseChoc = "Le type String de C# est en fait une classe, pas un type simple !";
            
            // La crier
            Console.WriteLine(phraseChoc.ToUpper()) ;
            
            // Remplacer un mot par un autre
            Console.WriteLine(phraseChoc.Replace("simple","primitif"));
        }
    }
}

La classe  List  est une autre classe de plan que nous avons déjà abordée. Elle offre toutes les fonctionnalités dont vous avez besoin pour gérer une liste. Vous devez instancier un nouvel objet pour chaque liste de votre programme. Chaque objet contiendra sa propre liste.

Voyons maintenant le deuxième type de classes que vous allez définir et utiliser : les classes utilitaires.

Utilisez des classes utilitaires

Vous avez déjà utilisé la classe  System  . Vous vous en souvenez ? Nous l'avons utilisée pour afficher une chaîne de caractères !

Décortiquons l'instruction de notre premier programme :

Console.WriteLine("Hello World!")

1. Console  est le nom d'une classe.

2. WriteLine  est une méthode statique qui affiche du texte sur une console, et passe à une nouvelle ligne.

La méthode  WriteLine  est « statique », ce qui signifie que vous n'avez pas besoin d'instancier un objet pour l'utiliser. C'est pour cela que vous pouvez appeler la méthode directement sur la classe  System  .

La classe  Math  est un autre exemple de classe utilitaire.

La classe Math définit les opérations courantes que vous pouvez effectuer sur les nombres. Par exemple,  Math.Abs(-4); donne la valeur absolue de la valeur fournie,4 dans ce cas.

Les méthodes statiques définies dans les classes utilitaires sont utiles, car elles vous permettent d'extraire une fonctionnalité dans un bloc de code réutilisable. Vous pouvez ensuite les utiliser sans avoir à instancier un objet. Vous l'avez compris, rien ne justifie une fonctionMain à rallonge !

Épurez votre fonction Main

Pour boucler ce chapitre, voyons comment appliquer un concept fondamental pour rendre votre code compréhensible et maintenable : ne rien garder dans votre fonction Main qui puisse être extrait vers une fonction. Même si votre implémentation actuelle consiste en une seule instruction, vous devez la remplacer par un appel à une méthode qui accomplit elle-même l'action. Si vous décidez d'ajouter de la complexité, elle sera déplacée vers d'autres méthodes, en conservant une fonction  Main  propre et nette.

Reprenons votre fonction  Main  et épurons-la au maximum. Voici une implémentation épurée de notre programme HelloWorld :

using System;

namespace HelloPropre
{
    /// <summary>
    /// Voici une implémentation propre du message traditionnel « Hello world ! ».
    /// </summary>
    /// <remarks>L'équipe éducative d'OpenClassrooms</remarks>
    public class WorldPropre
    {
        /// <summary>
        /// Le programme commence ici
        /// </summary>
        public static void Main(string[] args)
        {
            DireBonjour("World");
        }
        
        /// <summary>
        /// Afficher le message de salutation au destinataire qui a été renseigné
        /// </summary>
        /// <param name="recipient">À qui dire bonjour</param>
        private static void DireBonjour(string destinataire)
        {
            Console.WriteLine("Hello " + destinataire+ "!");
        }
    }
}

Comme vous pouvez le voir, la classe  WorldPropre  définit deux méthodes :

1. Main  est le point d’entrée du programme. Elle a uniquement pour rôle de transmettre la tâche à la méthode  DireBonjour  avec l'argument dont elle a besoin. Dans notre cas, c'est le destinataire prédéfini de notre bonjour : World !

2. La méthode  DireBonjour  affiche la chaîne « Hello » et ajoute la valeur fournie à la variable  destinataire  lorsqu'elle est appelée par la méthode  Main  .

En termes de fonctionnalité, rien n'a changé. Cependant, vous pouvez maintenant ajouter plus de logique au message que vous allez afficher, en changeant la méthode  DireBonjour  et en personnalisant le nom du destinataire.

Nous allons ajouter des fonctionnalités dans les chapitres suivants ! Pour cela, vous devez ajouter plus de logique à votre boîte à outils de programmation C#. Le chapitre suivant traite du premier de ces outils : les conditions !

En résumé 

Dans ce chapitre, vous avez vu les points suivants :

• Les programmes en C# sont structurés en espaces de noms et en classes.

• Aucun code n'est écrit en dehors d'une classe, ce qui signifie que toutes les fonctions sont des méthodes en C#.

• Il est courant de faire correspondre les espaces de noms aux dossiers et les classes aux fichiers.

• Il existe deux types de classes :

  • Les classes de plan, qui sont utilisées comme plans pour l'instanciation des objets.

  • Les classes utilitaires, qui contiennent des méthodes statiques pouvant être appelées directement sur la classe.

• Pour qu'un code soit épuré, aucune logique ne doit apparaître à l'intérieur de la méthode  Main  . Tout le travail doit être délégué à des fonctions nommées de manière appropriée.