Effizientes Finden von Zahlen in C#-Strings

Die Überprüfung, ob eine Zeichenkette eine Zahl darstellt, ist eine häufige Aufgabe in der C#-Entwicklung. Dieser Artikel untersucht mehrere effiziente Ansätze und vergleicht deren Stärken und Schwächen, um Ihnen bei der Auswahl der besten Methode für Ihre spezifischen Bedürfnisse zu helfen.

Inhaltsverzeichnis

• Verwendung regulärer Ausdrücke (Regex.IsMatch())
• Verwendung von TryParse()-Methoden
• Verwendung von LINQ (Enumerable.All())
• Manuelle Zeichen-für-Zeichen-Prüfung (foreach-Schleife)

Verwendung regulärer Ausdrücke (Regex.IsMatch())

Reguläre Ausdrücke bieten eine flexible und leistungsstarke Lösung zur Validierung von Zeichenkettenmustern. Die Methode Regex.IsMatch() ermöglicht es Ihnen, ein Muster zu definieren, das mit Ihrer Eingabezeichenkette abgeglichen wird. Dieser Ansatz ist im Allgemeinen effizient und behandelt eine breite Palette von Zahlenformaten.

using System;
using System.Text.RegularExpressions;

public class StringNumberValidator
{
    public static bool IsNumber(string str)
    {
        // Muster für Ganzzahlen, Gleitkommazahlen (einschließlich negativer Werte)
        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
    }
}

Sie können den regulären Ausdruck anpassen, um bestimmte Zahlenformate zu berücksichtigen (z. B. nur Ganzzahlen, Zahlen mit einer begrenzten Anzahl von Dezimalstellen). Dies macht ihn sehr anpassungsfähig an verschiedene Anforderungen.

Verwendung von TryParse()-Methoden

Die TryParse()-Methoden (z. B. int.TryParse(), double.TryParse(), decimal.TryParse()) versuchen, die Zeichenkette in einen numerischen Typ zu analysieren. Sie geben true zurück, wenn dies erfolgreich ist, und andernfalls false. Dies ist ein einfacher und oft effizienter Ansatz, insbesondere wenn Sie den erwarteten numerischen Typ kennen.

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

Wählen Sie die entsprechende TryParse()-Methode basierend auf dem erwarteten numerischen Typ Ihrer Eingabezeichenkette.

Verwendung von LINQ (Enumerable.All())

LINQs Enumerable.All() bietet eine prägnante Möglichkeit zu überprüfen, ob alle Zeichen in einer Zeichenkette eine bestimmte Bedingung erfüllen. Dieser Ansatz ist jedoch auf positive Ganzzahlen ohne Dezimalpunkte oder Minuszeichen beschränkt.

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

Diese Methode ist einfach und effizient für ihren begrenzten Umfang, mangelt aber an der Vielseitigkeit anderer Ansätze.

Manuelle Zeichen-für-Zeichen-Prüfung (foreach-Schleife)

Ein manueller Ansatz bietet die größte Kontrolle, ist aber in der Regel weniger effizient und fehleranfälliger. Sie würden die Zeichenkette durchlaufen und jedes Zeichen überprüfen, um sicherzustellen, dass es sich um eine Ziffer, einen Dezimalpunkt oder ein Minuszeichen (falls zulässig) an der richtigen Position handelt.

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

Obwohl dies maximale Kontrolle bietet, wird im Allgemeinen empfohlen, die oben beschriebenen prägnanteren und effizienteren Methoden zu verwenden, es sei denn, Sie haben sehr spezifische Validierungsanforderungen.

Zusammenfassend lässt sich sagen, dass der optimale Ansatz von Ihren Bedürfnissen abhängt. Regex.IsMatch() bietet eine robuste und flexible Lösung für die meisten Szenarien, während TryParse() für die einfache Validierung von Ganzzahlen oder Gleitkommazahlen effizient ist. Die LINQ- und die manuelle Schleifenmethode werden aufgrund ihrer Einschränkungen seltener bevorzugt.