Identificando Números em Strings C# com Eficiência

Validar se uma string representa um número é uma tarefa frequente no desenvolvimento C#. Este artigo explora várias abordagens eficientes, comparando seus pontos fortes e fracos para ajudá-lo a escolher o melhor método para suas necessidades específicas.

Sumário

• Usando Expressões Regulares (Regex.IsMatch())
• Usando Métodos TryParse()
• Usando LINQ (Enumerable.All())
• Verificação Manual Caractere a Caractere (Loop foreach)

Usando Expressões Regulares (Regex.IsMatch())

Expressões regulares oferecem uma solução flexível e poderosa para validar padrões de string. O método Regex.IsMatch() permite que você defina um padrão para comparar com sua string de entrada. Esta abordagem é geralmente eficiente e lida com uma ampla gama de formatos de números.

using System;
using System.Text.RegularExpressions;

public class StringNumberValidator
{
    public static bool IsNumber(string str)
    {
        // Padrão para corresponder a inteiros, números de ponto flutuante (incluindo valores negativos)
        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
    }
}

Você pode ajustar a expressão regular para acomodar formatos de número específicos (por exemplo, apenas inteiros, números com um número limitado de casas decimais). Isso a torna altamente adaptável a vários requisitos.

Usando Métodos TryParse()

Os métodos TryParse() (por exemplo, int.TryParse(), double.TryParse(), decimal.TryParse()) tentam analisar a string em um tipo numérico. Eles retornam true se bem-sucedidos e false caso contrário. Esta é uma abordagem simples e muitas vezes eficiente, especialmente quando você conhece o tipo numérico esperado.

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
    }
}

Escolha o método TryParse() apropriado com base no tipo numérico esperado da sua string de entrada.

Usando LINQ (Enumerable.All())

O Enumerable.All() do LINQ fornece uma maneira concisa de verificar se todos os caracteres em uma string atendem a uma determinada condição. No entanto, esta abordagem é limitada a inteiros positivos sem pontos decimais ou sinais negativos.

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
    }
}

Este método é simples e eficiente para seu escopo limitado, mas carece da versatilidade de outras abordagens.

Verificação Manual Caractere a Caractere (Loop foreach)

Uma abordagem manual oferece o maior controle, mas geralmente é menos eficiente e mais propensa a erros. Você iteraria pela string, verificando cada caractere para garantir que seja um dígito, ponto decimal ou sinal de menos (se permitido) na posição correta.

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
    }
}

Embora isso forneça controle máximo, geralmente é recomendado usar os métodos mais concisos e eficientes discutidos anteriormente, a menos que você tenha requisitos de validação muito específicos.

Em resumo, a abordagem ideal depende de suas necessidades. Regex.IsMatch() oferece uma solução robusta e flexível para a maioria dos cenários, enquanto TryParse() é eficiente para validação simples de inteiros ou ponto flutuante. As abordagens LINQ e de loop manual são menos frequentemente preferidas devido às suas limitações.