Exercice - Générer du code avec des méthodes

10 minutes

Les méthodes sont utiles pour organiser le code, réutiliser le code et résoudre efficacement les problèmes. Vous pouvez considérer une méthode comme une boîte noire qui accepte une entrée, exécute la tâche nommée et retourne un sortie. Partant de ce principe, vous pouvez rapidement structurer des programmes simplement en nommant vos tâches en tant que méthodes, puis en remplissant la logique une fois que vous avez identifié toutes les tâches nécessaires.

Lorsque vous utilisez un langage simple pour décrire les étapes du code, sans respecter strictement les règles de syntaxe, vous utilisez du « pseudo-code ». La combinaison de méthodes et de pseudo-code est un excellent moyen d’effectuer rapidement toute tâche de programmation délicate.

Utiliser des méthodes pour structurer le code

Supposez que vous passez un entretien technique. Le recruteur souhaite que vous écriviez un programme qui vérifie si une adresse IPv4 est valide ou non. Les règles suivantes vous sont fournies :

Une adresse IPv4 valide se compose de quatre nombres séparés par des points
Chaque nombre ne doit pas contenir de zéros non significatifs
Chaque nombre doit être compris entre 0 et 255

1.1.1.1 et 255.255.255.255 sont des exemples d’adresses IP valides.

L’adresse IPv4 est fournie sous forme de chaîne. Vous pouvez partir du principe qu’elle se compose uniquement de chiffres et de points (il n’y a aucune lettre dans la chaîne fournie).

Comment aborderiez-vous cette tâche ?

Notes

Même si vous n’avez pas une connaissance approfondie des adresses IP, ne vous inquiétez pas ! Vous pouvez toujours rédiger le code de cet exercice en suivant les étapes.

Décomposer le problème

Dans cette tâche, vous allez identifier les étapes nécessaires pour résoudre le problème. Si vous examinez attentivement les règles, vous constaterez peut-être qu’il suffit de trois étapes pour déterminer si une adresse IPv4 est valide ou non.

Dans l’éditeur de Visual Studio Code, supprimez tout code existant des exercices précédents.
Entrez le pseudo-code suivant dans l’éditeur :
```
/*
if ipAddress consists of 4 numbers
and
if each ipAddress number has no leading zeroes
and
if each ipAddress number is in range 0 - 255

then ipAddress is valid

else ipAddress is invalid
*/
```
Le pseudo-code est un excellent moyen de commencer à résoudre n’importe quel problème. À l’aide de ce bloc de commentaires, vous établissez un pont entre les règles de départ et le code du programme, en clarifiant les principales tâches que votre code effectuera. Le pseudo-code n’a pas besoin d’être fonctionnel ou d’adhérer à des règles de syntaxe, mais il doit être une explication claire de ce que le code va faire. Transformons-le en code réel.
Entrez une nouvelle ligne de code vide, puis tapez le code suivant dans l’éditeur :
```
if (ValidateLength() && ValidateZeroes() && ValidateRange()) 
{
    Console.WriteLine($"ip is a valid IPv4 address");
} 
else 
{
    Console.WriteLine($"ip is an invalid IPv4 address");
}
```
Lors de cette étape, vous transformez les instructions if de votre pseudo-code en méthodes pouvant être appelées, et vous générez les résultats. Ne vous souciez pas encore de la définition des méthodes ; vous pouvez partir du principe que chaque méthode effectue la tâche décrite par son nom. Vous corrigerez les erreurs de compilation et créerez la logique de méthode bientôt, mais pour l’instant vous allez vous concentrer sur la vue d’ensemble. Lorsque vous commencez à travailler sur un nouveau programme, le fait de vous concentrer sur la conception globale vous permet de rester organisé et de développer votre application plus rapidement.
Entrez une nouvelle ligne de code vide sous le code existant, puis tapez le code suivant dans l’éditeur :
```
void ValidateLength() {}
void ValidateZeroes() {}
void ValidateRange() {}
```
Notez comment l’utilisation de méthodes d’espace réservé vous a permis d’aborder rapidement le problème et de structurer votre code pour développer la solution. Maintenant qu’un plan structuré est en place, vous pouvez continuer à résoudre le problème en remplissant le code morceau par morceau.

Développer votre solution

Maintenant que vous disposez de toutes les méthodes d’espace réservé nécessaires pour résoudre le problème, vous pouvez commencer à vous concentrer sur les détails de votre solution. N’oubliez pas que le format d’entrée de l’adresse IPv4 sera une chaîne composée de chiffres séparés par des points. Commençons !

Au début de votre programme, créez des variables pour stocker les états d’entrée et de validation :

