Vorgehensweise: Konvertieren einer Zeichenfolge in eine Zahl (C#-Programmierleitfaden)How to convert a string to a number (C# Programming Guide)

Sie können eine Zeichenfolge in eine Zahl umwandeln, indem Sie die Methode Parse oder TryParse in den verschiedenen numerischen Typen (int, long, double usw.) oder Methoden in der System.Convert-Klasse aufrufen.You can convert a string to a number by calling the Parse or TryParse method found on the various numeric types (int, long, double, etc.), or by using methods in the System.Convert class.

Bei einer Zeichenfolge ist es etwas effizienter und einfacher, eine TryParse-Methode (beispielsweise int.TryParse("11", out number)) oder eine Parse-Methode (beispielsweise var number = int.Parse("11")) aufzurufen.If you have a string, it is slightly more efficient and straightforward to call a TryParse method (for example, int.TryParse("11", out number)) or Parse method (for example, var number = int.Parse("11")). Die Verwendung einer Convert-Methode eignet sich eher für allgemeine Objekte, die IConvertible implementieren.Using a Convert method is more useful for general objects that implement IConvertible.

Sie können die Methode Parse oder TryParse für den numerischen Typ verwenden, den Sie in der Zeichenfolge erwarten, beispielsweise den System.Int32-Typ.You can use Parse or TryParse methods on the numeric type you expect the string contains, such as the System.Int32 type. Die Convert.ToInt32-Methode verwendet Parse intern.The Convert.ToInt32 method uses Parse internally. Die Parse-Methode gibt die konvertierte Zahl zurück, und die TryParse-Methode gibt einen Boolean-Wert zurück, der angibt, ob die Konvertierung erfolgreich war. Anschließend wird die konvertierte Zahl in einem out-Parameter zurückgegeben.The Parse method returns the converted number; the TryParse method returns a Boolean value that indicates whether the conversion succeeded, and returns the converted number in an out parameter. Wenn die Zeichenfolge in keinem gültigen Format vorliegt, löst Parse eine Ausnahme aus, während TryParse``false zurückgibt.If the string is not in a valid format, Parse throws an exception, whereas TryParse returns false. Beim Aufrufen einer Parse-Methode sollten Sie grundsätzlich die Ausnahmebehandlung zum Abfangen einer FormatException verwenden, falls beim Analysevorgang ein Fehler auftritt.When calling a Parse method, you should always use exception handling to catch a FormatException in the event that the parse operation fails.

Aufrufen der Methoden „Parse“ und „TryParse“Calling the Parse and TryParse methods

Die Methoden Parse und TryParse ignorieren Leerraum am Anfang und am Ende der Zeichenfolge. Alle anderen Zeichen müssen jedoch Zeichen sein, die den entsprechenden numerischen Typ bilden (int, long, ulong, float, decimal usw.).The Parse and TryParse methods ignore white space at the beginning and at the end of the string, but all other characters must be characters that form the appropriate numeric type (int, long, ulong, float, decimal, etc.). Leerraum innerhalb der Zeichenfolge, die die Zahl bildet, führt zu einem Fehler.Any white space within the string that forms the number causes an error. Beispielsweise können Sie decimal.TryParse verwenden, um „10“, „10.3“ oder „ 10 “ zu analysieren. Sie können diese Methode jedoch nicht verwenden, um 10 aus „10X“, „1 0“ (beachten Sie das eingebettete Leerzeichen), „10 .3“ (beachten Sie das eingebettete Leerzeichen), „10e1“ (float.TryParse funktioniert in diesem Fall) usw. zu analysieren.For example, you can use decimal.TryParse to parse "10", "10.3", or " 10 ", but you cannot use this method to parse 10 from "10X", "1 0" (note the embedded space), "10 .3" (note the embedded space), "10e1" (float.TryParse works here), and so on. Darüber hinaus kann eine Zeichenfolge, deren Wert null oder String.Empty lautet, nicht erfolgreich analysiert werden.In addition, a string whose value is null or String.Empty fails to parse successfully. Durch Aufruf der String.IsNullOrEmpty-Methode können Sie auf eine NULL-Zeichenfolge oder eine leere Zeichenfolge prüfen, bevor Sie den Analyseversuch starten.You can check for a null or empty string before attempting to parse it by calling the String.IsNullOrEmpty method.

Das folgende Beispiel zeigt sowohl erfolgreiche als auch nicht erfolgreiche Aufrufe von Parse und TryParse.The following example demonstrates both successful and unsuccessful calls to Parse and TryParse.

using System;

public class StringConversion
{
    public static void Main()
    {
       string input = String.Empty;
       try
       {
           int result = Int32.Parse(input);
           Console.WriteLine(result);
       }
       catch (FormatException)
       {
           Console.WriteLine($"Unable to parse '{input}'");
       }
       // Output: Unable to parse ''

       try
       {
            int numVal = Int32.Parse("-105");
            Console.WriteLine(numVal);
       }
       catch (FormatException e)
       {
           Console.WriteLine(e.Message);
       }
       // Output: -105

        if (Int32.TryParse("-105", out int j))
            Console.WriteLine(j);
        else
            Console.WriteLine("String could not be parsed.");
        // Output: -105

        try
        {
            int m = Int32.Parse("abc");
        }
        catch (FormatException e)
        {
            Console.WriteLine(e.Message);
        }
        // Output: Input string was not in a correct format.

        string inputString = "abc";
        if (Int32.TryParse(inputString, out int numValue))
            Console.WriteLine(inputString);
        else
            Console.WriteLine($"Int32.TryParse could not parse '{inputString}' to an int.");
        // Output: Int32.TryParse could not parse 'abc' to an int.
     }
}

Das folgende Beispiel veranschaulicht einen Ansatz zum Analysieren einer Zeichenfolge, die führende numerische Zeichen (einschließlich Hexadezimalzeichen) und nachstehende nicht numerische Zeichen enthalten soll.The following example illustrates one a approach to parsing a string that is expected to include leading numeric characters (including hexadecimal characters) and trailing non-numeric characters. Vor dem Aufruf der TryParse-Methode werden gültige Zeichen vom Anfang einer Zeichenfolge einer neuen Zeichenfolge zugewiesen.It assigns valid characters from the beginning of a string to a new string before calling the TryParse method. Da die zu analysierenden Zeichenfolgen eine geringe Anzahl von Zeichen enthalten, wird im Beispiel zu diesem Zweck die String.Concat-Methode aufgerufen.Because the strings to be parsed contain a small number of characters, the example calls the String.Concat method to assign valid characters to a new string. Für eine umfangreichere Zeichenfolge kann stattdessen die StringBuilder-Klasse verwendet werden.For a larger string, the StringBuilder class can be used instead.

using System;

public class StringConversion
{
    public static void Main()
    {
        var str = "  10FFxxx";
        string numericString = String.Empty;
        foreach (var c in str)
        {
            // Check for numeric characters (hex in this case) or leading or trailing spaces.
            if ((c >= '0' && c <= '9') || (Char.ToUpperInvariant(c) >= 'A' && Char.ToUpperInvariant(c) <= 'F') || c == ' ') {
                numericString = String.Concat(numericString, c.ToString());
            }
            else
            {
                break;
            }
        }
        if (int.TryParse(numericString, System.Globalization.NumberStyles.HexNumber, null, out int i))
            Console.WriteLine($"'{str}' --> '{numericString}' --> {i}");
            // Output: '  10FFxxx' --> '  10FF' --> 4351

        str = "   -10FFXXX";
        numericString = "";
        foreach (char c in str) {
            // Check for numeric characters (0-9), a negative sign, or leading or trailing spaces.
            if ((c >= '0' && c <= '9') || c == ' ' || c == '-')
            {
                numericString = String.Concat(numericString, c);
            } else
            {
                break;
            }
        }
        if (int.TryParse(numericString, out int j))
            Console.WriteLine($"'{str}' --> '{numericString}' --> {j}");
            // Output: '   -10FFXXX' --> '   -10' --> -10
    }
}

Aufrufen der Convert-MethodenCalling the Convert methods

In der folgenden Tabelle werden einige der Methoden aus der Convert-Klasse aufgelistet, die Sie zum Konvertieren einer Zeichenfolge in eine Zahl verwenden können.The following table lists some of the methods from the Convert class that you can use to convert a string to a number.

Numerischer TypNumeric Type MethodeMethod
decimal ToDecimal(String)
float ToSingle(String)
double ToDouble(String)
short ToInt16(String)
int ToInt32(String)
long ToInt64(String)
ushort ToUInt16(String)
uint ToUInt32(String)
ulong ToUInt64(String)

In diesem Beispiel wird die Convert.ToInt32(String)-Methode aufgerufen, um eine Eingabezeichenfolge in einen int-Typ zu konvertieren. Das Beispiel fängt die zwei häufigsten Ausnahmen ab, die von dieser Methode ausgelöst werden können: FormatException und OverflowException.The following example calls the Convert.ToInt32(String) method to convert an input string to an int. The example catches the two most common exceptions that can be thrown by this method, FormatException and OverflowException. Wenn die resultierende Zahl schrittweise erhöht werden kann, ohne Int32.MaxValue zu überschreiten, fügt der Beispielcode dem Ergebnis 1 hinzu und zeigt die Ausgabe an.If the resulting number can be incremented without exceeding Int32.MaxValue, the example adds 1 to the result and displays the output.

using System;

public class ConvertStringExample1
{
    static void Main(string[] args)
    {
        int numVal = -1;
        bool repeat = true;

        while (repeat)
        {
            Console.Write("Enter a number between −2,147,483,648 and +2,147,483,647 (inclusive): ");

            string input = Console.ReadLine();

            // ToInt32 can throw FormatException or OverflowException.
            try
            {
                numVal = Convert.ToInt32(input);
                if (numVal < Int32.MaxValue)
                {
                    Console.WriteLine("The new value is {0}", ++numVal);
                }
                else
                {
                    Console.WriteLine("numVal cannot be incremented beyond its current value");
                }
           }
            catch (FormatException)
            {
                Console.WriteLine("Input string is not a sequence of digits.");
            }
            catch (OverflowException)
            {
                Console.WriteLine("The number cannot fit in an Int32.");
            }

            Console.Write("Go again? Y/N: ");
            string go = Console.ReadLine();
            if (go.ToUpper() != "Y")
            {
                repeat = false;
            }
        }
    }
}
// Sample Output:
//   Enter a number between -2,147,483,648 and +2,147,483,647 (inclusive): 473
//   The new value is 474
//   Go again? Y/N: y
//   Enter a number between -2,147,483,648 and +2,147,483,647 (inclusive): 2147483647
//   numVal cannot be incremented beyond its current value
//   Go again? Y/N: y
//   Enter a number between -2,147,483,648 and +2,147,483,647 (inclusive): -1000
//   The new value is -999
//   Go again? Y/N: n

Siehe auchSee also