Identification Efficace des Nombres dans les Chaînes C#

Valider si une chaîne de caractères représente un nombre est une tâche fréquente dans le développement C#. Cet article explore plusieurs approches efficaces, en comparant leurs forces et faiblesses pour vous aider à choisir la meilleure méthode en fonction de vos besoins spécifiques.

Table des matières

• Utilisation d’expressions régulières (Regex.IsMatch())
• Utilisation des méthodes TryParse()
• Utilisation de LINQ (Enumerable.All())
• Vérification manuelle caractère par caractère (boucle foreach)

Utilisation d’expressions régulières (Regex.IsMatch())

Les expressions régulières offrent une solution flexible et puissante pour valider les modèles de chaînes de caractères. La méthode Regex.IsMatch() vous permet de définir un motif à comparer à votre chaîne d’entrée. Cette approche est généralement efficace et gère un large éventail de formats de nombres.

using System;
using System.Text.RegularExpressions;

public class StringNumberValidator
{
    public static bool IsNumber(string str)
    {
        // Motif pour les entiers, nombres à virgule flottante (y compris les valeurs négatives)
        return Regex.IsMatch(str, @"^-?d+(.d+)?$"); 
    }

    public static void Main(string[] args)
    {
        Console.WriteLine(IsNumber("123"));     // True
        Console.WriteLine(IsNumber("123.45"));  // True
        Console.WriteLine(IsNumber("-123"));    // True
        Console.WriteLine(IsNumber("-123.45")); // True
        Console.WriteLine(IsNumber("123a"));    // False
        Console.WriteLine(IsNumber(""));        // False
    }
}

Vous pouvez ajuster l’expression régulière pour prendre en compte des formats de nombres spécifiques (par exemple, uniquement des entiers, des nombres avec un nombre limité de décimales). Cela la rend très adaptable à diverses exigences.

Utilisation des méthodes TryParse()

Les méthodes TryParse() (par exemple, int.TryParse(), double.TryParse(), decimal.TryParse()) tentent d’analyser la chaîne en un type numérique. Elles renvoient true en cas de succès et false sinon. Il s’agit d’une approche simple et souvent efficace, surtout lorsque vous connaissez le type numérique attendu.

using System;

public class StringNumberValidator
{
    public static bool IsInteger(string str)
    {
        int number;
        return int.TryParse(str, out number);
    }

    public static bool IsDouble(string str)
    {
        double number;
        return double.TryParse(str, out number);
    }

    public static void Main(string[] args)
    {
        Console.WriteLine(IsInteger("123"));     // True
        Console.WriteLine(IsDouble("123.45"));  // True
        Console.WriteLine(IsInteger("-123"));    // True
        Console.WriteLine(IsInteger("123a"));    // False
        Console.WriteLine(IsInteger(""));        // False
    }
}

Choisissez la méthode TryParse() appropriée en fonction du type numérique attendu de votre chaîne d’entrée.

Utilisation de LINQ (Enumerable.All())

Enumerable.All() de LINQ fournit un moyen concis de vérifier si tous les caractères d’une chaîne répondent à une certaine condition. Cependant, cette approche est limitée aux entiers positifs sans décimales ni signes moins.

using System;
using System.Linq;

public class StringNumberValidator
{
    public static bool IsPositiveInteger(string str)
    {
        return !string.IsNullOrEmpty(str) && str.All(char.IsDigit);
    }

    public static void Main(string[] args)
    {
        Console.WriteLine(IsPositiveInteger("123"));   // True
        Console.WriteLine(IsPositiveInteger("123.45")); // False
        Console.WriteLine(IsPositiveInteger("-123"));  // False
        Console.WriteLine(IsPositiveInteger(""));      // False
    }
}

Cette méthode est simple et efficace pour son champ d’application limité, mais manque de la polyvalence des autres approches.

Vérification manuelle caractère par caractère (boucle foreach)

Une approche manuelle offre un contrôle maximal, mais est généralement moins efficace et plus sujette aux erreurs. Vous itéreriez sur la chaîne, en vérifiant chaque caractère pour vous assurer qu’il s’agit d’un chiffre, d’un point décimal ou d’un signe moins (si autorisé) à la bonne position.

using System;

public class StringNumberValidator
{
    public static bool IsNumberManual(string str)
    {
        if (string.IsNullOrEmpty(str)) return false;

        bool hasDecimal = false;
        bool hasSign = false;

        foreach (char c in str)
        {
            if (c == '-' && !hasSign && str.IndexOf(c) == 0)
            {
                hasSign = true;
                continue;
            }
            if (c == '.')
            {
                if (hasDecimal) return false;
                hasDecimal = true;
                continue;
            }
            if (!char.IsDigit(c)) return false;
        }
        return true;
    }

    public static void Main(string[] args)
    {
        Console.WriteLine(IsNumberManual("123"));     // True
        Console.WriteLine(IsNumberManual("123.45"));  // True
        Console.WriteLine(IsNumberManual("-123"));    // True
        Console.WriteLine(IsNumberManual("-123.45")); // True
        Console.WriteLine(IsNumberManual("123a"));    // False
        Console.WriteLine(IsNumberManual(""));        // False
        Console.WriteLine(IsNumberManual("--123"));   //False
        Console.WriteLine(IsNumberManual("12.3.4"));  //False
    }
}

Bien que cela offre un contrôle maximal, il est généralement recommandé d’utiliser les méthodes plus concises et efficaces décrites précédemment, sauf si vous avez des exigences de validation très spécifiques.

En résumé, l’approche optimale dépend de vos besoins. Regex.IsMatch() offre une solution robuste et flexible pour la plupart des scénarios, tandis que TryParse() est efficace pour la validation simple des entiers ou des nombres à virgule flottante. Les approches LINQ et la boucle manuelle sont moins souvent préférées en raison de leurs limitations.