Megosztás a következőn keresztül:

Sztring átalakítása számmá (C# programozási útmutató)

Számmá alakíthatja a string-t úgy, hogy meghívja a Parse vagy TryParse metódusokat, amelyeket numerikus típusokon találhat (int, long, double stb.), vagy az System.Convert osztály metódusait használja.

Egy TryParse metódus meghívása (például int.TryParse("11", out number)) vagy egy Parse metódus (például var number = int.Parse("11")) meghívása valamivel hatékonyabb és egyszerűbb. Convert metódus használata hasznosabb az általános objektumok esetében, amelyek implementálják a IConvertible-t.

A numerikus típuson alkalmaz ható Parse vagy TryParse metódusokat használja, amelyekre számít, hogy a sztring tartalmazza, például az System.Int32 típust. A Convert.ToInt32 metódus belsőleg használ Parse . A Parse metódus a konvertált számot adja vissza; a TryParse metódus egy logikai értéket ad vissza, amely jelzi, hogy az átalakítás sikeres volt-e, és egy paraméterben out visszaadja az átalakított számot. Ha a sztring nem érvényes formátumban van, Parse kivételt jelez, de TryParse visszaadja false. Metódus meghívásakor Parse érdemes kivételkezelést alkalmazni, ha az FormatException elemzési művelet sikertelen.

Borravaló

Az AI-segítség segítségével számmá alakíthat egy sztringet.

Hívd meg a Parse vagy TryParse metódusokat

A Parse és TryParse metódus figyelmen kívül hagyja a sztring elején és végén lévő üres szóközt, de minden más karakternek a megfelelő numerikus típust alkotó karaktereknek kell lennie (int, long, ulong, float, decimal, stb.). A számot formázó sztringen belüli üres szóköz hibát okoz. Például használhatja a decimal.TryParse segítségével a "10", "10.3" vagy " 10 " elemzésére, de ezzel a módszerrel nem tudja elemezni a 10-et a "10X", "1 0" (vegye figyelembe a beágyazott szóközt), a "10 .3" (vegye figyelembe a beágyazott szóközt), "10e1" (ehhez float.TryParse működik), és így tovább. Az a sztring, amelynek értéke null vagy String.Empty, nem dolgozható fel sikeresen. A metódus meghívásával ellenőrizheti, hogy van-e null vagy üres sztring, mielőtt megkísérelné elemezni.String.IsNullOrEmpty

Az alábbi példa a sikeres és sikertelen hívásokat ParseTryParsemutatja be.

using System;

public static 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.

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

Az alábbi példa egy olyan sztring elemzésének egyik megközelítését szemlélteti, amely az első numerikus karaktereket (beleértve a hexadecimális karaktereket) és a záró nem numerikus karaktereket is magában foglalja. A TryParse metódus meghívása előtt a karaktersorozat elejétől érvényes karaktereket rendel egy új karaktersorozathoz. Mivel az elemezni kívánt sztringek néhány karaktert tartalmaznak, a példa meghívja a String.Concat metódust, hogy érvényes karaktereket rendeljen egy új sztringhez. Nagyobb sztring esetén az StringBuilder osztály használható helyette.

using System;

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

Konvertálási metódusok meghívása

Az alábbi táblázat felsorol néhány metódust az Convert osztályból, amelyekkel sztringet alakíthat számmá.

Numerikus típus Metódus
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)

Az alábbi példa a Convert.ToInt32(String) metódust hívja meg egy bemeneti sztring egész számra (int) konvertálására. A példa a metódus által leggyakrabban kiváltott két kivételt kezeli: FormatException és OverflowException. Ha az eredményül kapott szám túllépése Int32.MaxValuenélkül növelhető, a példa 1-et ad hozzá az eredményhez, és megjeleníti a kimenetet.

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 {++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

Sztring számmá alakítása AI használatával

Az AI-eszközök, például a GitHub Copilot használatával C#-kódot hozhat létre egy sztring számmá alakításához. A kérés testreszabható, hogy a követelményeknek megfelelően karakterláncot használjon.

Az alábbi szöveg egy példakérést jelenít meg a Copilot-csevegéshez:

Show me how to parse a string as a number, but don't throw an exception if the input string doesn't represent a number.

A GitHub Copilot mesterséges intelligenciával működik, így meglepetések és hibák lehetségesek. További információ: Copilot gyakori kérdések.

Lásd még