Konvertera en sträng till ett tal (C#-programmeringsguide)

Du konverterar en string till ett tal genom att anropa Parse metoden eller TryParse som finns på numeriska typer (int, long, doubleoch så vidare) eller med hjälp av metoder i System.Convert klassen.

Det är lite mer effektivt och enkelt att anropa en TryParse metod (till exempel int.TryParse("11", out number)) eller Parse -metod (till exempel var number = int.Parse("11")). Att använda en Convert metod är mer användbart för allmänna objekt som implementerar IConvertible.

Du använder Parse eller TryParse metoder för den numeriska typ som du förväntar dig att strängen innehåller, till exempel System.Int32 typen . Metoden Convert.ToInt32 använder Parse internt. Metoden Parse returnerar det konverterade talet. TryParse Metoden returnerar ett booleskt värde som anger om konverteringen lyckades och returnerar det konverterade talet i en out parameter. Om strängen inte är i ett giltigt format Parse genererar ett undantag, men TryParse returnerar false. När du anropar en Parse metod bör du alltid använda undantagshantering för att fånga en FormatException när parsningsåtgärden misslyckas.

Anropa parsnings- eller TryParse-metoder

Metoderna Parse och TryParse ignorerar blanksteg i början och i slutet av strängen, men alla andra tecken måste vara tecken som utgör lämplig numerisk typ (int, long, ulong, float, decimaloch så vidare). Ett tomt utrymme i strängen som utgör talet orsakar ett fel. Du kan till exempel använda decimal.TryParse för att parsa "10", "10.3" eller " 10 ", men du kan inte använda den här metoden för att parsa 10 från "10X", "1 0" (notera det inbäddade utrymmet), "10 .3" (observera det inbäddade utrymmet), "10e1" (float.TryParse fungerar här) och så vidare. En sträng vars värde är null eller String.Empty inte kan parsas. Du kan söka efter en null- eller tom sträng innan du försöker parsa den genom att anropa String.IsNullOrEmpty metoden.

I följande exempel visas både lyckade och misslyckade anrop till Parse och 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.
    }
}

I följande exempel visas en metod för att parsa en sträng som förväntas innehålla inledande numeriska tecken (inklusive hexadecimala tecken) och avslutande icke-numeriska tecken. Den tilldelar giltiga tecken från början av en sträng till en ny sträng innan metoden anropas TryParse . Eftersom strängarna som ska parsas innehåller några tecken anropar String.Concat exemplet metoden för att tilldela giltiga tecken till en ny sträng. För en större sträng StringBuilder kan klassen användas i stället.

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

Anropa konvertera metoder

I följande tabell visas några av metoderna från klassen Convert som du kan använda för att konvertera en sträng till ett tal.

Numerisk typ	Metod
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)

I följande exempel anropas Convert.ToInt32(String) metoden för att konvertera en indatasträng till en int. Exemplet fångar de två vanligaste undantagen som genereras av den här metoden: FormatException och OverflowException. Om det resulterande talet kan ökas utan att överskrida Int32.MaxValuelägger exemplet till 1 i resultatet och visar utdata.

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