string ipv4Input = "107.31.1.5";
bool validLength = false;
bool validZeroes = false;
bool validRange = false;

Mettez à jour votre code de solution de façon à utiliser les variables de validation comme suit :

ValidateLength(); 
ValidateZeroes(); 
ValidateRange();

if (validLength && validZeroes && validRange) 
{
    Console.WriteLine($"ip is a valid IPv4 address");
} 
else
{
    Console.WriteLine($"ip is an invalid IPv4 address");
}

Mettez à jour la méthode ValidateLength comme ceci :
```
void ValidateLength() 
{
    string[] address = ipv4Input.Split(".");
    validLength = address.Length == 4;
};
```
La première règle stipule que l’adresse IPv4 doit comporter quatre nombres. Ainsi, dans ce code, vous utilisez string.Split pour séparer les chiffres et vérifier qu’il y en a quatre.
Mettez à jour la méthode ValidateZeroes comme ceci :
```
void ValidateZeroes() 
{
    string[] address = ipv4Input.Split(".");

    foreach (string number in address) 
    {
        if (number.Length > 1 && number.StartsWith("0")) 
        {
            validZeroes = false;
        }
    }

    validZeroes = true;
}
```
Prenez un moment pour réfléchir à la façon dont la règle se traduit en code.

La deuxième règle stipule que les nombres dans l’adresse IPv4 ne doivent pas contenir de zéros non significatifs. Par conséquent, la méthode doit vérifier la présence de zéros non significatifs dans les nombres, tout en acceptant 0 comme nombre valide. Si tous les nombres ont des zéros valides, validZeroes doit être égal à true, et false sinon. Ainsi, dans ce code, vous vérifiez que chaque nombre comportant plusieurs chiffres ne commence pas par un zéro.

Si vous regardez attentivement, vous remarquerez que validZeroes est défini sur true une fois la boucle foreach terminée. Toutefois, vous ne souhaitez affecter la valeur validZeroes à true que si aucun zéro non significatif n’est trouvé. Vous pourriez corriger ce bogue en définissant validZeroes = true avant l’exécution de la boucle foreach. Toutefois, vous pouvez également corriger ce bogue à l’aide d’une instruction return .
Mettez à jour votre code comme suit :
```
foreach (string number in address) 
{
    if (number.Length > 1 && number.StartsWith("0")) 
    {
        validZeroes = false;
        return;
    }
}
```
L’instruction return met fin à l’exécution de la méthode et retourne le contrôle à l’appelant de méthode. L’ajout d’une instruction return après validZeroes = false met fin à la méthode après la découverte du premier zéro non valide. Si aucun zéro non valide n’est trouvé, la méthode se termine après l’affectation de la valeur validZeroes à true. Passons à la méthode suivante.
Mettez à jour la méthode ValidateRange comme ceci :
```
void ValidateRange() 
{
    string[] address = ipv4Input.Split(".");

    foreach (string number in address) 
    {
        int value = int.Parse(number);
        if (value < 0 || value > 255) 
        {
            validRange = false;
            return;
        }
    }
    validRange = true;
}
```
La troisième règle stipule que chaque nombre de l’adresse IPv4 doit être compris entre 0 et 255. Ainsi, dans ce code, vous vérifiez que chaque nombre est inférieur à 255 et, si ce n’est pas le cas, vous arrêtez l’exécution après avoir affecté la valeur validRange à false. Étant donné que la chaîne d’entrée contient uniquement des chiffres et des points, vous n’avez pas besoin de vérifier la présence de nombres négatifs.

Toutefois, il peut arriver qu’aucun chiffre ne soit présent entre les points. Par exemple, « 255...255 ». Dans ce cas, string.Split(".") retourne des entrées vides, provoquant l’échec de int.Parse. Vous pouvez empêcher cela en spécifiant StringSplitOptions.
Mettez le code à jour comme suit :
```
string[] address = ipv4Input.Split(".", StringSplitOptions.RemoveEmptyEntries);
```
L’utilisation de StringSplitOptions.RemoveEmptyEntries omet les entrées vides du tableau address et empêche toute tentative d’analyse de chaînes vides.

Terminer votre solution

Maintenant que vous avez créé toutes les méthodes pour valider une adresse IP, il est temps de revenir à votre solution initiale. Dans cette tâche, vous allez ajouter d’autres valeurs d’entrée et vous préparer à tester votre code.

