Jak převést řetězec na číslo (Průvodce programováním v C#)

Převedete číslo string voláním Parse nebo TryParse metodou nalezenou u číselných typů (int, long, doubleatd.) nebo pomocí metod ve System.Convert třídě.

Volání metody (například) nebo Parse metody (napříkladvar number = int.Parse("11")) je o něco efektivnější a jednodušší TryParse . int.TryParse("11", out number) Convert Použití metody je užitečnější pro obecné objekty, které implementují IConvertible.

U číselného typu, který očekáváte, že řetězec obsahuje, například System.Int32 typ, použijete Parse nebo TryParse použijete metody. Metoda Convert.ToInt32 se používá Parse interně. Metoda Parse vrátí převedené číslo; TryParse metoda vrátí logickou hodnotu, která určuje, zda byl převod úspěšný, a vrátí převedené číslo v parametru out . Pokud řetězec není v platném formátu, Parse vyvolá výjimku, ale TryParse vrátí falsehodnotu . Při volání Parse metody byste měli při selhání operace analýzy vždy použít zpracování FormatException výjimek.

Volání metod Parse nebo TryParse

TryParse Metody Parse ignorují prázdné znaky na začátku a na konci řetězce, ale všechny ostatní znaky musí být znaky, které tvoří příslušný číselný typ (int, , long, ulongfloat, decimalatd.). Jakékoli prázdné znaky v řetězci, který tvoří číslo, způsobí chybu. Můžete například použít k parsování "10", "10,3" nebo " 10 ", ale tuto metodu nemůžete použít decimal.TryParse k parsování 10 z "10X", "1 0" (všimněte si vloženého prostoru), "10 ,3" (poznámka: vložené místo), "10e1" (float.TryParse pracuje zde) atd. Řetězec, jehož hodnota je null nebo String.Empty se nepodaří úspěšně analyzovat. Před pokusem o jeho parsování můžete zkontrolovat hodnotu null nebo prázdný řetězec voláním String.IsNullOrEmpty metody.

Následující příklad ukazuje úspěšné i neúspěšná volání a Parse TryParse.

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

Následující příklad ukazuje jeden přístup k analýze řetězce, u které se očekává, že bude obsahovat počáteční číselné znaky (včetně šestnáctkových znaků) a koncové nečíselné znaky. Před voláním TryParse metody přiřadí k novému řetězci platné znaky od začátku řetězce. Vzhledem k tomu, že řetězce, které mají být analyzovány, obsahují několik znaků, příklad volá metodu String.Concat pro přiřazení platných znaků k novému řetězci. Pro větší řetězec StringBuilder lze místo toho použít třídu.

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

Volání metod Convert

Následující tabulka uvádí některé metody z Convert třídy, které můžete použít k převodu řetězce na číslo.

Následující příklad volá metodu Convert.ToInt32(String) pro převod vstupního řetězce na int. Příklad zachytí dvě nejběžnější výjimky vyvolané touto metodou: FormatException a OverflowException. Pokud je možné výsledné číslo zvýšit bez překročení Int32.MaxValue, přidá příklad k výsledku hodnotu 1 a zobrazí výstup.

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

Převod řetězce na číslo pomocí GitHub Copilotu

Pomocí GitHub Copilotu v integrovaném vývojovém prostředí (IDE) můžete vygenerovat kód pro převod řetězce na číslo v jazyce C#.

Pokud používáte Visual Studio 2022 verze 17.8 nebo novější, můžete zkusit v sadě Visual Studio vygenerovat kód pro převod řetězce na číslo pomocí githubového copilotu řízeného AI. Odešlete otázku jako výzvu v okně chatu Copilot, jak je znázorněno v následujícím příkladu. Můžete také odesílat výzvy pomocí vloženého chatu v samotném okně editoru.

Následující text ukazuje příklad výzvy ke kopírování chatu:

Vygenerujte kód jazyka C#, který převede řetězec "123" na číslo pomocí tryParse. Zadejte příklad výstupu.

Výzvu můžete přizpůsobit tak, aby používala řetězec podle vašich požadavků.

Pomocí funkcí chatu, jako jsou příkazy lomítka, odkazy na soubory, metody nebo třídy a vlákna, můžete nastavit záměr a získat lepší odpovědi s vymezeným kontextem. U existujícího souboru, který je otevřený v integrovaném vývojovém prostředí, můžete pomocí vloženého chatu /generate code to convert the string string1 in #Filename to a numberzobrazit příkaz GitHub Copilot .

Následující výstup ukazuje příklad odpovědi copilot chatu:

Here is a C# code snippet to convert the string "123" to a number using TryParse:

using System;

class Program
{
    static void Main()
    {
        string numberString = "123";
        int number;
        bool success = int.TryParse(numberString, out number);
        
        if (success)
        {
            // Example output
            Console.WriteLine("The converted number is: " + number);
        }
        else
        {
            Console.WriteLine("Conversion failed.");
        }
    }
}

When you run this code, the output will be:
The converted number is: 123

Když Copilot vrátí blok kódu, odpověď obsahuje možnosti pro zkopírování kódu, vložení kódu do nového souboru nebo náhled výstupu kódu.

Další informace naleznete v tématu:

• Centrum zabezpečení GitHub Copilot
• GitHub Copilot v sadě Visual Studio
• GitHub Copilot ve VS Code