Refactorisation des boucles

Fait partie de la section Logique & Flux du Journey C# de Coddy — leçon 16 sur 66.

Refactoriser les boucles peut améliorer la lisibilité et la maintenabilité du code.

Remplacez la boucle traditionnelle par foreach pour plus de simplicité :

string[] fruits = { "apple", "banana", "cherry" };

// Avant la refactorisation
for (int i = 0; i < fruits.Length; i++)
{
    Console.WriteLine(fruits[i]);
}

// Après la refactorisation
foreach (string fruit in fruits)
{
    Console.WriteLine(fruit);
}

Extraire la logique de boucle complexe dans des méthodes :

int[] numbers = { 1, 2, 3, 4, 5, 6, };

// Avant la refactorisation
for (int i = 0; i < numbers.Length; i++)
{
    if (numbers[i] % 2 == 0)
    {
        Console.WriteLine($"{numbers[i]} is even");
    }
}

// Après refactorisation avec méthode auxiliaire
for (int i = 0; i < numbers.Length; i++)
{
    if (IsEven(numbers[i]))
    {
        Console.WriteLine($"{numbers[i]} is even");
    }
}

// Méthode auxiliaire
bool IsEven(int number)
{
    return number % 2 == 0;
}

Divisez les grandes boucles en boucles plus petites et plus ciblées :

int[] data = { 1, 2, 3, 4, 5 };

// Avant : Une grande boucle effectuant plusieurs tâches
for (int i = 0; i < data.Length; i++)
{
    // Traiter les données
    data[i] = data[i] * 2;
    // Afficher les résultats
    Console.WriteLine(data[i]);
}

// Après : Boucles séparées avec des objectifs clairs
// Traiter les données
for (int i = 0; i < data.Length; i++)
{
    data[i] = data[i] * 2;
}

// Afficher les résultats
for (int i = 0; i < data.Length; i++)
{
    Console.WriteLine(data[i]);
}

Défi

Moyen

Créez une méthode appelée refactoredArrayFilter qui :

Prend un tableau d'entiers en paramètre
Implémente deux versions de code qui comptent les nombres divisibles par 3 :
- Original : Utilisez une boucle for traditionnelle avec une instruction if
- Refactorisé : Utilisez une boucle foreach avec la logique extraite vers une méthode d'aide
Retourne le compte de la version refactorisée sous forme d'entier

Par exemple, donné le tableau [3, 4, 6, 7, 9], la méthode devrait retourner 3 car il y a trois nombres (3, 6 et 9) qui sont divisibles par 3.

Note : Vous n'avez pas besoin d'imprimer quoi que ce soit - retournez simplement le compte sous forme d'entier.

Aide-mémoire

Utilisez foreach au lieu des boucles for traditionnelles pour une itération de tableau plus simple :

// Traditional for loop
for (int i = 0; i < fruits.Length; i++)
{
    Console.WriteLine(fruits[i]);
}

// Refactored with foreach
foreach (string fruit in fruits)
{
    Console.WriteLine(fruit);
}

Extrayez la logique de boucle complexe dans des méthodes d'aide :

// Before refactoring
if (numbers[i] % 2 == 0)
{
    Console.WriteLine($"{numbers[i]} is even");
}

// After refactoring with helper method
if (IsEven(numbers[i]))
{
    Console.WriteLine($"{numbers[i]} is even");
}

// Helper method
bool IsEven(int number)
{
    return number % 2 == 0;
}

Découpez les grandes boucles en boucles plus petites, focalisées, avec des responsabilités uniques :

// Before: One loop doing multiple things
for (int i = 0; i < data.Length; i++)
{
    data[i] = data[i] * 2;  // Process
    Console.WriteLine(data[i]);  // Print
}

// After: Separate loops with clear purposes
for (int i = 0; i < data.Length; i++)
{
    data[i] = data[i] * 2;  // Process only
}

for (int i = 0; i < data.Length; i++)
{
    Console.WriteLine(data[i]);  // Print only
}

Essayez vous-même

public class RefactorArrayFilter
{
    // Implémentez la méthode refactorArrayFilter
    public static int refactorArrayFilter(int[] numbers)
    {
        // Écrivez votre code ici
        
    }
    
    // Implémentez toute méthode auxiliaire dont vous avez besoin
}

Testez-vous

Cette leçon comprend un petit quiz. Commencez la leçon pour y répondre et suivre votre progression.

Toutes les leçons de Logique & Flux

3Améliorations des boucles

Performance des boucles Itération de structures complexes Chaque type de boucleRefactorisation des bouclesRécapitulatif - Boucles optimisées

6Gestion des valeurs nulles

Les bases des références nulles Types valeur nullables Patterns de vérification de nullité Programmation défensive Récapitulatif - Null Safety

9HashMap Partie 1

Qu'est-ce qu'un HashMap ?Déclarer un HashMap Vérifier si une clé existe Accéder aux valeurs Modifier des dictionnaires Récapitulatif - HashMap

12HashSet Partie 2

Maths - Union de HashSets Maths - Intersection de HashSets Maths - Différence d'ensembles Maths - Différence symétrique Itération sur les ensembles