Recherchez le code suivant que vous avez écrit dans le programme :
```
string ipv4Input = "107.31.1.5";
```
Mettez à jour le code comme suit :
```
string[] ipv4Input = {"107.31.1.5", "255.0.0.255", "555..0.555", "255...255"};
```
Lors du développement d’une solution, il est important de tester votre code avec différents cas d’entrée. Dans ce code, vous fournissez une plage décente de valeurs de test. Maintenant que vous avez mis à jour votre entrée de test, vous devez mettre à jour votre code de façon à utiliser les nouvelles valeurs. Étant donné que les valeurs se trouvent dans un tableau, vous devez mettre à jour votre code afin de tester chacune d’elles à l’aide d’une boucle.
Mettez le code à jour comme suit :
```
foreach (string ip in ipv4Input) 
{
    ValidateLength(); 
    ValidateZeroes(); 
    ValidateRange();

    if (validLength && validZeroes && validRange) 
    {
        Console.WriteLine($"{ip} is a valid IPv4 address");
    } 
    else 
    {
        Console.WriteLine($"{ip} is an invalid IPv4 address");
    }
}
```
Pour finir, vous devez corriger les données d’entrée utilisées par chaque méthode, puisque vous avez mis à jour ipv4Input d’une chaîne en un tableau. Étant donné que chaque méthode utilise string.Split, vous pouvez déclarer une variable pour stocker le résultat de string.Split et l’utiliser dans chaque méthode à la place.

Ajoutez une variable pour stocker l’adresse IPv4 actuelle que chaque méthode référencera :

string[] ipv4Input = {"107.31.1.5", "255.0.0.255", "555..0.555", "255...255"};
string[] address;
bool validLength = false;
bool validZeroes = false;
bool validRange = false;

Initialisez address en utilisant string.Split comme suit :

foreach (string ip in ipv4Input) 
{
    address = ip.Split(".", StringSplitOptions.RemoveEmptyEntries);

Supprimez les références à string.Split de chacune des méthodes de validation afin qu’elles utilisent la variable globale address à la place. Par exemple :
```
void ValidateLength() 
{
    validLength = address.Length == 4;
};
```

Vérifier votre travail

Dans cette tâche, vous allez exécuter votre application à partir du Terminal intégré et vérifier que votre code fonctionne correctement. Commençons.

Comparez votre code avec le suivant pour vous assurer qu’il est correct :

string[] ipv4Input = {"107.31.1.5", "255.0.0.255", "555..0.555", "255...255"};
string[] address;
bool validLength = false;
bool validZeroes = false;
bool validRange = false;

foreach (string ip in ipv4Input) 
{
    address = ip.Split(".", StringSplitOptions.RemoveEmptyEntries);

    ValidateLength(); 
    ValidateZeroes(); 
    ValidateRange();

    if (validLength && validZeroes && validRange) 
    {
        Console.WriteLine($"{ip} is a valid IPv4 address");
    } 
    else 
    {
        Console.WriteLine($"{ip} is an invalid IPv4 address");
    }
}

void ValidateLength() 
{
    validLength = address.Length == 4;
};

void ValidateZeroes() 
{
    foreach (string number in address) 
    {
        if (number.Length > 1 && number.StartsWith("0")) 
        {
            validZeroes = false;
            return;
        }
    }

    validZeroes = true;
}

void ValidateRange() 
{
    foreach (string number in address) 
    {
        int value = int.Parse(number);
        if (value < 0 || value > 255) 
        {
            validRange = false;
            return;
        }
    }
    validRange = true;
}

Enregistrez votre travail à l’aide de Ctrl + S ou du menu Fichier Visual Studio Code.
Si nécessaire, ouvrez le volet Terminal intégré de Visual Studio Code.

Dans le panneau EXPLORATEUR, pour ouvrir un terminal à l’emplacement de votre dossier TestProject, cliquez avec le bouton droit sur TestProject, puis sélectionnez Ouvrir dans le terminal intégré.
À l’invite de commandes terminal, entrez dotnet run
Vérifiez que votre code produit la sortie suivante :
```
107.31.1.5 is a valid IPv4 address
255.0.0.255 is a valid IPv4 address
555..0.555 is an invalid IPv4 address
255...255 is an invalid IPv4 address
```
Si votre code affiche des résultats différents, vous devez le passer en revue afin de trouver votre erreur et d’effectuer des mises à jour. Réexécutez le code pour voir si vous avez résolu le problème. Continuez à mettre à jour et à exécuter votre code jusqu’à ce qu’il produise les résultats attendus.

Récapitulatif

Voici ce que vous avez appris sur l’utilisation des méthodes jusqu’à présent :

Les méthodes peuvent être utilisées pour structurer rapidement des applications
Le mot clé return peut être utilisé pour arrêter l’exécution de la méthode
Chaque étape d’un problème peut souvent être traduite en sa propre méthode
Utilisez des méthodes pour résoudre de petits problèmes afin de générer votre solution

Commentaires

Cette page a-t-elle été utile ?