Come convertire una stringa in un numero (Guida per programmatori C#)

Un oggetto string può essere convertito in un numero chiamando il metodo Parse o TryParse relativo ai tipi numerici (int, long, double e così via) o usando i metodi della classe System.Convert.

Le chiamate al metodo TryParse (ad esempio, int.TryParse("11", out number)) o al metodo Parse (ad esempio, var number = int.Parse("11")) sono leggermente più semplici ed efficienti. L'uso di un metodo Convert è più utile per gli oggetti generali che implementano IConvertible.

I metodi Parse o TryParse vengono applicati al tipo numerico che si prevede sia contenuto nella stringa, ad esempio il tipo System.Int32. Il metodo Convert.ToInt32 utilizza il metodo Parse internamente. Il metodo Parse restituisce il numero convertito, mentre il metodo TryParse restituisce un valore booleano che indica se la conversione è riuscita e restituisce il numero convertito in un parametro out. Se il formato della stringa non è valido, il metodo Parse genera un'eccezione, mentre TryParse restituisce false. Quando si chiama un metodo Parse, è sempre consigliabile usare la gestione delle eccezioni per intercettare FormatException in caso di esito negativo dell'operazione di analisi.

Chiamare i metodi Parse o TryParse

I metodi Parse e TryParse ignorano lo spazio vuoto all'inizio e alla fine della stringa, ma tutti gli altri devono essere caratteri che costituiscono il tipo numerico appropriato (int, long, ulong, float, decimal e così via). Gli spazi vuoti all'interno della stringa che sostituisce il numero generano un errore. È ad esempio possibile usare decimal.TryParse per analizzare "10", "10,3" o "10", ma non è possibile usare questo metodo per ottenere 10 da "10X", "1 0" (si noti lo spazio interno), "10 ,3" (si noti lo spazio interno), "10e1" (in questo caso, float.TryParse funziona) e così via. Una stringa con valore null o String.Empty non viene analizzata correttamente. È possibile cercare una stringa vuota o Null prima di tentare di analizzarla chiamando il metodo String.IsNullOrEmpty.

L'esempio seguente illustra le chiamate con esito positivo e negativo per Parse e 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.
    }
}

Nell'esempio seguente viene illustrato un approccio per l'analisi di una stringa che si prevede includa caratteri numerici iniziali (inclusi caratteri esadecimali) e caratteri non numerici finali. I caratteri validi dall'inizio di una stringa vengono assegnati a una nuova stringa prima di chiamare il metodo TryParse. Poiché le stringhe da analizzare contengono alcuni caratteri, l'esempio chiama il metodo String.Concat per assegnare caratteri validi a una nuova stringa. Per una stringa più grande, è invece possibile usare la classe StringBuilder.

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

Chiamare i metodi della classe Convert

Nella tabella seguente sono elencati alcuni dei metodi della classe Convert che è possibile usare per convertire una stringa in numero.

Tipo numerico	metodo
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 questo esempio viene chiamato il metodo Convert.ToInt32(String) per convertire una stringa di input in un tipo int. L'esempio rileva le due eccezioni più comuni generate da questo metodo: FormatException e OverflowException. Se il numero risultante può essere incrementato senza superare Int32.MaxValue, l'esempio aggiunge 1 al risultato e visualizza l'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